April 2021 Summaries

This tutorial demonstrates how to stream audio into a call using the Nexmo Voice API, allowing users to play holding music or messages during calls, and even place callers into a conference while streaming audio. The application uses Java with the Spark framework, utilizes the Nexmo client library for authentication and configuration settings, and requires a Vonage API account, virtual phone number, and ngrok for public accessibility. The code guides users through creating a Voice API application, linking their Nexmo number, answering an inbound call, playing audio into the conference, and testing the application. By following this tutorial, developers can create a custom Java application to enhance their Nexmo Voice API experience.

This application allows users to check the status of a given line on the London Underground by sending an SMS with the line name. The application uses the Vonage SMS API and the Transport for London (TFL) API to retrieve real-time data about the status of the tube line chosen by the user. When an inbound message is received, the application checks if the line name matches any of the valid values in the `lines` array. If it does, the application sends a message back to the user with the current status of the line. Otherwise, it sends a message providing the valid values. The application can be deployed to Heroku, where it will scale according to traffic demand and consume dyno hours only when running.

You can send a text message through your Vonage virtual number using their SMS API, but it's not possible to confirm if the message was actually delivered without access to the device associated with that number. However, many networks will provide a delivery receipt programmatically, which you can access and display in your application. To request a delivery receipt, you need to create a publicly-accessible webhook and configure your Vonage account to use it. You'll need to make your webhook accessible by using ngrok during development, and then tell Vonage to use the URL of your webhook in their dashboard settings page. By setting up your application to handle both GET and POST requests on your webhook endpoint, you can capture delivery receipts regardless of the HTTP method used to send them.

This tutorial provides a comprehensive guide on how to create an in-browser voice chat application using Nexmo's API and Vue.js, with Express.js as the server-side framework. The application allows users to join or create conversations, authenticate themselves with a JWT token, and manage audio playback. The tutorial covers setting up the project, creating the server-side API endpoints, implementing the client-side UI components, and connecting the two. It also discusses how to add features such as user management, message sending, and call handling. The application is designed to be scalable and maintainable, with a focus on separation of concerns between the client and server sides.

This tutorial demonstrates how to integrate calls into an iOS application using a custom UI component called NXMCallButton, which is a subclass of UIButton. The button can be configured to call either in-app users or PSTN numbers. To complete the tutorial, you need a Vonage API account and a virtual phone number. The project uses CocoaPods for dependency management and requires microphone usage permission. The NXMCallButton component can be added to the user interface using either Storyboard or programmatically.

You've built an application that allows you to call your YNAB budget and make sure that you've got enough left in your chosen category before making a purchase. The application uses the Nexmo voice API, Google's speech-to-text API, and the YNAB API to provide real-time call transcription and audio feedback on an active voice call. You've wired up these APIs using their websockets to enable this functionality. The application can also be used with the Monzo API by replacing the YNAB API credentials with a Monzo access token.

You can add Viber communication to your Node.js app by setting up a Vonage API account and using their sandbox service, which allows you to send messages without a business profile. To start, create an axios client and provide the necessary data, including username and password, from ID, and to number. Then, make a POST request to the Messages API with the data object and options object for authentication. The response will include a message UUID, which can be logged to the console. Once set up, you can run your code by executing node app.js, and receive your test message in Viber on the whitelisted device.

This series of tutorials will explore the Vonage Video API (formerly TokBox OpenTok) and what you can build with it. The Video API is very robust and highly customizable, and in each post we’ll show how to implement a specific feature using the API. This time we will look at how to add texting to a basic audio-video chat. As this application will require some server-side code, we will use Glitch for ease of setup. You can also download the code from this Glitch project and deploy it on your own server or hosting platform of choice (may probably require some configuration tweaking based on the requirements of your platform). We will not be using any front-end frameworks for this series, just vanilla Javascript to keep the focus on the Video API itself. At the end of this tutorial, you should be able to have an audio-video chat application with text chat functionality. Text chat is implemented using the signaling API. The final code for this application can be found in this GitHub repository or remixed on Glitch. You will need a Vonage Video API account, which you can create for free here. You will also need Node.js installed (if you are not using Glitch). This tutorial builds on the first introductory post in the series: Building a Basic Video Chat. If this is your first time using the Video API, we highly suggest you go through that because it covers the basic setup: Create a Vonage Video API project, setting up on Glitch, basic project structure, initializing a session, connecting to the session, subscribing and publishing, basics of Text Chat With Vonage Video API. Implementing text chat with the Video API is done via the signalling API. This signalling mechanism allows clients connected to a session to send text and data to each other. We will only focus on text for now. The Video API Client SDK will dispatch an event when the client receives a signal. For a basic text chat where messages are visible to all connected clients, we will use the signal() method of the Session object. Participating clients will receive that signal by listening to the signal event dispatched by the Session object. We need another event listener to receive that message by listening to the signal event dispatched by the Session object. The data payload from that event will be used to print the message into the message area of the chat window. To make the chat more user-friendly, we also want to add a means of identifying who said what in the chat. We will make use of the user name input on the landing page to get that information, passing it on to the server as a query string in the URL. The following script on the landing.html page passes the room name and user name entered to the index.html page. When the index.html page loads, it will trigger a POST request to the session/:name route, extracting the submitted user name from the URL and passing it onto the server. We can make use of the stream name in the response to label streams so participants can hover over each participant's video stream to see a name. Both the initPublisher() method and the subscribe() method accepts an optional properties argument, which allows us to pass in customisation options for the stream. When participants send text messages, we want to POST them to the server to be stored in the database. We can save messages into the database by creating a saveMessage() function to do that. The final code on Glitch and GitHub contains everything we covered in this fairly lengthy post but re-organised so the code is cleaner and more maintainable. There are additional functionalities we can build with the Vonage Video API which will be covered in future tutorials, but in the meantime, you can find out more at our comprehensive documentation site. If you run into any issues or have questions, reach out to us on our Community Slack. Thanks for reading!

This tutorial guides developers in making an SMS-based queue management application with Python and Flask more production-ready by Dockerizing it and deploying it to Heroku. The application uses a virtual phone number, Vonage API account, and a Postgres database for scalability. To make the application secure, secrets are managed using environment variables, and sensitive information is stored in a .env file. The tutorial covers setting up a Dockerfile, configuring an application server with Gunicorn, and deploying the container to Heroku. With these steps, developers can create a production-ready application that is easily scalable and replicable.

Tucuvi is an AI-powered virtual caregiver that uses voice technology to augment healthcare professionals' capacity and provide continuous care for the elderly and chronic patients at home, addressing the issue of lack of continuous monitoring for patients with chronic conditions. The company has developed a disease-agnostic monitoring platform that can be used by healthcare organizations without any hardware investment, differentiating it from competitors. Tucuvi has received funding from various investors, including Bootstrap, VC/Angel, and FFF, and is currently testing its platform in renowned hospitals in Spain, aiming to position itself as the golden standard for clinical monitoring in 3 years.

A tutorial is provided on how to create a callback script that interacts with a caller to prompt for a voice message, then retrieves the contents of the recording and requests a voice transcription from Amazon Transcribe using Nexmo's Voice service. The tutorial covers setting up an AWS account, creating an S3 bucket, and configuring IAM credentials to access Amazon Transcribe and S3. It also explains how to set up ngrok to make the local application available on the internet, create a Vonage API account, and install required dependencies using Composer. The script uses Slim as a microframework to handle HTTP calls and callbacks, and includes route-based middleware to handle Nexmo's status updates, fetching recordings, and requesting transcription from Amazon Transcribe.

This tutorial series aims to help developers get started with Nexmo's Voice API using Node-RED, a visual programming tool. The goal is to play an audio file to a caller during an inbound call or stream audio into a call for an outbound call. To achieve this, developers need to set up their environment by installing the necessary nodes and exposing their local server to the internet using tools like ngrok. They also need to create a Nexmo application and link their virtual number to it. The tutorial covers building a Nexmo Call Control Object (NCCO) to control the call flow and making an outbound call using the `createcall` node. Throughout the process, developers can follow along with example flows and use pre-built nodes to simplify the development experience.

The Nexmo Elixir SDK allows developers to send SMS messages in Elixir, leveraging the Vonage API. To get started, you need an Elixir installation, a Vonage API account, and a Nexmo virtual phone number. The process involves setting up your code structure with three files (mix.exs, send-sms.ex, and .env), defining your Mix file dependencies, integrating environment variables from the .env file, creating your Elixir code with the SendSms module, and running the application in an interactive Elixir shell to send the first SMS message.

This tutorial guides developers on how to create a voicemail application using Nexmo Voice APIs and ASP.NET Core, allowing customers to leave messages for a specific phone number. The project uses NancyFX to handle HTTP requests and creates a route to /webhook/answer, which responds with an NCCO returned by the GetVoiceMailNCCO() method. The tutorial also covers configuration steps such as linking a Nexmo account to a phone number, setting up an answer URL using Ngrok, and exposing the webhook endpoint for testing. With this application, customers can leave messages that will be stored in a recording and sent to another route for further processing.

Microsoft.Extensions.Logging provides a flexible and extensible logging framework for .NET applications, allowing developers to abstract the logger from the logging operation itself. This approach enables users to bring their own custom logging frameworks without modifying the SDK's codebase. The library allows developers to create fully dynamic, extensible loggers that can be easily configured and customized to meet specific requirements. By using Microsoft.Extensions.Logging, developers can avoid common issues such as switching between different loggers or dealing with legacy logger implementations. The framework is designed to be agonistic to the chosen log provider, making it easy for users to integrate their preferred logging solution into the SDK.

The Nexmo Voice API allows for recording inbound and outbound telephone calls, but manually classifying these recordings based on their content can be time-consuming. To automate this process, a tutorial is provided on using Natural Language Processing via Google Cloud Services to classify the content of each recording. The tutorial requires a Vonage API account, a virtual phone number, and enables two Google Cloud Services APIs: Cloud Speech-to-Text and Cloud Natural Language. It uses Flask to serve an NCCO file, instructing Nexmo to record calls, and Huey for background tasks to download the recordings, transcribe them into text, and classify their content using the Google Cloud services. The tutorial also includes code examples and instructions on how to set up the necessary environment and credentials.

I am Nick Iati, a technical writer joining Nexmo Developer Relations as part of the Vonage Business Cloud APIs team, based in Rochester, NY; I hold degrees in Communication and Professional and Technical Communication from SUNY at Buffalo and New Jersey Institute of Technology respectively; prior to this role, I worked as a systems analyst and product manager for companies such as Fujifilm and Ellucian; my experience includes managing API-centric SaaS solutions for higher education institutions and overseeing technical documentation and training efforts; in my free time, I enjoy traveling, reading, and spending quality time with family and friends.

Vonage has announced the introduction of Custom Channels, a new feature that allows developers to create custom integrations with various channels using custom events. With this feature, developers can send and receive data between their applications and other platforms, such as messaging platforms, emails, or payments, using a standardized format. The feature is available through Vonage's Conversations API and Client SDKs, and provides an efficient way to integrate different services into conversation experiences. To use Custom Channels, developers need to define a custom event type, send the event with relevant data, and receive the event on their application's RTC event_url. Additionally, push notifications can be sent for mobile apps running in the background, allowing users to receive notifications about incoming custom events.

Kevin Lewis is excited to join the Developer Relations team at Nexmo, bringing his experience in supporting the local tech community in London and organizing events such as You Got This, a network of conferences on core skills for happy work lives. The former Developer Advocate for Vonage has also held roles in improving public services and working with student community leaders, and has an interest in creating novel playable experiences with tech. He is now looking to support the London tech community in his new role at Nexmo, and can be reached on Twitter for connections.

As a seasoned educator with experience in software development, Nahrin brings a unique perspective to the Nexmo Developer Education team, having taught students of varying demographics and co-ordinated numerous technical workshops and events. With a passion for cutting-edge technology and education, they aim to create resources that inspire developers using Nexmo's communications APIs, leveraging their skills in React.js and Python to build a STEM learning management system. Nahrin is excited to join the team and connect with the developer community on Twitter or the Nexmo Community Slack, looking forward to sharing knowledge and experiences.

The Vonage Video API and Azure Face API are used together in this tutorial to build a multi-party video conference that analyzes the sentiment of each participant based on their facial expression. The code sets up an OpenTok session, subscribes to it, and connects to it using the provided tokens. It then uses JavaScript to capture images from each stream, send them to Azure Face API for emotion detection, and display the identified emotions as emojis next to the corresponding video streams. The `processImages` method is called when the "Analyze" button is clicked, which clears any existing emojis and gets all HTML video tags in the DOM, sending them to the `sendToAzure` method to be processed. However, there are limitations to this code, such as it only adding an emoji for the first face detected by Azure Face API if multiple faces are present.

The latest version of OpenTok, v2.16, has been released to coincide with Safari version 12.1, bringing several new features including support for VP8 Video Codec on iOS and macOS, enabling full interoperability between all browsers and old Android devices that do not support H.264 encoding. Additionally, experimental screen sharing support has been added, as well as scalable video support through simulcast technology, which helps to improve video quality by adapting to the network or processing capacity of each subscriber. The release also includes Unity samples for integrating OpenTok with Unity3d on various platforms in beta.

We've recently released v2.6.0 of our Node.js SDK and added the ability to change the host used for making HTTP requests. This feature allows developers to override the default hosts, api.nexmo.com and rest.nexmo.com, in the SDK, enabling them to bypass the load balancer and make requests towards specific data centers or proxies. By adding an options object to the Nexmo instance with an apiHost property, developers can specify a custom host for their API requests. The new feature also supports using curlhub as a proxy to inspect API traffic before it reaches the Nexmo API. To use this feature, developers need to add the apiHost and restHost properties to their Nexmo instance, followed by a bucket ID from curlhub appended to the specified hosts. The updated SDK can be tracked on GitHub, and developers are encouraged to provide feedback or suggest improvements.

At Nexmo, we love sharing code with our developer communities. Usually, this means publishing to a git repo on GitHub so that any developer that wants to use the code can go ahead and do so. We realized though that now we have around 300 repositories between a few different GitHub organizations, it can be tricky to find what you need and also to understand how to use each project unless there are good instructions. To make the Developer Experience even better for everyone, we created and then publicly shared our Repository Standards. We recognized three types of project that we publish often and adjusted our guidelines for each type, including SDKs, demo applications, and other types of projects. We took particular care with installation instructions and licensing to ensure community can build on our SDKs with confidence. Having a clear statement of the features and purpose of the project is really important in a repository like this. We also worked on licensing and on including either docker setups or "click to deploy" buttons to allow users to try out what we had made for them. The goal was to capture a shared checklist of things we think are important when we publish a repository, making it easier for developers to find our projects on GitHub. We started with a basic README template and guidelines, including a checklist, to remind us to link to developer documentation and tell users how to get in touch if they needed to. The details here are small things, but they do matter, helping to orientate developers on where they are, what this repository is about, and where they might go next.

We are pushing out a new version of the .NET server SDK—version 4.3.0, with two new core features: Generate JWTs directly from the SDK and list owned numbers using Nexmo's SDK for easy management.` `The Generate JWT feature avoids the need to implement custom logic when using beta SDKs like Messages and Dispatch, while the List Owned Numbers feature enables users to monitor and manage their own numbers directly from Nexmo without purchasing or saving them.` `For real-time updates on the .NET SDK, follow it in GitHub: https://github.com/Nexmo/nexmo-dotnet. Users can also reach out to Steve Lorello for assistance with any questions or concerns through community slack.

Distributed Ledger Technology (DLT) is a digital method that allows users and systems to record transactions related to their assets in multiple locations, providing better security, transparency, and trust amongst parties. In India, the Telecom Regulatory Authority of India (TRAI) requires any domestic enterprise sending Application 2 Phone (A2P) SMS through domestic connections to pre-register with DLT. To comply with this regulation, enterprises must register their Principal Entity, Headers, Templates, and provide consent on a listed DLT system. Vonage provides an API account and SDKs that can be used to send DLT-compliant SMS messages, requiring the addition of two parameters (entity-id and content-id) to every request or SMPP request. Enterprises can use Vonage's temporary solution to let Vonage manage DLT for them, but it is recommended to update their project and use the new API parameters to comply with the regulation. A webhook can be used to receive SMS delivery receipts and verify if an SMS message was sent successfully.

This hotline application uses OpenTok for video chat and Nexmo for sending texts. It allows users to ask questions, receive answers from volunteers, and connect with each other in real-time using their webcams. The application includes features such as a simple interface for users to ask questions, provide phone numbers to receive text notifications when there are no questions, and a way for volunteers to provide their phone numbers to receive notifications when they can answer questions. The application is built on top of Express.js, Glitch, and uses the OpenTok and Nexmo APIs to handle video chat and text messaging functionality.

To access and analyze session-level video data with GraphQL and Advanced Insights, users must first understand how GraphQL works and how to query their project's data using the Insights GraphiQL Explorer. Advanced Insights relies on GraphQL for making queries to access Vonage Video API data, and users can start by querying session IDs, sessions, meetings, publishers, and stream data to retrieve various types of video metrics such as bitrate information. The process involves specifying a project ID, date range, and fields required in the query, and running the query in the Insights GraphiQL Explorer to obtain the desired data. With this knowledge, users can create their own custom queries and start analyzing their customers' video application experience using Advanced Insights.

The author of the text created a React app that analyzes the sentiment of a user's recent tweet on Twitter using Microsoft Azure's Text Analytics API, and then sends an SMS report to the user via Nexmo's Messages API. The app is built with Express.js as the backend server. The author used RapidAPI to connect to the Azure API. The app allows users to input their Twitter handle, retrieve their most recent tweet, calculate its sentiment score, and send the result to their phone number. The sentiment analysis is based on a numeric scale from 0 to 1, where 0 is negative and 1 is positive. The author also added some logic to analyze the sentiment score and assign an emoji to it.

Enabling message signing on a Vonage account is crucial for securing incoming webhooks, as it ensures that data originates from Vonage's servers and has not been tampered with. To enable this feature, users must request it through an email to [email protected] and set up the signature secret in the dashboard settings page. The shared secret is used to calculate signatures on both server and client sides, preventing unauthorized access or tampering with incoming data. When an SMS arrives, Vonage sends a webhook containing message data and a calculated signature, which can be verified by the receiving application using the same algorithm and secret. This process protects against timing attacks and malicious incoming data, making secure applications happy ones.

A WordPress plugin is created using a boilerplate, which provides a standard structure and files. The Nexmo PHP Library is installed via Composer, and its API is initialized in the plugin's constructor. The plugin listens to WooCommerce order status changes by hooking into the `woocommerce_order_status_` action. When an order status changes, the plugin sends an SMS notification to the customer using Nexmo's SMS API. The plugin also adds an order note with a message indicating whether the notification was successful or not.

I made a setup using Zapier and Vonage to send an SMS whenever I press a smart button, which uses no code at all. To complete this tutorial, one needs a Vonage API account and a virtual phone number. The process starts by setting up a Zapier trigger with the flic button as input, then configuring the SMS to send using the Vonage API account information. This allows for customization of the message, including the "From" field which can be either an owned or purchased number, the "To" field with the recipient's E.164 format number, and the "Text" field where the message is composed. Once set up, turning on the Zap and giving it a name makes it easy to send an SMS whenever the button is pressed, using no code.

Sentiment analysis is crucial in understanding the emotions and intentions behind text-based communications, such as SMS messages. It can help bridge the gap between what we say and what we mean, particularly in professional settings where tone can easily be misinterpreted. Leveraging IBM Watson's Tone Analyzer service, a PHP application can be set up to analyze the sentiment of incoming SMS messages using Vonage's SMS service, demonstrating how sentiment analysis can be integrated into applications to improve communication intent understanding. The example utilizes ngrok to make the local application accessible over the internet and Composer for dependency management, showcasing a straightforward approach to implementing this functionality in a real-world scenario.

The Nexmo Number Insight API provides valuable information about telephone numbers, going beyond just formatting and verification. The API has three tiers: Basic, Standard, and Advanced, each offering varying levels of detail and useful data such as country origin, number type (landline, mobile, or virtual), carrier, and risk indicators. The Basic tier is free and provides international and national formatting information, while the Standard tier adds network type and carrier information. The Advanced tier offers detailed risk assessment and location checking through IP matching. By using the Number Insight API, developers can enhance their customer experience, prevent fraud, and improve risk management processes, making it a valuable tool for businesses.

This video appointments reference application provides a foundation for different implementations, allowing developers to create personalized experiences using video. The application includes essential features such as scheduling appointments in advance, messaging participants with links to join the call, and basic video call UI with buttons for muting and sharing screens. The application is customizable from a look and feel perspective, and it can be applied to various use cases, including healthcare, e-learning, finance, job interviews, and more. The application uses the Vonage Video API and Messages API, which provide WebRTC-based solutions and gateway to multiple messaging channels, respectively. The application also includes tools such as ngrok for exposing the server and Visual Studio Code for development, and it can be deployed using a 'deploy to Heroku' button on GitHub.

This tutorial series guides readers through building a clone of Slack using Vue.js and Vonage Conversation API. The first part covers setting up the project, installing dependencies, creating an Express.js server, generating a Vue.js client application, and configuring the proxy for API requests. It also introduces hot reloading, concurrent execution, and styling with Tailwind CSS. Additionally, it sets up a full-screen loading component, connects to the Vonage Conversation API, and creates a basic messaging UI. The goal is to build a chat client that resembles Slack's user experience, which will be continued in part 2.

The Social Cafe application is an online platform designed to facilitate conversations between attendees during breaks and after talks at events. The application uses the Vonage Video API to power video calls in each table. A demo version of the application is available for free, allowing users to add their own event or deploy it to Netlify. The application was built using Nuxt.js and requires a Vonage Video API account to function. It features an event lobby with multiple conversation tables, each representing a unique video call, as well as a landing page where users can input an event code to access the event lobby. Users can also create and navigate between rooms within the event, which includes a video chat feature using the iframe. The application has various features such as validating user input, storing event data in a file, and accessing room information through computed properties. With its basic implementation of video conferencing, the Social Cafe application provides a starting point for building more advanced online gathering platforms.

The application is a prototype that uses two-factor authentication (2FA) to track player progress in a game-like scenario. The 2FA system involves sending an SMS with a verification code to the player's phone number, which they must then enter into the application to authenticate their identity. The application uses Nexmo's Verify API and Messages API to handle the 2FA process. To trigger the OTP request, players submit their phone number via another web form submission. Once verified, the player is redirected to a results page where their status is displayed. Additional features can be added using Nexmo's Messages API, such as sending additional SMS containing links to verification pages. The application structure includes three main pages: login, administrator, and verification code entry pages. The application uses lowdb for storing player information and Koa.js for handling API requests and responses.

In our effort to support developer communities around the world, we’re excited to announce ways in which we are helping groups host events and engage with their community members online:` This announcement highlights Vonage's initiative to support online community engagement. `Social Cafe, an open-source demo for communities to build their own online environment, is being hosted by Vonage.` The Social Cafe Demo provides a platform for communities to create meaningful conversations between attendees, moving beyond traditional broadcasting methods. `The demo allows users to freely move between video call "tables" to chat with different community members,` enabling more interactive and engaging events. `Vonage's support includes hosting an instance of the demo at no cost, as well as providing tutorials and resources for communities to host their own version in five minutes.` This initiative aims to bridge the gap between online and offline community activities during challenging times, such as isolation.

The article explains how to build a simple IVR (Interactive Voice Response) system using Nexmo Voice and Spark Java. The goal is to create an IVR that allows users to input digits on their keypad, which will be processed by the service. To achieve this, you need to set up a Maven project, install the required dependencies, and configure Spark to host your web application. You also need to use Ngrok to expose your local development machine to the outside world. Once everything is set up, you can test your IVR system by calling the Nexmo number and entering digits on the keypad. The system responds with a message indicating the digit entered. To make it more useful, you can add functionality such as handling input events and connecting to databases. The article provides code examples and guidance throughout the process, making it accessible to developers of all levels.

This tutorial provides a comprehensive guide on how to receive SMS messages in a browser using the Vonage SMS API, Ably real-time messaging platform, Next.js, and Vercel. The app uses Ably for pub/sub messaging between users, allowing them to send and receive text messages in real-time as they are received. To build this app, developers need to create an Ably account, a virtual phone number from Vonage, and install the necessary dependencies such as Node.js, Next.js, and Vercel. The app will use Vercel's serverless functions to authenticate with Ably and handle incoming SMS messages. The tutorial covers how to set up the Ably SDK, create a serverless function to connect to Ably, and build the React component to display received SMS messages in real-time. The final step involves hosting the app on Vercel and setting up an SMS number for the app.

To get user inputs in a web app or GUI, you can use forms for structured input and flags for coded series of inputs. However, natural language input from users like SMS messages requires more advanced techniques, such as Microsoft's Language Understanding (LUIS) platform. LUIS allows you to build bots that understand the intent behind user messages and extract actionable information. By creating a LUIS app with entities and intents, you can train it on sample data and test its accuracy. In this tutorial, we built an example of how to use LUIS to process SMS messages from Vonage's API, extracting food and restaurant information and sending responses back to the sender. The demo uses ASP.NET Core and C# to integrate with the LUIS platform, and can be extended to work with other APIs and channels.

Ngrok is a cross-platform application that exposes local servers to a unique ngrok.io subdomain over secure tunnels, allowing developers to receive notifications from APIs like Nexmo without exposing their server to the internet. This can be achieved by installing the Ngrok node in Node-RED and configuring it to create an HTTP or HTTPS endpoint, making it useful for testing integrations with third-party services or APIs that require valid SSL/TLS domains. The ngrok tunnel is limited to 8 hours and requires a unique subdomain each time, but can be extended by creating a free account on the Ngrok dashboard. The tool also comes with features such as a dashboard to inspect tunnel status, replay requests, and valuable insight into API interactions, making it a powerful solution for quick demos and simple tunnelling needs.

This tutorial explains how to build a React Native iOS app using the Vonage Client SDK, which allows users to make phone calls to physical phone numbers. To complete this tutorial, you need to set up several prerequisites such as Xcode 12, a GitHub account, Cocoapods, Homebrew, and a Vonage API account with an API Key and API Secret. You also need to create a virtual phone number and install the necessary dependencies for React Native. The app uses a webhook server to receive incoming calls from Vonage and then connects the call to the PSTN phone number. To run the project, you need to start Metro with `npx react-native start` and then open a new terminal window to run `npx react-native run-ios`. The app allows users to place phone calls using their virtual phone number. The tutorial also covers how to communicate with native code using NativeModules and EventEmitter API, which is essential for integrating the JavaScript code with the native iOS code.

This tutorial series explores the Vonage Video API (formerly TokBox OpenTok) and its capabilities for building robust and customizable video chat applications. The series starts with creating a basic audio-video chat application using Glitch, a Node.js server, and vanilla JavaScript, and then moves on to implementing more advanced features such as session creation, token generation, and streaming. The tutorial covers the basics of how the Vonage Video API works, including initializing a session, connecting to it, publishing and subscribing to streams, and handling errors. It also provides a comprehensive overview of the API's capabilities and limitations, as well as resources for further learning and troubleshooting.

Vonage uses OpenAPI to describe its APIs and has created a Postman Collection for easy exploration and evaluation. To use this collection, you need a Vonage API account with an API Key and Secret, as well as a virtual phone number. Postman supports environment, global, and collection-level variables, which enable dynamic filling of parameter values, making tasks smoother and less painful. Chaining requests can also be used to handle multi-step prerequisites, allowing for scripting in JavaScript using the Pre-Request Script or Tests area. The Request Body section provides a concise example of how to use these features to make a text-to-speech voice call. By sharing the collection, others can easily fill in missing variable values and press the Send button.

A Vonage Video publisher tutorial is provided, covering the creation of a web application that overlays text or an image onto a user's camera stream in real-time, and includes it in a video call session using the Vonage Video API. The tutorial requires several components, including a video element, canvas elements, and JavaScript functions to manipulate the video stream and add text or images to the canvas. Once the desired output is created on the canvas, it can be used as a source for a Vonage Video API publisher. The tutorial includes scaffold markup, code examples, and instructions on how to include the canvas in a video API session, hide elements, and publish from the second canvas.

The Nexmo team is re-writing their CLI tool, which they have been using for about 4 years, and has been written in Node.js. They analyzed several frameworks to build a new Command-Line Interface (CLI) that meets their requirements. The criteria included features such as language support, maintenance status, sub-commands, output formats, plugins, aliasing, bin generation, config management, Windows support, autocomplete, interactivity, global flag definition, and cross-platform compatibility. After narrowing down the options to six libraries, they built proof of concepts (PoCs) for oclif, caporal, and ink to compare their pros and cons. The team chose to go ahead with building the next Nexmo CLI using oclif due to its great support and documentation, actively maintained status, and growing community. They are also adding full support for TypeScript to their Node.js SDK to keep the same stack across their SDK and CLI.

With the current global situation, most countries are in some form of lockdown. Social distancing is critical right now to reduce the impact of Covid-19. While some of us may have packed calendars of virtual hangouts, others may not have such a large pool of people to call or connect with to pass the time. My grandmother, for example, isn't very technical, so is reliant on phone calls. Although she is lucky enough to have thirteen grandchildren, she often says she hasn't heard from anyone some days and would like to speak to someone daily. At Vonage, we have regular opportunities to build something for our learning. In this opportunity, I chose to create a befriending service, which would introduce users that are vulnerable, lonely, or want a different person to talk to daily. The idea behind this is to enable people to make new friends while in lockdown, or at any time.

The DMS Accelerator is a European online accelerator program that supports data-driven startups and small-medium sized businesses in accelerating their business through sales, marketing, financing, and standardization. The program provides tailor-made coaching and mentoring, sales training, marketing, and connections with investors to help participants gain traction in terms of financing, revenue generation, customers, and market visibility. Founders participating in the program can expect to see progress faster than working with big organizations, changes implemented quickly, and a balance between clever decision making and trial and error. The most challenging part for startups is finding this balance, while the accelerator helps them work on it. The DMS Accelerator focuses on supporting European data-driven startups and SMEs, and its main goal is to support the competitiveness of the European data market. The program has a strong track record of success with companies such as Yosh.ai, Memoresa, and Mediscen, which have seen significant traction and growth after participating in the accelerator. When considering an accelerator, founders should consider the time they need to invest, whether there is a fit between the program's services and their current challenges, and any costs associated with the accelerator.

The code provided is for a PHP application that can receive inbound calls and capture user input entered via the keypad, utilizing the Vonage API and the Slim framework. To set up this application, one needs to have a Vonage API account, a virtual phone number, and PHP 5.6 or above installed. The application will respond to incoming calls by displaying text prompts and capturing DTMF input from the caller, which is then sent to a separate URL for processing. The code uses ngrok to expose the local server to the internet, allowing Nexmo to make requests to it. Once set up, the application can be tested by dialing the associated phone number and following the steps spoken on the other end of the line.

The Vonage Messaging API allows businesses to leverage customer service by collating review feedback from social media platforms such as Facebook. Sentiment analysis mines insights from customers' feedback using natural language processing techniques to determine whether feedback data is positive, negative or neutral. The tutorial covers initializing the Messages API Sandbox on Vonage, collecting data from customers through Facebook, creating a bot to handle feedback from customers, and analyzing customer key pain points with visualization. To create a bot, businesses need a Vonage API account, a business account with each provider, and a Facebook account. The bot stores customer feedback in a database or text file, returns relevant responses to the customer, creates a dashboard through Streamlit to understand sentiments in real-time, measures customer sentiments with a positive, negative, neutral scale, and analyzes customer key pain points with visualization. The tutorial also covers creating a function called `sendMessage` which sends messages to Facebook in response to customers' queries, feedback, or reviews. Additionally, the application listens for incoming messages from the Messages API and stores data in a database file named `messages.db`. To analyze user's feedback, the data is visualized through the python Streamlit framework with libraries such as TextBlob, WordCloud, Matplotlib, and Pandas, which generates a word cloud to visualize the frequency of words provided in the feedback by users. The overall sentiment analysis shows that most of the feedback is not in support of the products and services of the firm.

Vonage is participating in Hacktoberfest 2020 as a partner and invites users to immerse themselves in the festivities by checking out their page for details on planned activities. Git, a distributed version control system, allows developers to track changes across files in projects. Users can install Git using command-line tools or graphical user interfaces like GitHub Desktop and Git Kraken. Creating a local repository involves creating a new directory with a .git folder, adding files such as a README.md file, committing these changes, and branching out to create separate versions of the code. Branching allows different versions of the code to coexist, enabling control over changes and collaboration among multiple people. Users can host their repositories on GitHub, a remote hosting platform that controls version control and enables collaboration with others on projects. By following steps such as creating a repository, pushing branches, and creating pull requests, users can merge changes into primary branches and track progress in their Git journey. With Hacktoberfest approaching, participants are encouraged to put their Git learnings into practice by contributing to Vonage projects and sharing ideas through the community Slack workspace.

To manage their repositories using GitHub Desktop, developers first need to install the application, authorize access to their GitHub account, clone their repository, create a new branch, make changes, and review them in the desktop application. Once ready, they can commit their changes with a brief description, then push them to the remote server. Next, they create a pull request by clicking on an option to proceed, which requires providing information about the changes, such as why they were made and whether new tests have been added. The developer must also follow any specific repository processes or checks that run automatically upon creating the pull request. After submitting the pull request, the developer reviews its status and makes any necessary adjustments before it can be accepted.

The tutorial provides step-by-step instructions on how to set up a phone number with the ability to record an incoming call using PHP and the Nexmo command line interface. The code is designed to work with any version of PHP 5.6 or above, and it uses a virtual phone number and ngrok to expose the local machine's server to the outside world. The process involves installing Slim, creating an index.php file, adding the necessary code, and running the code using the terminal. Once set up, the app can be tested by dialing the purchased number and following the prompts, and the recorded message can be accessed through a URL provided by ngrok. The tutorial concludes by suggesting ways to extend the code into a more fully fledged voicemail system.

Vonage's Verify API is used to implement multi-factor authentication with a two-step registration process for users, ensuring that only verified contact information is accepted. The tutorial extends an existing user authentication system in Symfony 5, adding phone number verification using the Vonage Verify API to confirm that the provided phone number belongs to the user and is valid for the region (country code) specified. The process includes creating a new entity with additional properties to store the country code and verification request ID, as well as implementing form fields to collect phone numbers, countries, and verification codes. A new utility class, `VonageUtil`, handles API interactions and verifies user input before sending a verification call using the Verify API. The tutorial also includes an event subscriber that checks if users are verified before allowing access to secured pages, redirecting them back to the verify form if necessary. The finished code for this tutorial is available in the end-tutorial branch of the GitHub repository.

The Vonage Go SDK is used to send an SMS using Go in less than 20 lines of code, requiring only a Golang installation or access to the Golang Playground. The SDK provides a simple and secure way to create an auth object combining API key and secret, instantiate an smsClient object, and perform actions on the Vonage API such as sending an SMS. To send an SMS, you need to pass the necessary information including the number the SMS should be sent to, the number it is sent from, and the text to be displayed. The heavy lifting of sending the SMS is done in a single line using the Send method provided by the API client, with error checking and response output added for verification.

This tutorial provides a comprehensive guide to building a basic application with two-factor authentication using the Nuxt JS framework. The application requires users to verify themselves by entering a PIN code sent to them via SMS, and it uses the Nexmo Verify API for this purpose. To achieve this, the tutorial demonstrates how to create a mini verification API using Express middleware inside Nuxt, which exposes three endpoints: `/send`, `/verify`, and `/auth-check`. These endpoints handle user input, verify phone numbers, and check authentication status, respectively. The application also includes server-side rendering, custom server middleware, and VueX state management. The tutorial concludes by highlighting the benefits of using Nuxt's Server Side Middleware for building complex applications with minimal overhead.

The Number Insight Dashboard is an application that monitors inbound SMS traffic, gathers insights about the numbers sending messages using the Nexmo Number Insight API, stores the data in a MongoDB database, and displays it in a browser-based dashboard with pre-built visualizations. The dashboard is built using Next.js, uses Chart.js for client-side charts, and Pusher to update graphs in real-time. To use the dashboard, one needs a Vonage API account and an SMS capable number, and can deploy it on Glitch or Heroku/Now.sh. Users can add new graphs by aggregating data from MongoDB and creating a new endpoint in the server.js file. The dashboard provides insights into total messages, geographic spread, and running costs of gathering insights, making it useful for monitoring SMS traffic and analyzing number-level data.

The Vonage Reports API provides access to detailed data about activity on an account, including cost, delivery status, country, network provider, message body, and more. The API covers various products such as SMS, Voice, Verify, Number Insight, Messages, Conversations, and Automated Speech Recognition usage. It offers two types of requests: synchronous for frequent and periodic retrieval of smaller batches of data, and asynchronous for infrequent, large queries returning tens of millions of records. The API can be used to gather data for big data type applications such as data visualization, analysis, and testing outbound campaigns. With the reports, users can gain insights into traffic trends, issues, or fraudulent cost spikes on a large scale, and provide in-depth analytics to customers on their activity via sub-accounts.

The tutorial guides users through creating a Home Surveillance System With Node and a Raspberry Pi that can send notifications of its IP address when booting in headless mode. The system uses the Vonage API to send SMS and WhatsApp notifications, requiring a Vonage API account and a virtual phone number. The code is written in JavaScript and utilizes the Nexmo Node SDK to interact with the Vonage API. The script retrieves the Raspberry Pi's IP address and sends it as a notification via SMS or WhatsApp when run on boot-up, using a configuration file (.env) to store environment variables.

The Nexmo-to-Azure Speech Service connector allows users to receive inbound phone calls and automatically transcribe them in real-time using Azure's Speech-To-Text API. The app can be deployed with various options, including one-click deployment on Heroku or Azure, remixing the code on Glitch, or deploying with Docker. To use the app, a Vonage API account is required, which includes purchasing a virtual phone number and setting up an application ID. Once set up, users can call the assigned number and see their spoken words transcribed in real-time. The connector also allows for extending its functionality by pushing the transcribed phrases to another service for further processing.

I'm excited to join the Vonage team as a Developer Educator after 9 years working in closed source companies, taking knowledge from the developer community and now looking forward to giving back. I come from London but currently live in Essex, have studied Computer and Information Systems, and my primary language is PHP, with experience in various development projects including those involving Raspberry Pi's. In my free time, I enjoy climbing, gaming, and creating projects, and look forward to being part of a team that values giving back to the community.

You can build an SMS app that responds with terrible festive jokes and one-liners to quickly break awkward silences, using Node.js, Koa framework, Vonage Messages API, a virtual phone number, and Ngrok for exposure. To get started, clone the repository, configure the app by setting up a Vonage API account, creating a virtual phone number, and linking it to the app. The app will then receive new SMS messages and respond with jokes and one-liners, breaking the tension. Once set up, you can deploy the app to a server like Heroku with minimal code changes.

You can develop and test applications using WhatsApp, Viber, or Facebook Messenger through the Messages API Sandbox, which allows you to link your own accounts and start sending and receiving test messages on your devices as you build. To get started, you need a Vonage API account, a smartphone with one of these messaging apps installed, a command line or terminal application, and whitelist yourself by linking your account ID to the API Key of your Nexmo account. Once whitelisted, you can test your account by sending yourself a message using the Terminal application, and then connect your application via webhooks to receive inbound messages from any of the supported services. The Messages API Sandbox provides tools such as Status webhooks to monitor the delivery path of messages sent by your application, allowing you to build applications that interact with these messaging platforms quickly and easily.

The Vonage Client SDK UI Web Components are a set of pre-built Web Components designed to minimize the work developers need to integrate the Vonage Client SDK into their applications. These components can be used with or without JavaScript frameworks or libraries, and they handle various responsibilities such as creating chat applications. The goal is to provide an easy-to-use interface for integrating the Vonage Client SDK into different types of applications. With the growing list of available Web Components, developers can now create fully functional chat applications by simply placing these components in their layout and passing in the necessary data. An early working version of these components is available in a Vonage Community GitHub repository, and contributions are welcome. The components have been integrated with the Nexmo Client SDK to provide a seamless experience for developers.

At Vonage, we launched our first Startup Program in February to empower the global startup community by enabling startups to build products faster and better using Communications APIs, while also helping them scale more efficiently and building great customer experiences. Through the Startup Spotlight series, we celebrate and showcase amazing startups like Billseye, a FinTech/Legaltech company that automates time tracking and billing for professionals who bill by the hour, removing pain associated with this process, and has achieved over ten thousand downloads of its Android software, recognition from several organizations, and plans to release an iOS solution in several weeks. Vonage's Startup Program provides educational resources and a supportive environment for startups to utilize Communications APIs effectively, and Billseye aims to disrupt the conventional approach to business communications in three years.

You have successfully created a PHP application hosted on AWS Lambda that listens for a specific webhook URL, confirms the caller's number, and converts a random fact from text to speech using Vonage's API. The application uses Slim Framework for routing, GuzzleHttp for making API requests, Bref for support on PHP on AWS Lambda, and Vonage's PHP client to handle incoming webhook requests. You have also deployed the code to AWS Lambda and created an application in Vonage to enable your virtual phone number to know which endpoint it needs to request when a call is made.

Caroline Kerns is joining the Vonage Team as a Community Manager, bringing her passion for creating welcoming and valuable communities to the role. Originally from Germany, Caroline has been in the US for about a decade and developed an interest in programming two years ago, which led her to join various programming communities where she discovered her love for being a Community Manager. Outside of work, Caroline enjoys collecting dice, playing Magic The Gathering, re-reading Jane Austen novels, cross-stitching, hiking, or taking photographs of local wildlife, and is excited to connect with the Vonage community on Twitter.

This project uses the Vonage Client SDK to build a React Native Android app that makes a phone call to a physical phone number. The app requires an active Vonage API account, a virtual phone number, and a GitHub account. It sets up a webhook server using Express.js and Node.js to receive inbound calls from Vonage. The app also uses the react-native-permissions library to request permissions for microphone access on Android and record audio on both Android and iOS devices. The Client SDK is used to authenticate users and connect them to their PSTN phone number. The project demonstrates how to communicate with native code using NativeModules and NativeEventEmitter APIs.

We built an iOS application using Flutter that makes a call from a mobile application to a physical phone number using Vonage Client SDK. The application has three screens: Prerequisites, Login as Alice, and Make a Phone Call. To build the application, we installed the required packages, including permission_handler for requesting microphone permissions, and set up the Vonage CLI and Flutter SDK. We also implemented the login functionality using the Vonage Client SDK, which authenticates the user Alice and generates a JWT token. The application then makes a call to a physical phone number and handles the call state changes using the NexmoCallEventListener listener. Finally, we added the functionality to request microphone permissions and end the call when it is answered or ended by the callee.