May 2021 Summaries
292 posts from Vonage
Filter
Month:
Year:
Post Summaries
Back to Blog
In an effort to transform into an agile engineering organization, Vonage is adopting site reliability engineering (SRE) principles and moving away from manual, repetitive, and automatable tasks known as "toil." To address the challenges of database changes, such as schema alterations and ad-hoc modifications, Vonage has developed an automation framework that allows engineers to specify and run SQL queries on databases using a declarative and idempotent approach. The framework uses Terraform for state management, AWS SecretsManager for secure credential storage, and Python for execution, with Jenkins serving as the runner. To ensure safety and security, the framework performs checks on submitted pushplans, maintains an audit trail, and executes SQL statements safely. While there are still improvements to be made, this foundation provides a solid base for extending automation to other aspects of database management.
May 26, 2021
755 words in the original blog post.
This Google Apps Script tutorial helps freelance developers integrate Vonage products with Google Workspace (formerly G-Suite) to send custom notifications when a Vonage account balance falls below a specified limit. To achieve this, the script uses the Vonage REST API to fetch the account balance and checks if it's lower than the set threshold. If so, an email is sent to the recipient with a reminder message. The script can be run periodically using triggers, allowing for automated execution without human intervention.
May 26, 2021
1,550 words in the original blog post.
The application implements video moderation using Vonage Video API and AWS Rekognition, enabling the detection of inappropriate content in real-time. The backend is built with AWS Serverless components such as AWS Lambda, AWS API Gateway, and AWS DynamoDB, while the client-side application is a React Single Page Application. The useModeration hook sends every second a screenshot of the camera or screen to the moderation API function, which analyzes the image using AWS Rekognition and detects inappropriate content. If detected, it mutes the video from the offending publisher and sends a notification to all participants. The application architecture allows for customization based on the user's use case, including muting audio/video or disconnecting users from joining sessions again.
May 25, 2021
870 words in the original blog post.
The Vonage API offers an Automatic Speech Recognition (ASR) feature that enables developers to build voice interactions into their applications, such as simple IVRs with voice navigation, sophisticated voice bots, and assistants. This feature allows for fast customer service, speech-based self-serve operations, a superior user experience, and reduced operational costs. To demonstrate this, the article provides a step-by-step guide on building a simple IVR app using Node.js, Express, and the Vonage API. The code snippet shows how to implement the answer webhook, which activates speech recognition, and how to decide what action to take based on the ASR results. The article concludes by providing testing instructions and encouraging readers to learn more about the new Speech Recognition feature, as well as other resources and tutorials.
May 25, 2021
930 words in the original blog post.
This summary provides an overview of how to build a parental control application using the Vonage Voice API and Android 10's Call Redirection feature to mask sensitive phone numbers. The application allows parents to configure their child's phone number, which is then used to proxy calls made from the device to a Vonage number, protecting the child's privacy. The application uses a NodeJS webhook server to handle requests from the Android app and redirect calls. The solution provides a flexible way to create call proxies for various use cases, leveraging the capabilities of the Voice API.
May 24, 2021
1,221 words in the original blog post.
Web Components are a set of web standards used to build reusable components without depending on specific JavaScript frameworks or libraries. They provide custom elements, shadow DOM, HTML templates, and other APIs to facilitate the creation of self-contained UI components. Companies such as Google, Salesforce, Twitter, GitHub, and YouTube are already using Web Components in their applications. Electronic Arts has successfully implemented Web Components in its network design system to create a coherent experience for users browsing its games' websites. The Web Component example used by Vonage demonstrates how simple it is to use these components with just an HTML tag, without needing to know WebGL and the WebXR Device API. By building on web standards, Web Components aim to make component creation easier and more accessible.
May 24, 2021
845 words in the original blog post.
This tutorial guides users in creating a Progressive Web App (PWA) that serves as a personal health blogging tool with live video chat functionality, using Preact CLI and Vonage Video API. The application is built from scratch, starting with setting up the project structure and installing necessary tools. The app enables users to create posts, share them with coaches, and receive live coaching sessions via video chat. To deploy the app, Netlify is used, which automates the deployment process. After deploying, users can access the CMS to publish posts, manage their profile, and engage with other users. The tutorial concludes by mentioning potential enhancements for better utility and experience, such as archiving video coaching sessions and importing data from additional health tools.
May 24, 2021
2,487 words in the original blog post.
This tutorial guides users through setting up a private call system using Nexmo's Voice API, forwarding calls via a voice proxy, and adding a recording feature. To begin, users need to install Node.js and Node-RED, create a Vonage API account, and obtain necessary credentials. They then set up their local server to be accessible over the public internet using ngrok. Next, users create a Nexmo Voice Application, link a virtual number to it, and define a webhook endpoint for inbound calls. The tutorial provides instructions on how to handle incoming calls, log call events, and add a recording feature to the system. Throughout the process, users learn about various Nexmo APIs, Node-RED nodes, and NCCOs, which are used to control the flow of the call. By following this tutorial, users can create a private call system with recording capabilities, making it suitable for businesses or individuals who need to make secure calls without revealing their phone numbers.
May 24, 2021
2,035 words in the original blog post.
This tutorial guides users in building a voice-based conferencing service using Nexmo APIs. To start, users need to expose their local server to the internet, define webhook endpoints for inbound calls and input events, create a Nexmo Voice Application, set up a number to call, and handle call events. The process involves installing Node-RED, setting up credentials, creating applications, linking virtual numbers, and handling events. Users can test the service by calling a predefined virtual number and entering a meeting ID, which will connect them to other users who have entered the same ID.
May 24, 2021
2,042 words in the original blog post.
This tutorial guides you through creating an Express.js application that can receive SMS messages using the Vonage Messages API and log them to an Airtable database. The application is set up to handle incoming messages, create new records in both the Numbers and Messages tables, and send confirmation SMS replies back to the sender. To complete the setup, you need a Vonage API account, Node.js installed on your machine, ngrok, and a local development environment. You also need to install dependencies such as `@vonage/server-sdk`, Express.js, and Airtable. The application is built using an Express.js server that listens for incoming messages on port 3000, which are then processed by the Vonage Messages API and logged to Airtable. Once set up correctly, you can test the application by sending SMS messages to your virtual phone number and verifying that they appear in both the Numbers and Messages tables of your Airtable database. The tutorial also covers error handling, creating new records for existing numbers, and sending confirmation SMS replies back to the sender.
May 24, 2021
1,497 words in the original blog post.
A Node-RED flow programmatically sends out notifications to a list of contacts using Google Sheets and the Vonage SMS API. The flow starts by reading data from a Google Sheet, splitting it into individual arrays, setting a delay between each array, preparing a templated message, sending SMS notifications through the Vonage SMS API, and logging delivery receipts back to the same spreadsheet on a different worksheet.
May 24, 2021
2,554 words in the original blog post.
Nexmo's Ruby SDK aims to improve developer experience by providing explicit code that is easier to debug and resolve issues. The team has started incorporating static type checking using the Sorbet gem, which helps ensure an explicit codebase. This process has revealed gems such as "Thinking Through The Interface" and "Follow Each Method All The Way Through." By introducing static typing, the SDK strives to achieve a 100% typed codebase incrementally over several months, focusing on deep thinking about design choices and method utilization. The goal is to enhance developer experience while maintaining flexibility in Ruby's dynamically typed language.
May 24, 2021
2,040 words in the original blog post.
You've built a simple voicemail service using Node-RED and Nexmo APIs that allows callers to leave messages, which are then sent to your email address as an attachment. The system uses a webhook endpoint to receive incoming calls, records the message, and sends it to you via email with a subject line including the caller's number. You can also log call events in the debug area for further analysis. This setup provides a convenient solution for personal or business use cases where voicemail services are not readily available or desired.
May 24, 2021
2,597 words in the original blog post.
The tutorial guides users in building an application that allows them to capture a screenshot of their desktop, annotate it with important details from a Nexmo Conversation chatlog, and save the image in the cloud using Cloudinary. The application uses the Nexmo Conversation API for multi-channel communication and combines its functionality with the Cloudinary API for image upload and annotation. To build this app, users need to have a Vonage API account, set up their credentials, and install necessary libraries such as desktop-screenshot and Cloudinary. The app's flow involves capturing a screenshot when a user enters "screenshot" in the chatlog, annotating it with relevant information from the Nexmo Conversation API, and uploading it to Cloudinary for easy future access. This tutorial demonstrates how users can leverage both Cloudinary and Nexmo APIs to enhance their communication and collaboration tools.
May 24, 2021
957 words in the original blog post.
The author created a WebSocket-based demo application using React to display translated SMS messages in real-time. The application uses Nexmo's SMS service and Google Translate API to translate incoming SMS messages into multiple languages, which are then displayed on the screen. The application includes features such as a dropdown menu for selecting the translation language, a connection status indicator, and a component that displays the translated messages. The WebSocket server is created using Node.js and the `ws` package, and it establishes real-time communication with the client-side React application. The application demonstrates the use of WebSockets for bi-directional communication between the client and server, and it showcases the capabilities of Nexmo's SMS service and Google Translate API.
May 24, 2021
1,657 words in the original blog post.
This tutorial guides users through setting up a chat application using Express.js, Nexmo's Node.js Server SDK, and Passport.js to authenticate users. The process starts with creating a new project, installing dependencies, and configuring Nexmo credentials. Users are then guided through creating a Typeform to capture user data, which is used to create a new user in the database and generate a JWT for authentication. The application also uses Ngrok to expose the local machine to the internet safely. Once users authenticate, they can join conversations and send messages. The tutorial concludes with tips on how to enhance the application further, including sending magic links via email, capturing display names and images, and implementing additional features such as revokable opaque strings, audio support, and shared media previews.
May 24, 2021
4,789 words in the original blog post.
To celebrate International Women's Day, the Vonage team organized various events and initiatives to promote diversity, inclusion, and empowerment of women in tech. The company shared stories and journeys of its female colleagues, including developers, advocates, and community managers, highlighting their experiences, challenges, and successes. The #EachforEqual campaign theme encouraged employees worldwide to support celebrating women's achievements and fostering a more inclusive workplace culture. Additionally, Vonage hosted clothing drives for Dress for Success, live-streams with expert speakers, and office events to promote diversity and inclusion. The company's efforts aimed to create a positive impact on the software industry and provide opportunities for underrepresented groups.
May 24, 2021
1,736 words in the original blog post.
This tutorial demonstrates how to create an Express.js server that receives inbound SMS messages from Vonage and translates them into English using the Azure Translator Text service. To get started, you need a Vonage API account, a phone number from Vonage, and an Azure Translator Text subscription. You also need to set up ngrok to allow public traffic to reach your local application. The tutorial guides you through creating an Express route and functions to handle incoming SMS messages and translations, using the `@azure/ms-rest-js` and `@azure/cognitiveservices-translatortext` packages.
May 21, 2021
1,263 words in the original blog post.
To deploy an application available for end-users to view and use, the process involves moving it from a development server to production where users can access it via the internet or intranet. This typically requires software and package installation, testing, software release, and deployment processes. The tutorial focuses on deploying Vonage Message API to production on PythonAnywhere, which is a cloud-based development and hosting environment for python applications. To start, create a PythonAnywhere account, install a Python application, and have basic knowledge of Python. Then, follow the steps to set up the Vonage Developer Dashboard, create a sandbox, and generate an API key and secret. Next, write a simple Flask application that sends WhatsApp messages using the Vonage API library. Create a requirements.txt file with necessary packages and install them in a virtual environment. Finally, deploy the application on PythonAnywhere by creating a web application, configuring virtual environments, and setting up WSGI configuration files. The tutorial concludes by providing guidelines for deploying Vonage applications on other platforms and upgrading to paid accounts with no limitations.
May 21, 2021
1,908 words in the original blog post.
A music video from 2001 features Kelly Rowland sending an SMS on her Nokia phone using Excel, which is considered outdated technology at the time. This functionality exists today thanks to Nexmo's API, allowing users to send SMS messages programmatically. To replicate this in a modern spreadsheet like Google Sheets, a script can be created that utilizes the fetchURL API and Google Apps Script to send an SMS message. The script can also be modified to pull data from other cells in the sheet and to validate user input. Additionally, implementing a contact list feature allows users to easily select a recipient without having to manually enter their phone number.
May 21, 2021
1,395 words in the original blog post.
This project involves building a Laravel application that maintains a collection of recipes and sends notifications when it's time to perform specific actions in the kitchen. The application uses Vonage's Messages API to receive inbound messages from Facebook, WhatsApp, or Viber, and sends responses back to the user at the correct time using Laravel's notification system. The application is designed to be extensible and can be easily integrated with other messaging platforms. To use the application, a Facebook page needs to be linked to Vonage, a new Vonage application needs to be created, and webhooks need to be configured. The project provides a comprehensive guide on how to set up the application, including setting up Laravel notifications, configuring Vonage authentication credentials, and sending updates to Facebook. Once the application is running, users can send messages with recipe names, and the application will respond with the next action to take at the correct time.
May 21, 2021
1,786 words in the original blog post.
Nexmo's Number Insight API provides real-time intelligence about phone numbers, with three levels of information available: Basic, Standard, and Advanced. The API is used to determine the country where a number is registered, its local and international representation, and other details such as line type and Mobile Country Code. The Advanced API also provides additional data on the validity and reachability of the number, as well as whether it is likely to be valid or ported. To use the API, developers need to sign up for a Vonage account and install the Nexmo REST API client for Node.js, then send an input phone number to the server to retrieve the insight data. The process involves setting up a Koa.js project, installing dependencies such as `koa-router` and `koa-bodyparser`, and creating routes to handle incoming POST requests.
May 21, 2021
1,401 words in the original blog post.
The tutorial describes how to send SMS messages using AWS Lambda and the Go programming language, leveraging the Nexmo Messaging API. To accomplish this, one must have a Nexmo developer account, an Amazon Web Services (AWS) account, and be familiar with the Go programming language. The process involves creating a data model for the request and response, building an HTTP client to send a POST request to the Nexmo Messages API, and defining a handler function that uses the AWS Lambda SDK for Go. Once complete, the Lambda function is deployed to AWS Lambda and integrated with API Gateway to make it accessible as part of standard HTTP requests. The tutorial concludes by highlighting potential use cases, such as sending app store links to users through SMS.
May 21, 2021
1,582 words in the original blog post.
Slack is a popular workplace collaboration tool with over 10 million daily active users, and the Vonage-Slack integration allows developers to easily launch a customized live video experience within Slack without leaving their workspace. To get started, users need to sign up for a Vonage account and configure TokBox using specific commands such as `/tokbox`, `config`, and `remove`. This enables them to create unique links for live video meetings, set API keys and secrets, and remove the current configuration if needed. The integration aims to elevate the developer experience by providing a seamless way to launch a video session on Slack, making it an attractive option for teams looking to enhance their collaboration tools.
May 21, 2021
359 words in the original blog post.
Hui Jing Chen's blog post provides an in-depth tutorial on how to utilize Nexmo's Number Insight API with Node.js and the Koa.js framework, detailing the setup process from creating a new Node.js project to handling API requests. The Number Insight API offers three levels of information—Basic, Standard, and Advanced—about phone numbers, such as their validity, reachability, and roaming status, which can be used to format numbers correctly and assess communication methods. The guide explains setting up a Koa.js server, configuring environment variables, and implementing a basic web page to input phone numbers and retrieve insights. It also covers the asynchronous capabilities of the Advanced API, suitable for risk assessment and determining a number's communication type, while encouraging further exploration through additional resources and community support.
May 21, 2021
2,055 words in the original blog post.
With Nexmo In-App Voice, developers can easily make and receive phone calls directly within their Android app using the Nexmo Stitch Android SDK and WebRTC technology. The functionality allows customers to make outbound calls without leaving the app, and receive incoming calls from other users. To get started, developers need a Vonage API account, set up Firebase Functions to host the NCCO and return a JWT for users to login with, deploy the Firebase project, create a Vonage application, link a phone number and user to the app, and set up the Android project using Retrofit. The Nexmo Stitch SDK handles the hard work of placing and answering phone calls, allowing developers to focus on building their app's UI and logic.
May 20, 2021
2,002 words in the original blog post.
This tutorial continues the "Getting Started with Vonage and Ruby on Rails" series by teaching developers how to receive an inbound call using a webhook endpoint in Ruby on Rails. To follow this tutorial, developers need a basic understanding of Ruby and Rails, as well as a Vonage API account and a previously set up Vonage application. The first step is to link the Vonage Application to the purchased Nexmo number using the Vonage CLI tool, which tells Vonage to make an HTTP call to the answer_url whenever an inbound call is received. Once this is done, developers can handle the incoming call webhook by processing the payload and storing a new call record in their application database. The tutorial concludes with instructions on how to start the server, ensure ngrok is running, and make a voice call to test the setup.
May 20, 2021
742 words in the original blog post.
We're going to use a virtual number that connects two parties but is only usable for the duration of the current transaction, to avoid giving out our personal phone numbers to strangers. We'll rent a virtual number through Vonage CLI and associate it with an application to link multiple numbers to a single backend. Our Express server will have a single endpoint that returns an NCCO file containing instructions for the Vonage API when someone answers or makes a call, using the rented virtual number as the caller's identity. To use our proxy server, we'll create a Vonage Voice Application and link it to our virtual number, configuring our Glitch .env file with the required numbers in E.164 format.
May 20, 2021
716 words in the original blog post.
This tutorial continues the series of "Getting Started with Nexmo APIs and Ruby on Rails" by focusing on how to listen for call events from Nexmo to update the status of a call in a Rails application. To follow this tutorial, developers need a basic understanding of Ruby and Rails, as well as a Vonage API account and a working Rails server. The tutorial explains how to set up a webhook endpoint with Nexmo, handle incoming call events, and process the received webhooks to update the status of the calls in the application.
May 20, 2021
889 words in the original blog post.
This tutorial demonstrates how to use the Nexmo Number Insights API to validate and gain information about any phone number. To complete this tutorial, you need a Vonage API account with an API key and secret, as well as a virtual phone number. The tutorial uses PHP and Composer dependencies, and provides examples of different levels of service, including Basic, Standard, and Advanced, which offer varying amounts of information about the phone number, such as its type, carrier, roaming status, and reachability. The application uses a SlimPHP framework and displays the form to input the phone number and select the level of insight desired, with the response displayed in a tabular layout. The tutorial also includes handling for errors and provides additional resources for further learning, including API reference documentation, code snippets, and tutorials on other topics such as fraud scoring and phone number verification.
May 20, 2021
803 words in the original blog post.
The Nexmo Messages API for Salesforce is a package that enables developers to send messages via SMS, MMS, WhatsApp Business, Facebook Messenger, and Viber Service Messages directly on the Salesforce Apex class, allowing for an omnichannel strategy. The package provides simplicity by accessing multiple channels through a single API, making it easy to integrate with various AI services such as IBM Watson or Google Dialogflow. With one-click installation, developers can easily embed the service into their application, whether server-side or client-side, within Salesforce or not. The package allows for creating multichannel messaging flows using Salesforce Process Builder, enabling triggers and actions based on specific conditions, making it easy to automate business logic.
May 20, 2021
1,840 words in the original blog post.
This tutorial series covers the use of Nexmo's Voice API with Node-RED to make outbound calls, including text-to-speech (TTS) phone calls. To get started, users need a Vonage API account and a virtual phone number. They also require an API key, secret, and a voice-enabled virtual number. The tutorial guides users through setting up their Node-RED editor, installing the Nexmo nodes, creating a Nexmo application, building a call control object (NCCO), making the outbound call, and optionally receiving events about the progress of the call. Throughout the process, users need to expose their local server to the internet using tools like ngrok if necessary. The tutorial aims to provide a hands-on experience with Nexmo's Voice API and Node-RED for developers.
May 20, 2021
1,767 words in the original blog post.
The tutorial describes how to build an SMS queue management system using Python and the Flask framework. The application allows users to reserve a spot in line by sending a text message, receive status updates on their position in line, and be notified when it's time for them to arrive. The backend consists of routes for the views, webhook logic to handle incoming SMS messages, and helper functions to manage database queries and send notifications. The frontend includes two views: one for displaying the current wait list and another for managing user input. The application uses Nexmo's Messages API to send and receive text messages, and ngrok is used to forward traffic from a local server to a public URL.
May 18, 2021
2,426 words in the original blog post.
The tutorial series aims to teach developers how to send and receive SMS using Vonage's API. To complete this task, a developer needs a Vonage API account and a virtual phone number. The process involves setting up an ASP.NET project and adding a controller called SMSController.cs. An action method called DLR is created in the SMSController.cs file to read the delivery receipt and print its status to the output window. The tutorial also covers using webhooks, ngrok, and Vonage CLI for testing and deployment purposes.
May 18, 2021
570 words in the original blog post.
We've built an application that sends daily SMS updates to subscribers based on whether it's the weekend or not, using web scraping from `isittheweekend.com`. The application uses Ruby on Rails and leverages the Nexmo SMS API. We created a Rake task to run the application once a day and configured the `whenever` gem to execute the Rake task at 24-hour intervals. To deploy the application, we can use Heroku or other external hosting providers. For local development, we need to make the Rails event webhook accessible to the outside world using tools like ngrok.
May 18, 2021
3,097 words in the original blog post.
The COVID-19 pandemic has led to a shift towards remote work, with many companies adopting hybrid or fully distributed workforces. Despite the benefits of remote work, creating an environment that feels connected and human for remote teams is a significant challenge for employers. Commons, a startup founded by Patrick Burns, aims to address this issue by creating a voice-first collaboration platform designed to recreate an office-like environment for team interactions. The platform uses a Vonage API and has been developed by a team of experienced product leaders and engineers who have spent years building social, communication, and enterprise networking products.
May 18, 2021
750 words in the original blog post.
The text discusses Rack middleware, specifically Nexmo Rack, which is a customizable interface between Ruby web frameworks and application servers. To use Nexmo Rack, developers need to set up a Vonage API account and provide their signature secret and desired signing algorithm. The middleware supports both environment variables and Rails Credentials for authentication. Once credentialed, the VerifySignature functionality can be used to inspect incoming requests for signatures, verifying them if valid and returning a 403 Forbidden status otherwise. Developers can mount Nexmo Rack middleware into a Rails application or use it in a standalone Ruby application, with examples provided for both cases.
May 18, 2021
860 words in the original blog post.
This tutorial provides a practical example of deploying an AWS Lambda function that uses Amazon Transcribe and Nexmo Voice to create a transcription microservice, allowing developers to build their own applications with this feature. To accomplish this, the tutorial requires PHP installed locally, a local clone of the nexmo-community/voice-aws-speechtotext-php repo on Github, Serverless Framework installed globally, a Vonage API account, and an AWS account with IAM credentials associated with a user who has sufficient privileges. The tutorial guides developers through creating an S3 bucket to store voice recording MP3 files, setting up IAM users, installing the Serverless Framework, preparing the application using Composer, editing the serverless.yml file, updating environment variables, deploying the application to Lambda, and testing the Vonage setup.
May 18, 2021
1,525 words in the original blog post.
This tutorial explains how to use the Vonage C# Client Library to receive SMS messages on a Vonage phone number using the C# Client Library, continuing from the previous tutorial that showed how to send an SMS message. To complete this tutorial, a Vonage API account and a virtual phone number are required, along with ngrok to expose a local server's port over the internet for testing purposes. The tutorial guides through creating an action method in the `SMSController.cs` file to receive inbound SMS data using the `[FromUri]` attribute and printing the message details to the output window if the response values are not null. Finally, it shows how to set up a Vonage app, create a webhook, and link the virtual phone number to the app, allowing the ASP.NET web app to receive SMS messages sent to the Vonage phone number via an inbound webhook.
May 18, 2021
844 words in the original blog post.
The Nexmo Ruby SDK has released version 7.0.0 with improved API error handling, renamed the `Calls` class to `Voice`, and introduced static typing for the `Account`, `Alerts`, and SMS classes, making it easier for developers to handle errors and write more robust code. The new release aims to improve consistency across languages and provide a better experience for users. The SDK continues to evolve with upcoming features like the Conversations, Messages, and Dispatch APIs, and developers are encouraged to contribute to the GitHub repository or join the Nexmo Community Slack.
May 18, 2021
688 words in the original blog post.
This tutorial guides users on setting up an application that sends notifications to a Slack channel whenever a virtual number from Nexmo receives a text message, utilizing Node.js, Express, and ngrok for exposing the local web server to the internet. The application requires a Vonage API account, a virtual phone number, and an incoming webhook URL generated by Slack. With these components in place, users can receive notifications about inbound messages, allowing them to track their communication with users or customers effectively.
May 18, 2021
1,068 words in the original blog post.
As a member of the Developer Relations team at Nexmo, I travel extensively throughout the year attending events, speaking at conferences, and collaborating with developers from around the world. To make the most of my time on the road, it's essential to prioritize health and well-being, as burnout can quickly set in when traveling frequently. This includes taking the time to recover between trips, eating healthy snacks, exercising regularly, and getting enough sleep whenever possible. By being mindful of these habits, I'm able to stay energized and focused, even during long flights or layovers. Additionally, I've found that using travel hacks such as packing essential items like power adapters, entertainment for downtime, and reusable water bottles can make a significant difference in my travel experience. Whether exploring new cities, taking advantage of airport amenities, or utilizing global entry programs, there are many strategies to help navigate the complexities of air travel while staying productive and refreshed.
May 18, 2021
3,423 words in the original blog post.
This tutorial guides users in automating the process of sending SMS payment confirmations for each new Stripe charge using Zapier and Nexmo. To achieve this, users need to create a Zap with a Stripe trigger, configure the Nexmo SMS action, customize the message template, and test the integration. The automation enables customers to choose their preferred communication method, enhancing the customer experience and brand perception while saving developer resources.
May 18, 2021
1,061 words in the original blog post.
The Nexmo Server SDK team has revisited their existing specifications to improve the developer experience for those using their APIs. They aim to make it easier for developers to quickly get up to speed with new libraries without much interference. The new specification focuses on flexibility, abstracting away HTTP-specific details and emphasizing convenience above all else. This change will enable a more modern and clean interface, making it easier for developers to use the SDKs and provide an experience similar to well-constructed libraries from their respective languages.
May 18, 2021
1,131 words in the original blog post.
The author, a father, wanted to allow his 8-year-old son to make a phone call to the teacher stationed in the cafeteria before school starts, but was hesitant due to the cost and potential for him to lose it. He discovered an AWS IoT Button, which is a cheap device that can be linked to Amazon Web Services, and used it to send an email when clicked. To connect this with making a phone call, he integrated the Nexmo Voice API, which enabled him to make automated calls. The author created a Lambda function using the AWS IoT Button blueprint, and then connected it with the Nexmo code to create a fully functional system that allows his son to make a phone call by clicking a button on the IoT device. This innovation has saved him time in his morning routine and given his son more independence.
May 18, 2021
886 words in the original blog post.
This tutorial demonstrates how to build a simple real-time transcription service using ASP.NET Core, Microsoft Azure's Speech SDK, and the Vonage .NET SDK. The service uses a WebSocket connection to receive audio from a client, which is then sent to an Azure Speech-to-text service for transcription. The service also includes features such as language selection, recognition of metadata in the received audio, and handling of exceptions. To complete the tutorial, you need to set up an Azure Cognitive Services resource, create a Vonage API account, and configure your project with the necessary NuGet packages. You also need to set up IIS Express, Ngrok for testing purposes, and a Voice Controller to handle incoming webhooks from the Vonage Voice Application. Once everything is configured, you can call the Vonage Number linked to your application, speak into it, and see the transcription of your speech in real-time on the debug console.
May 18, 2021
1,336 words in the original blog post.
In addition to creating delightful APIs for users, the developers also participate in events with other API-makers. They recently attended APItheDocs in Amsterdam, where they learned valuable insights from a talk by Anthony Roux on what makes an API product successful. The key points covered were being open and transparent, providing documentation that is easily accessible, including status pages, pricing, and terms and conditions. Onboarding was also discussed, with the importance of making it easy for users to start exploring quickly, using data collection as little as possible, and having a clear on-boarding experience within three seconds, thirty seconds, and three minutes. The talk emphasized the importance of examples and demos, SDKs, free trials, simple pricing models, support systems that are easily accessible and documented, and being present at events to interact with customers and peers.
May 18, 2021
840 words in the original blog post.
This is an overview of creating an FAQ bot for Santa Claus using QnAMaker and the Nexmo Messages API. The goal is to automate some of his correspondence and provide him with modern means of fielding questions from various channels such as Facebook Messenger, WhatsApp, SMS, and more. To achieve this, a knowledge base is created in QnA Maker, which is then used by the bot to generate responses to incoming messages. The Nexmo Messages API is used to send and receive messages, allowing the bot to interact with users across different platforms. The project involves setting up a virtual phone number, creating an Azure account, installing necessary NuGet packages, generating JWT tokens for authentication, building data structures to receive and send data, and configuring the controller to handle incoming messages. Once completed, the service can be deployed and tested using IIS Express or ngrok, which exposes it to the internet and enables webhooks to be set up with the Nexmo Messages API.
May 18, 2021
2,271 words in the original blog post.
We recently ran a webinar with David Leary from Intuit Developer to go over the basics of using the Nexmo SMS and Voice APIs. To complete this tutorial, you will need a Vonage API account, which can be signed up for today with free credit. This tutorial covers sending an outbound SMS, receiving an inbound SMS, making an outbound phone call, and receiving an inbound phone call. The examples come with code snippets and links to further in-depth reading. To send an SMS, you can use a virtual phone number purchased from Nexmo, and to receive an SMS, you need to register for an SMS Delivery Receipt. To make an outbound phone call, you need to create a Nexmo Voice API account, and to receive an inbound phone call, you need to set up a conversation control object. There's also more information about programmable communications, such as the Verify API for 2FA and one-time passwords, and Number Insight for looking up information on phone numbers.
May 18, 2021
883 words in the original blog post.
The author built a tool in Firebase to control smart devices using text messages and voice commands, with the help of the Verify API from Vonage. To start, they created a virtual phone number and set up a Cloud Function to send verification codes to users when their numbers are added to Firestore. The function uses the Nexmo JavaScript SDK wrapped as promises to handle callback methods correctly. After receiving a verification code, users can submit it to check if it's valid, and if so, update the document in Firestore with a verified flag. The author also built a React app to add new phone numbers and verify them using Firebase Functions. With the Verify API, they gained control over how their system interacts with users, protecting against spam and suspicious activity while validating ownership of phone numbers.
May 18, 2021
1,322 words in the original blog post.
In a marketing campaign without tracking, it's impossible to determine which campaigns are successful and which ones aren't. Campaign tracking is essential for any advertising or marketing campaign. The challenge lies in tracking offline advertising such as print ads, which requires unique promotional URLs or coupon codes. Nexmo virtual numbers can help solve this problem by allowing users to dial a unique number that can be tracked within existing business intelligence tools. To track inbound telephone callers, the system uses the Nexmo API to request a call control object (NCCO) from the URL provided, which contains actions such as streaming an mp3 file or recording and connecting the call to an agent. The NCCO also includes the number called in E.164 international format, allowing for accurate tracking of the campaign, caller, and call information. The system uses Mixpanel to store and analyze this data, including information about the caller's name, country, and network type. By using a unique identifier such as the telephone number or campaign name, the system can track subsequent events and segment data to evaluate campaign performance.
May 18, 2021
2,441 words in the original blog post.
When working with AWS Lambda, users often struggle with accessing other AWS services like S3, RDS, or Transcribe due to permission issues. To resolve this, a Vonage API account is required, which includes an API Key and Secret, as well as a virtual phone number. A new IAM user should not be created for the Lambda function, but rather environment variables `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` are set in the `.env` file, which gets generated by Lambda during deployment. The role permissions must also be set during deployment, with all AWS services handled directly within the Lambda function instead of an IAM user. To achieve this, a partial YAML example using the Serverless framework can be used to deploy an AWS Lambda function and set the required permissions. Upon successful deployment, the active permissions of the function can be viewed in the AWS Console, allowing for a more detailed breakdown of how they are set.
May 18, 2021
450 words in the original blog post.
The Nexmo Developer Relations team has experienced significant growth since its "Hello World" post in 2016, with the addition of new members from San Francisco to London, spread across six geographic locations, making it a truly remote-first team. In the past year, the team achieved notable highlights such as releasing the Voice API beta, running an early adopter program, and integrating AI capabilities into Project Intu with IBM Watson. The DevRel stats show that Nexmo's client libraries have gained popularity, with over 20k monthly installs in February 2017, and nearly 1 million page views for the updated documentation. The team has also been involved in numerous events and blog posts, reaching 65k developers, giving out 3,000 t-shirts, and publishing 44 blog posts. The company's accounts have increased by 75% to 200k developers, demonstrating a strong growth in adoption. The DevRel team is now looking for new members to join the Nexmo API communications platform, with positions available for JavaScript/Node, .NET/Microsoft, and PHP Developer Advocates.
May 18, 2021
601 words in the original blog post.
The Nexmo Voice API uses Nexmo Applications to hold security and config information needed to connect to Nexmo endpoints. A virtual phone number is required to purchase one that meets your needs. The Nexmo Voice API can be used to build a single level IVR with multiple paths, such as forwarding the call to a specific destination or playing a recorded piece of information. To create an IVR, you need to expose your local server to the internet using a tunneling service like ngrok and install the necessary nodes in Node-RED, including Nexmo and Ngrok nodes. The IVR can be configured to send caller numbers to voicemail or SMS with online booking links. The Nexmo Voice API provides a range of actions available, such as connecting callers, sending messages, and recording calls.
May 18, 2021
3,419 words in the original blog post.
The machine learning-powered translation APIs of Amazon Web Services, Google Cloud Platform, IBM Watson, and Microsoft Azure offer a range of features to facilitate global communication in real-time. Each service has its strengths and weaknesses, with varying levels of supported languages, pricing structures, and ease of use. While all services provide accurate translations, they may not always return the original text, which can be a drawback for some applications. IBM Watson's pricing is considered high due to its limited language support and lack of auto-detection. In contrast, Azure and Google Cloud offer more matured offerings with better language models. Overall, each service is suitable for handling most use cases, but users should carefully consider their specific needs before choosing a translation API.
May 18, 2021
1,818 words in the original blog post.
This tutorial provides a step-by-step guide on integrating two-factor authentication with Nexmo Verify into a Laravel application. The process involves collecting the user's phone number at registration time, adding a field to the users table in the database, and modifying the login controller to send a verification request via Nexmo. After verifying the code provided by the user, the system logs them in automatically. The tutorial also touches on implementing additional security measures such as validating the incoming data, catching exceptions, and logging out the user after registration.
May 18, 2021
1,835 words in the original blog post.
This tutorial series, led by Nexmo developer advocate Tomomi Imura, covers how to add programmable SMS capabilities to Node.js applications using Express, including sending, receiving, and verifying SMS messages, as well as implementing two-factor authentication for iOS apps. To complete the tutorials, developers need a Vonage API account with an API key and secret, and a virtual phone number. The series includes code samples and instructions on how to use Nexmo's SMS API to build secure messaging systems.
May 17, 2021
609 words in the original blog post.
This tutorial extends a voice application created in a previous tutorial, allowing it to record a message from a caller using the Nexmo Voice API and the Node.js client library. To complete this tutorial, developers need to set up a Vonage API account and create a virtual phone number. They then modify the NCCO to handle requests for recording audio, including specifying an event URL where information about the recording is sent. When a recording is completed, the event returns the information, including the audio file URL, which can be used to retrieve the recording from Nexmo. Developers also learn how to download the recorded audio file to their disk using the `files.save` method of the Nexmo Node.js library.
May 17, 2021
733 words in the original blog post.
This tutorial demonstrates how to implement 2 Factor Authentication (2FA) in an ASP .NET MVC application using Nexmo SMS and SendGrid Email as the different methods of verification. The implementation involves setting up the Nexmo and SendGrid clients, adding the necessary configuration to the IdentityConfig.cs file, and creating a new controller action method for sending emails and SMS messages. The tutorial also covers how to add 2FA capabilities to user registration and login processes, ensuring that users cannot bypass the 2FA verification process. By using SMS and email as additional layers of security, this implementation provides an enhanced level of protection against unauthorized access to sensitive user information.
May 17, 2021
1,255 words in the original blog post.
Two-factor authentication (2FA) is a security process that requires a user to provide two different authentication factors to access a system, network, or application. In this tutorial, we covered how to add 2FA to an iOS application using the Nexmo Verify SDK, which provides SMS and TTS verification, as well as biometric fingerprint or retina scan verification. The app uses a virtual phone number and a Back4App backend for user login and data storage. We also added a new view controller for verification and implemented logic for SMS verification on login, PIN code verification, and transfer functionality with 2FA.
May 17, 2021
2,624 words in the original blog post.
The addition of dynamic connect for voice apps aims to improve the caller experience by reducing failed calls when the primary line is unavailable. The new functionality works with existing failed call states and introduces four new call states: failed, rejected, unanswered, and busy. When a system uses this feature, Nexmo makes an HTTP call to the event URL in case of a failed state, allowing the web server to respond with an updated NCCO that replaces the original one. This allows for alternative numbers to be tried, improving the overall customer experience.
May 17, 2021
334 words in the original blog post.
The Firebase Auth Quickstart provides a great tutorial on how to add authentication to your application, but without two-factor authentication (2FA), it's a bit insecure! Adding an extra layer of security to your application is simple using the Nexmo Verify SDK. To complete this tutorial, you will need a Vonage API account and a virtual phone number. You can sign up for these on the Vonage website. The tutorial also uses OAuth providers like Google and Twitter. Once you have all the necessary credentials, you can add two-factor authentication to your application using the Nexmo Verify SDK. This allows you to allocate more time to developing your app by providing a managed UI solution that enables you to make verification requests securely and with ease.
May 17, 2021
1,329 words in the original blog post.
The tutorial focuses on creating an interactive notifications system for a package delivery company using the Vonage SMS API, Express.js, and JavaScript. It covers sending and receiving basic text messages between companies and customers. The app allows employees to submit phone numbers, send notifications with delivery slot information, and listen for incoming messages from customers to change their delivery slot.
May 17, 2021
1,540 words in the original blog post.
The Nexmo Java client library has released its first snapshot version of v2.0, which includes coverage for the Nexmo Voice API and automated testing with tools like Codecov and Codacy. The release is available on Maven Central snapshot repo and can be installed using Gradle or Maven. The library already works with most of the Verification API and some of the SMS API, but more functionality will be added in future releases. The team is seeking feedback from users to improve the library, and it's a great opportunity for developers to try out the new version and provide input before its official release.
May 17, 2021
584 words in the original blog post.
The IBM Watson Project Intu is a cognitive technology that enables developers to extend its capabilities to new form factors such as robots, drones, and mobile devices. With the integration of Intu with the Nexmo Voice API, Watson's capabilities can be extended to reach billions of people who have access only to a telephone. The tutorial provided shows how to set up the Nexmo Voice Connector for Project Intu and enable Watson to have a conversation with users over a mobile phone. To complete this tutorial, developers need to create an IBM Bluemix account, download the Intu tooling application, install it, and customize it to call their phone number using the Nexmo API. Once set up, users can engage in conversations with Watson over their phone, exploring more features such as operational instances and customizing the device to try on other devices like Raspberry Pi.
May 17, 2021
1,168 words in the original blog post.
The major providers in the AI bot space offer similar services but use different terminology. The term "bot platform" was first used by Syd Lawrence and his company, The Bot Platform, before it became widely adopted. A bot platform is a system that allows users to create their own app messaging bots, with Syd's company offering a service solution where they help build out the bot for users or with them to begin with. Microsoft's framework, also known as a development kit or SDK, is used to build bots that can be made available on multiple channels such as Skype, Facebook Messenger, and Slack. The concept of the framework is similar to Java's "Write once, run everywhere" idea, aiming to simplify development by allowing developers to create one bot that can be easily deployed across different channels without requiring significant additional work. Microsoft also offers various services, including natural language understanding using LUIS, which can be added to a bot for more accurate results.
May 14, 2021
1,779 words in the original blog post.
This tutorial covers setting up a webhook endpoint using Node-RED to receive SMS messages from Vonage API. The prerequisites include having a Vonage API account and a virtual phone number, as well as an optional ngrok service for exposing the local server to the internet. To set up the endpoint, users need to define a webhook endpoint in their Node-RED editor, expose their local server to the internet, associate the webhook endpoint with the virtual number, and then send a text message to test the setup. The received SMS messages will contain various key values such as msisdn, to, text, type, keyword, and message-timestamp, which can be used for further processing or analysis.
May 14, 2021
703 words in the original blog post.
This tutorial guides you through creating a Ruby on Rails conference call application using the Nexmo Voice API. To accomplish this, you need to create a new Rails application, expose it externally with ngrok, set up your Nexmo account and phone number, link your application to your phone number, define your Rails Controller actions and routes, and run your application. The tutorial provides a comprehensive walkthrough of each step, including setting up ngrok and defining the necessary NCCO instructions for the conference call. Once you complete these steps, you can make calls to your Nexmo-powered conference call and invite others to join in.
May 14, 2021
1,296 words in the original blog post.
This tutorial guides the creation of a Magic 8-Ball voice app using Ruby and the Nexmo Voice API. To start, users need to set up a Vonage API account, create a virtual phone number, and install ngrok to expose their local server externally. The app's flow involves prompting the user to ask a question, pressing 1 to receive an answer, and then displaying a randomly selected response from a predefined array. The app uses Rails as its backend framework and handles caller input errors by checking for the digit '1' in the input. Users must also link their Nexmo account, phone number, and Voice application to complete the setup. Once set up, users can run their app using ngrok and interact with it by calling the Nexmo phone number. The completed app provides a simple yet entertaining way to make decisions or seek advice through the classic Magic 8-Ball mechanic.
May 14, 2021
1,790 words in the original blog post.
Launching and discovering bots, especially voice bots, poses significant challenges. According to experts, the biggest issue lies not in getting discovered, but in delivering on the promise of the bot's use case and managing users' expectations. It's essential to design the bot correctly, clearly stating what it can and cannot do, to avoid frustrating users. The discovery phase is also affected by the lack of orchestration and the clutter of apps on devices, making it difficult for users to navigate and find the right bot. Developers must adopt a user-centric approach, focusing on simplicity and providing a "playing-with-tech" experience to help users learn and discover new capabilities.
May 14, 2021
1,128 words in the original blog post.
The Nexmo PHP client library has been released with version 1.0, built on top of Zend Diactoros and Guzzle, it's a PSR-7 compliant HTTP client for the Nexmo API, supporting core services such as SMS, voice calls, Verify and virtual number provisioning, with plans to add coverage for remaining products over the next month. The library is designed to be flexible, allowing developers to use entities and type hints or pass data around as arrays. It provides examples of how to send an SMS, make a voice call and verify user's identity using less than ten lines of code each. Additionally, it has a Laravel service provider that allows users to easily integrate the library into their applications.
May 14, 2021
586 words in the original blog post.
This issue of balancing user privacy against the value of organic user data is a crucial concern in the bot and AI space as voice assistants like Alexa become increasingly popular, capturing audio and potentially other sensitive information from users. It's not a technical issue but rather a privacy issue that developers must address to ensure the success of these systems, while also maintaining users' trust and comfort with sharing their data. The more information gathered by the assistant, the better it can be, but this comes at the cost of worsening the privacy case, highlighting the need for finding a balance between these two competing interests.
May 14, 2021
404 words in the original blog post.
The decision between creating a chatbot or voice bot depends on the context of the use case, but having both channels available to users can be beneficial. Context is crucial in determining which type of interaction is more suitable for a particular situation. Voice bots are better suited for tasks that require hands-free interaction, such as driving, while text-based chatbots excel in situations where screens are required for feedback or information. However, voice systems lack domain-specific language understanding, making it challenging to recognize and process specific company names or terminology. To overcome this limitation, custom speech recognition systems can be developed to improve accuracy. Additionally, the need for developers to access audio files from voice assistants is a challenge that these platforms will have to address in order to provide more advanced speech-to-text capabilities. Ultimately, having multiple personas or interfaces for different domains and use cases may become necessary to effectively utilize both chatbots and voice bots.
May 14, 2021
1,303 words in the original blog post.
As a developer advocate at Vonage, Amanda is passionate about cloud technologies, JavaScript, human-computer interactions, and ambient computing, with a focus on conversational technologies that can improve lives and make technology more inclusive. She believes in creating an inclusive environment for the developer community, where everyone is welcome to join and collaborate. With six years of development experience, Amanda has empathy to communicate and help empower people to reach their goals, and she looks forward to creating content using Vonage's APIs to bring value to the community.
May 14, 2021
287 words in the original blog post.
The game of telephone is recreated using Ruby on Rails, Nexmo Voice API, and Google Cloud Platform Speech to Text and Translate APIs. The application accepts an inbound phone call, takes an original message, converts it to text, translates it through multiple languages until it retranslates it back into English, and plays the final message back to the caller. To set up the application, a Vonage API account, virtual phone number, ngrok, Google Cloud Platform account, and Rails application are required. The application's controller actions define how the game is played, including answering the call, saving the recording, transcribing it into text, translating the text through multiple languages, and playing back the final translated message to the caller.
May 14, 2021
2,724 words in the original blog post.
Bots and artificial intelligence (AI) have made significant progress in recent years, but their technical maturity is still a topic of debate. According to Syd Lawrence, CEO/Co-Founder of The Bot Platform, bots are currently at the calculator watch stage, meaning they're not yet mainstream but have been around for many years. Martin Beeby, Technical Evangelist at Microsoft, notes that while chatbots and voicebots have improved in terms of understanding user intent, they still face challenges such as accurately detecting free-form English and providing a seamless onboarding experience. The key to further advancement lies in the development of more sophisticated AI systems that can truly understand user intent and provide a natural language interface.
May 14, 2021
1,258 words in the original blog post.
The concept of bot messaging has gained popularity, but its uniqueness lies in its ability to deliver messages with specific tasks or information, rather than engaging users in conversations. CEO Syd Lawrence and Microsoft Technical Evangelist Martin Beeby discussed the benefits of messaging platforms, including proactive messaging and high open rates, which are often higher than email marketing. They also touched on the importance of control and personalization in messaging, citing features such as sound and vibration notifications and non-interruptive messages that appear in Messenger. The duo noted that while push notifications can feel more personal, they may be exploited if not managed carefully, highlighting the need for gatekeepers to ensure responsible use of these platforms.
May 14, 2021
1,639 words in the original blog post.
To build a dead-drop phone number where messages can be left for someone to pick up later, you'll need a Vonage API account and a virtual phone number. You'll use Flask to create a basic voicemail service that allows people to call the Nexmo number and leave a message. The recorded message will be copied to your server, and you'll build a simple web page that lists the recordings and allows them to be played in the browser. You'll also store some metadata along with the audio, such as who made the call and when it was made, using TinyDB. Finally, you'll create a view that lists all stored recordings, including some of the associated call data, which can be viewed on a web page.
May 13, 2021
2,070 words in the original blog post.
Nexmo has announced new partnerships with major Artificial Intelligence leaders including Amazon, Google, IBM Watson, and Microsoft, enabling developers to integrate AI into real-time communications apps using the WebSockets feature of the Voice API. These partnerships provide access to advanced deep learning capabilities such as speech-to-text conversation, Natural Language Understanding, and language translation services. With these new integrations, Nexmo developers can build smarter software that combines AI with real-time communication solutions, enabling applications such as automated customer engagement, sentiment analysis, and personalized service.
May 13, 2021
716 words in the original blog post.
IVR systems are widely used, but creating a complex one with simple code can be challenging. This article introduced the use of XState, a popular State Machine library for JavaScript, to create a scalable and maintainable IVR system using Vonage's API. The example demonstrated how to model the call structure as a Finite-State Machine, utilize XState's interpret function, and modify the call structure with ease by changing the JSON object passed to the Machine function. Additional features of XState discussed include the Visualizer tool for sharing Statechart diagrams, self-referencing transitions, persistence, strict mode, and more. The code example provided can be used as a starting point for creating a real-world IVR system that scales well with user interactions.
May 13, 2021
2,426 words in the original blog post.
The tutorial provides a step-by-step guide to capturing SMS messages sent to a Nexmo number and logging them into a Google spreadsheet using an AWS Lambda function written in Python. The process involves setting up a Vonage API account, purchasing a virtual phone number, and configuring the AWS Lambda function to receive and log incoming SMS messages. The tutorial also covers how to integrate with Google Sheets using the Drive API and Service Account Key. The code bundle includes libraries for Nexmo and Google Sheets, allowing developers to capture feedback, registration, or other data through SMS messaging.
May 13, 2021
1,575 words in the original blog post.
The tutorial demonstrates how to use the Nexmo Voice API to create a simple voice proxy that hides a caller's real number. A business reason for this is to protect customer privacy. The process involves creating a virtual phone number, installing dependencies, defining webhook endpoints, logging call events, handling inbound calls, making webhooks accessible, purchasing a number, creating a Nexmo Voice API application, linking the application to the number, and implementing proxy logic using NCCO connect action.
May 13, 2021
1,531 words in the original blog post.
The new Nexmo .NET client library v4.0.0 is now available via NuGet Package Manager Console, supporting the new Nexmo Application API with greater programmatic control over applications, allowing developers to create, update, or delete applications and retrieve information about specific applications using their IDs or listing all created applications.
May 13, 2021
361 words in the original blog post.
"Create your own voicemail application powered by the Nexmo Voice API and Ruby on Rails."
This tutorial enables users to create their own voicemail applications using the Nexmo Voice API and Ruby on Rails, allowing customers to leave messages for each other. The process involves setting up a Vonage API account, purchasing a virtual phone number, creating a new Rails application, and configuring the application to receive and play back voicemails. The tutorial covers key steps such as creating routes, defining controller actions, and generating models, providing users with a comprehensive guide to building their own custom voicemail applications.
May 13, 2021
2,500 words in the original blog post.
Nexmo's communication APIs and SDKs offer a rich experience for users, allowing companies to build customizable contact center applications. The Nexmo Client SDKs enable the creation of in-app voice and messaging experiences, while also providing conversation context across channels, including phone calls, messages, and video. The Conversation API integrates these features, enabling developers to maintain user communication contexts. With ongoing additions, such as SMS and social media integration, Nexmo's contact center applications are becoming increasingly robust and smart. To get started with building a contact center application, the company provides demo apps and tools.
May 13, 2021
357 words in the original blog post.
The text discusses creating an application using PHP and Nexmo's Voice API to automate tasks such as calling and sending SMS messages. The author shares their personal experience working in a web agency where distractions were common, leading them to design a solution to improve workflow efficiency. They outline the steps to set up a Voice Application on the Nexmo dashboard, including generating an application name, event URL, public/private key pair, and API credentials. The text then delves into implementing the Nexmo client in PHP, creating a reusable service class, and adding functionality to send SMS messages using the Nexmo messaging API or its existing client. Finally, the author shares their completed example code, which includes a controller that reacts to event webhooks sent by Nexmo after every call, echoing an alert if the call fails. The goal is to create a simple phone status checker that can be expanded upon in various ways.
May 13, 2021
1,966 words in the original blog post.
The author of this text has created a Twitter bot that can be controlled using a phone call, allowing users to interact with it without needing data or Wi-Fi. The bot uses Nexmo's API and Dual-tone multi-frequency signalling (DTMF) to read out tweets from specific hashtags or accounts. To control the bot, users dial a number on their phone, which is then used as input for the bot. The bot can be customized to use different Twitter accounts or hashtags, and even other data sources like Hacker News. Once set up, users can call the virtual number to interact with the bot, which will read out relevant tweets or messages based on their input.
May 13, 2021
1,233 words in the original blog post.
This PHP application receives an inbound voice call from Vonage, processes the caller's phone number, and returns a dynamic response using Text-To-Speech to read out the number digit by digit. The application is exposed to the internet using ngrok, allowing Vonage to make requests to it when a call is received. The final step involves configuring the Vonage account with the application's URL and linking the purchased phone number to the application. With this setup, the PHP application can dynamically generate responses to incoming voice calls, providing a more personalized experience for callers.
May 13, 2021
1,159 words in the original blog post.
When it comes to SMS communications, sentiment analysis tools like IBM Watson Tone Analyzer help mitigate misunderstandings by providing a more nuanced understanding of emotions and communication styles. To integrate Nexmo SMS with this tool, developers need a Vonage API account and set up the IBM Cloud service, which provides credentials for running the application. The sample repository on Github allows for deployment to various platforms, including Heroku and Glitch, and enables users to analyze the sentiment of incoming SMS messages, providing valuable insights for teams to improve customer satisfaction or intervene in chatbot activity.
May 13, 2021
526 words in the original blog post.
As a developer, it's essential to consider how phone numbers are used in apps, as using real numbers can lead to unwanted calls and interactions with real individuals or businesses. Fortunately, many countries have designated specific ranges of phone numbers for fictional use, such as the 555 block in the US, which allows developers to use safe numbers without accidentally using a real person's or business's number. By using these designated ranges, developers can avoid potential issues and ensure their examples and demos are more realistic and less prone to prank calls or unwanted interactions.
May 13, 2021
577 words in the original blog post.
At Nexmo, a new feature called SIP Connect has been announced which allows WebRTC endpoints to be connected to the Nexmo Voice API, enabling PSTN users to dial into an OpenTok video session. This enables the creation of real-time video web applications that can connect with both WebRTC and PSTN users. To build such an application, a Vonage API account is required, along with TokBox credentials for the real-time voice and video functionality. The application will need to be built using JavaScript or other compatible languages, and will require server-side code in Express.js to handle requests and connect with OpenTok. Key endpoints include /room/:roomId, /dial-out, /nexmo-answer, /nexmo-dtmf, and /hang-up, which are used for rendering the video session, dialing out via SIP, answering calls from the Nexmo Voice API, prompting for a PIN code, and hanging up the call respectively. The application also handles event webhooks to receive updates on call status changes.
May 13, 2021
1,576 words in the original blog post.
The Nexmo Ruby gem is an officially supported client library that makes it easier for Ruby on Rails developers to integrate Nexmo's cloud communications APIs into their applications. The new Nexmo Rails gem takes another step in this direction by initializing a Nexmo client instance and making it available throughout the application. To use the Nexmo client, developers need to install the gem, add their API credentials to a `.env` file, and run an initializer to set up the client instance. Once set up, developers can access various Nexmo APIs such as sending SMS messages, creating voice interactivity, and retrieving number insights with ease. The Nexmo Rails gem is now available for installation in the Gemfile, allowing developers to integrate Nexmo's APIs into their Rails applications more straightforwardly than ever before.
May 13, 2021
794 words in the original blog post.
swift
In this tutorial, you will use the Vonage Video Client SDK for iOS to build a one-to-one video chat in SwiftUI. To get started, open Xcode and create a new project by going to File > New > Project. Select iOS as the platform and App for the template and give it a name. Install the Video Client SDK as a dependency and add necessary permissions. Create an instance of the OpenTokManager class, which connects to the Vonage servers using your credentials. The OpenTokManager class handles the setup, publishing, subscribing, and cleanup of streams. You can then build the UI by creating a ContentView that displays the publisher and subscriber views. If you build and run the project, you should now be able to start a video chat with another device or the OpenTok Playground.
May 13, 2021
1,536 words in the original blog post.
You will use the Spark framework to receive an HTTP call made by Vonage when your number gets a call, adding the necessary dependencies to your build.gradle file, defining the answer route which uses the ConnectAction and PhoneEndpoint classes from the Vonage Java Client Library to create the NCCO response. You need to register the answer route with Spark, purchasing a Vonage number to receive phone calls using the Vonage CLI, exposing your application to the internet safely using ngrok, configuring your Vonage account to link your phone number and application, and testing your application by calling your Vonage number.
May 13, 2021
1,221 words in the original blog post.
To exercise the new PHP client library a bit, we're going to build a simple SMS group chat where a user's inbound message is sent to all the other members of the chat. This script accepts [inbound webhooks](https://docs.nexmo.com/messaging/setup-callbacks#setting) from Nexmo, and processes the message. The logic here is simple, if the user is subscribed and active, their message should be sent to all the _other_ members. We need to check that the user is able to post a message to the group. If we found a user in the database, it means they were at some time subscribed to the group, but we need to check if they've left. The script uses regular expressions and `switch` statements to handle different commands and messages. It also logs important events such as users joining or leaving a group, sending a message, or replying to a user's message. Once all the message are sent, it adds the new message to the log collection on the database. With that we've setup a simple script that accepts inbound messages, replies to some of them, and relays others to a group. The command concept could be extended to more complex and interactive auto-responder bots, or this could be repurposed as a SMS distribution list that allows anyone to send an inbound message to a group of people.
May 13, 2021
1,815 words in the original blog post.
The Flood Voice Broadcast Alerts App is a Ruby-based Sinatra application that uses the Nexmo Text-To-Speech API to send voice alerts for subscribers who have opted-in to receive flood warnings for their postcode or phone number. The app allows administrators to select who should receive the alert and sends a voice message using the Nexmo API, which includes features such as automatic retry and detection of answering machines. The application uses a virtual phone number provided by Nexmo and stores subscriber information in an SQLite3 database.
May 13, 2021
1,309 words in the original blog post.
Convolutional Neural Networks (CNNs) provide a powerful mechanism for image classification, but building and training them can be challenging. The ML.NET TensorFlow library makes it easier to build and train CNNs in C# using ASP.NET Core applications. This tutorial demonstrates how to create an ML.NET TensorFlow neural network to recognize different types of dogs, train the model with images, and use a messaging API to classify incoming images and send feedback to users. The application uses a web server to receive messages from users, classify them using the trained model, and send back a response. To test the application, the authors used ngrok to expose the port to the internet and register webhooks with Nexmo's Messages API.
May 13, 2021
3,104 words in the original blog post.
Creating a voice proxy using the Nexmo Voice API allows users to make phone calls with confidence by masking their private phone number. To achieve this, users need to set up a Ruby on Rails application, expose it externally using ngrok, and link it to a Nexmo account, phone number, and Voice application. The application is then configured to forward inbound phone calls via voice proxy to the user's personal number, with options to announce or silently forward the call. With this setup, users can make secure and private phone calls while maintaining their anonymity.
May 13, 2021
1,515 words in the original blog post.
Turbolinks 5, authentication, and a web UI for customers are all great additions that could enhance the system. The use of Action Cable for real-time communication between the customer service agent and the customer is particularly interesting, as it enables two-way messaging without requiring page refreshes. Implementing authentication would add an extra layer of security to the system, while providing a user-friendly interface for customers would make the platform more appealing.
May 13, 2021
1,898 words in the original blog post.
The world-wide-web is a wondrous thing, enabling easy creation and sharing of information. However, much of what we create lives within walled gardens, which is the antithesis to the original idea of the web. Decentralisation has been a fundamental aspect of the web since its inception, allowing no central controlling node or single point of failure. Introducing the person-to-person web, where each visitor to your site becomes a peer in the swarm, sharing files directly and creating freedom from indiscriminate censorship. A tutorial demonstrates how to use Nexmo's Voice API with the Dat protocol to create a distributed website hosting an audio journal.
May 13, 2021
1,575 words in the original blog post.
Steve Lorello is excited to join the Developer Relations Team at Nexmo, bringing his extensive experience in the .NET stack to improve integrations with the platform. With a background in helping hundreds of developers and working on Air Traffic Control Systems, he aims to make developer interactions with Nexmo seamless and productive. In his free time, Steve enjoys running with his dog, watching sports, and exploring new destinations around the world with his wife. He looks forward to collaborating with the community and growing the .NET community at Nexmo.
May 13, 2021
233 words in the original blog post.
You will learn how to handle your first inbound call with Node-RED using the Nexmo Voice API, after installing the necessary components, including a virtual phone number and setting up a Nexmo application, which includes creating a Nexmo Call Control Object (NCCO) that defines actions to be followed when a call is handled. You will also set up an event handler to receive delivery receipts and deploy your flow to test it with your virtual number.
May 13, 2021
1,211 words in the original blog post.
In order to set up 2FA (two-factor authentication) on a WordPress website, you'll need to create a custom plugin and use the Nexmo Verify API. This setup requires a Vonage API account and involves several steps, including integrating the Nexmo PHP Library into your plugin, setting up user profiles with custom fields for the mobile number and 2FA status, sending verification codes via SMS or call, and validating the code entered by the user. The process also involves hooking into WordPress actions and filters to intercept the login action and validate the code before allowing the user to log in. With this setup, you'll have a secure way to protect your website and its users from unauthorized access.
May 13, 2021
2,144 words in the original blog post.
I'm Fabian Rodriguez, a Ruby Tech Lead at Nexmo's Developer Experience team, where I'll be focusing on improving our developer platform and documentation. I was born in Uruguay but have been living in Germany for the past couple of years, where I've developed a passion for web development with Ruby and JavaScript, as well as Machine Learning and Data Mining projects in Python. My interest in tech started when I took a programming course in high school, and I've since earned a Bachelor's degree, worked with startups and large companies globally, and co-founded a consulting company. Outside of work, I enjoy watching football, reading novels and science fiction, and spending time outdoors running, swimming, and biking, despite the challenges of German winter.
May 13, 2021
336 words in the original blog post.
In this article, readers learned how to use Nexmo's Number Insight Advanced API within an ASP.NET web application. The API provides various insights about a phone number, including its international and local format, country of registration, line type detection, mobile country code, and roaming information. The article demonstrated how to create a controller method to handle the API request, store the results in sessions, and redirect to a view displaying the advanced insights. The view displays the retrieved data, allowing users to see detailed information about the phone number they inputted.
May 13, 2021
681 words in the original blog post.
The Nexmo team has been busy releasing several new versions of their .NET SDK, including 4.0.1, 4.1.0, 4.1.1, 4.1.2, and 4.2.0, each with various improvements and features such as workflow ID parameter for verification requests, fully functional Application V2 API, redact library, get recording API, strongly typed NCCOs and webhook events, improved signing and validation of SMS messages, and bug fixes including tracking in progress NCCOs. These updates aim to enhance the SDK's functionality and usability.
May 13, 2021
653 words in the original blog post.
This tutorial demonstrates how to create an inbound Vonage SMS webhook and translate incoming text messages into English using the Google Cloud Translation API. To get started, one needs a Vonage API account, a Google Cloud project with the Translate API enabled, and ngrok for public traffic. The Express.js application is set up with the necessary packages, including `@google-cloud/translate`, `body-parser`, and `express`. The server listens on port 3000, and the webhook route is defined to handle incoming SMS messages. The `handleRoute` function checks if the message is valid and calls the `translateText` method to perform the translation. The `translateText` function uses the Google Cloud Translation API to translate the text into the target language specified in the environment variable `TARGET_LANGUAGE`. Once set up, the application can receive inbound SMS messages and translate them into English, making it a valuable tool for businesses looking to expand their reach across languages.
May 13, 2021
1,318 words in the original blog post.
To set up a conference call using Nexmo, developers need to create a Vonage API account, purchase a virtual phone number, and add the Nexmo PHP library as a dependency. They then write an `answer.php` file that returns a Nexmo Call Control Object (NCCO) to instruct how incoming calls should be handled, including a "talk" action for a greeting and a "conversation" action to join the conference call. The NCCO is returned with a Content-Type header set to application/json. Developers can test their code by starting a PHP webserver from the `public/` directory and making requests to the `answer.php` endpoint using an HTTP client. To make the code publicly available, developers can use tools like Ngrok to expose their local development platform. They then create an application with a webhook endpoint for incoming calls, link it to the purchased virtual phone number, and handle call events by writing an event handler in PHP. Once set up, developers can join conference calls using the Nexmo number and see the events arriving at the `event.php` endpoint.
May 13, 2021
1,225 words in the original blog post.
COBOL is widely used in the banking and finance industry for its reliability and security features. A tutorial on sending text messages using COBOL has been provided, which requires a Vonage API account, a virtual phone number, and a COBOL compiler such as GnuCOBOL. The tutorial covers the basics of COBOL programming, including data structures and module structure. It also explains how to define variables, use filler keywords, and call external programs using the SYSTEM program. The completed program is provided, which sends a text message using the Nexmo CLI. The tutorial concludes with suggestions for further exploration and resources for learning more about COBOL.
May 13, 2021
1,490 words in the original blog post.
The Nexmo Client SDK allows developers to create chat applications with audio functionality, enabling real-time communication between users. To get started, install Node and NPM, set up a Vonage API account, and clone the demo application from GitHub. The script can be used to automate the setup process, but manual configuration is also possible. Once set up, the application allows users to log in, start chatting, and enable audio communication. The JavaScript code handles user events, such as sending messages and enabling/disabling audio, and logs errors using a custom error logger. With both users logged in and having enabled audio, they can hold a conversation between each other, with options to click on Disable Audio to turn the microphone back off.
May 13, 2021
1,953 words in the original blog post.
At Nexmo, they take their developer documentation seriously but also have a lighter side with a collection of NCCO examples that showcase creative uses of the Voice API. The NCCO examples collection is a GitHub project where users can contribute and share their own examples, following no specific rules except for having fun with it. This collection includes tricks like connecting incoming and outgoing calls, changing voices, and using SSML to add emotion to spoken messages.
May 13, 2021
248 words in the original blog post.
The Vonage Conversation API allows developers to build conversation features that can take place across multiple mediums while maintaining context. This tutorial will explain the basics of how the Conversation API works by building a rudimentary on-page live chat as a use-case example. The chatbox will allow customers to message a support agent in real-time, and the support agent will be able to reply to the customer. The tutorial covers styling and layout aspects, including creating a slide-in chat window and laying out chat messages on either side of the chat interface. It requires a Vonage API account, Node.js, and installation of the beta version of the Vonage CLI. The tutorial also provides guidance on setting up a Node application using Express and Nexmo libraries.
May 13, 2021
2,446 words in the original blog post.
Vonage's Voice APIs are being used to implement a voice proxy technique that masks the phone number of callers by using an intermediary number, also known as a virtual number. This is done by creating an ASP.NET Core app and using NancyFX to handle HTTP requests, including forwarding calls from Vonage's Voice API. The process involves setting up a Nancy module with a route to answer incoming calls, which returns the NCCO (Nexmo Call Control Object) in response. To test this setup, a new URL is generated using Ngrok and used as the answer_url for the voice application. When a call is made, Vonage's Voice API requests the app to figure out how to respond, and the app responds with the NCCO, effectively masking the original caller's number.
May 13, 2021
768 words in the original blog post.
As users increasingly rely on voice bots and personal assistants for recommendations on their buying decisions, businesses will do all they can to have their products and services listed among the suggested options. Voice SEO is likely to become a key concept in this space, with platforms deciding which voice applications to suggest based on user commands. This could lead to a new market for optimizing voice apps to get to the top of suggestion lists, similar to AdWords-style bidding. The potential for invocation names to become like domain names where they're traded is uncertain, but it's possible that multiple skills with the same name could coexist, and platforms may decide which ones to suggest based on user commands.
May 12, 2021
417 words in the original blog post.
AI-powered personal assistants will need to understand individual preferences and behaviors to provide relevant, personalized recommendations. However, their level of personalization may be influenced by factors such as user payment status or the presence of advertisers. If users pay for a membership, they are likely to receive tailored suggestions; otherwise, the system may prioritize corporate interests over user needs. The extent to which these assistants become channels for advertisers is uncertain and will depend on various market dynamics. Ultimately, the balance between personalization and advertising will be shaped by the interests of those who fund the systems.
May 12, 2021
233 words in the original blog post.
Nexmo has introduced a new feature called split recording for its Voice API offering, allowing users to record two participants in separate audio channels, making call transcription easier. The feature enables users to work with the audio from a single participant easily. With this enhancement, users can record calls and fetch the recordings once the call is completed, enabling common tasks like call transcription. The new feature uses a specific Nexmo Call Control Object (NCCO) to enable dual-channel recording, which records the audio in both channels and sends the URL for the recording once the call is complete. Users can then transcribe the individual tracks using tools like IBM Watson or FFmpeg. By separating the audio into two mono tracks, users can accurately transcribe the conversation without having to manually merge the recordings. The feature also allows users to rebuild a timeline of the conversation as it happened, providing a more accurate representation of the call. Overall, Nexmo's split recording feature makes call transcription easier and more efficient for developers and businesses.
May 12, 2021
830 words in the original blog post.
This tutorial series is designed to help developers use the Vonage Voice API with ASP.NET, focusing on playing audio to a caller during an incoming call. To complete this tutorial, developers need a Vonage API account and a virtual phone number. They must also configure their project by initializing Vonage with their API credentials and creating a public/private key pair. The tutorial covers how to create a stream NCCO, which is used to send audio to the caller, and how to play that audio during the call using an ASP.NET Core controller. The code includes methods for dynamically creating the NCCO file and saving it to a specific path.
May 12, 2021
1,127 words in the original blog post.
We are excited to introduce node-red-contrib-nexmo v3, an updated version of a popular open source project that enables "flow-based programming for the Internet of Things." This new release provides functionality for all Nexmo products in general availability, including SMS, Voice, Verify, and Number Insight. With this update, users can now create flows for tasks such as sending SMS to multiple recipients, creating autoresponders, building phone call IVRs, or running phone number verification, among others. The Nexmo Node-RED package offers a wide range of benefits, including the ability to combine it with other services like Slack or IBM Watson, and provides lower-level access through custom JavaScript blocks. Thousands of developers are already working on Node-RED, creating various interactions, and sample flows can be found in the Node-RED Library. To get started, users need to install the runtime and editor, which can be done locally, on a device like a Raspberry Pi, or using cloud-hosted options. A local tunnel solution such as ngrok may also be required to expose the Node-RED server to the Internet for Nexmo platform communication. The community is actively contributing to this project, with helpful examples in the Cookbook and a 5-minute video tutorial on how to get started with the Nexmo Node-RED package.
May 12, 2021
545 words in the original blog post.
You've been set up for a blind date by your friends Bob and Carol, who are fantastically bad judges of character. Your date is rude, has terrible table manners, and smells funny. You need to get out of this date fast. To do so, you'll use the Fitbit Ionic smartwatch with the Nexmo Voice API to trigger a phone call from your friend Nexmo, which will ring your phone. The companion app on your phone will receive the request and forward it to the Nexmo server, which will then make the actual outbound call to your phone. You'll need to set up a server using Node.js and ExpressJS, configure your Nexmo account, and install the necessary apps on both the Ionic and your phone. With this setup, you can trigger a bail-out call by pressing a button on your watch, which will ring your phone and allow you to escape the date.
May 12, 2021
2,385 words in the original blog post.
You will create a Swift application that uses the Vapor web framework and the Nexmo Voice API to receive phone calls. To start, you need a Vonage API account with an API Key and API Secret, as well as a virtual phone number purchased through the Nexmo CLI. You'll use Vapor to create a simple web app, add a route for the voice answer, expose your application using ngrok, purchase a Nexmo number, create a Nexmo application to tie everything together, test your application by making a call to your Nexmo number, and learn about Nexmo concepts such as applications, URLs, and NCCO reference.
May 12, 2021
1,074 words in the original blog post.
This article is about using Vonage's Number Insight Basic API to retrieve basic information about a phone number within an ASP.NET web application. It guides developers through setting up the application, creating a view for users to input a phone number, and making a call to the Number Insight Basic API to retrieve international and national formats, country of registration, and more. The article concludes by showcasing how this information can be displayed on a view within the ASP.NET app.
May 12, 2021
554 words in the original blog post.
The tutorial outlines how to implement two-factor authentication for a user's phone number using Nexmo's Verify API endpoints in an iOS app. The process involves setting up the Glitch server, programming the UI to request or respond to requests with the server, and implementing functions to send SMS verification requests and verify PIN codes. The implementation includes storing a response ID to cancel or complete verification requests, making network calls to start, check, and cancel verification requests, and handling successful and unsuccessful verifications. The app's UI is reviewed, including a verification view controller with text fields for inputting email address, password, and telephone number, as well as buttons for login and cancel verification.
May 12, 2021
1,248 words in the original blog post.
A developer can build a front-end application with React that controls conversations in real-time using the Nexmo Client SDK, which allows users to control elements of the conversation. The application is built on top of an Express server, which provides routes for managing users and other work. The full-stack app consists of two separate applications: one running on port 3001 (the Express server) and another on port 3000 (the React client). The Nexmo Client SDK is used to generate JWTs, create new users, and manage conversations in both the front-end and back-end applications. The application can be started using npm start, which starts the Express server and the React client concurrently.
May 12, 2021
2,369 words in the original blog post.
This project involves building an answering machine detection system using a trained machine learning model, specifically a Gaussian Naive Bayes classifier, which achieved 96% accuracy. The system uses audio samples of beeps and speech to train the model, and then uses the trained model to detect when an answering machine is on a voice call. When a beep is detected, the system sends a message saying "Answering Machine Detected" into the call. The project also involves building a client application that connects to a websocket, observes when a beep is detected, and sends a TTS into the call when a voicemail is detected. The system uses Python libraries such as Scikit-learn, Librosa, and Matplotlib for machine learning and audio processing tasks.
May 12, 2021
1,878 words in the original blog post.
This tutorial covers implementing two-factor authentication for an Android app using Nexmo's Verify API endpoints, specifically focusing on sending verification requests and checking verification codes via a proxy server setup. The app uses Retrofit for networking and Moshi for JSON serialization/deserialization. It stores the phone number and request ID in SharedPreferences to cancel or check the status of any verification request. The network requests are similar to those made earlier to start the verification process, with error handling for responses. The app also includes a "Cancel" button to handle cancellation of the verification request.
May 12, 2021
1,673 words in the original blog post.
This is a tutorial on how to receive a phone call, record a message, and display the recording URL using Java and the Spark framework with Vonage API. To complete this tutorial, you need a Vonage API account, a virtual phone number, and a copy of the JDK installed. The tutorial covers setting up a new Java project with Gradle, defining routes for answering calls and logging recordings, purchasing a phone number and configuring your application to use it, exposing your application to the internet using ngrok, and testing your application. The tutorial provides an example of how to create an application that can receive a phone call, record a message, and display the recording URL in a few lines of code.
May 12, 2021
1,356 words in the original blog post.
To show your boss how hard you're working, you can use the power of Nexmo and GitHub Actions to send them a text message every time a push is received in your repository. To do this, you'll need a Vonage API account and a virtual phone number, as well as a GitHub Action workflow that uses the Nexmo SMS Action. The workflow will require three secret variables: your Nexmo API Key, API Secret, and phone number, which can be stored in environment variables for security. Once created, the action will send a text message to the specified recipient with a greeting and a mention of the user who pushed the code. This can help demonstrate your value to your boss and lead to a positive annual review and pay raise.
May 12, 2021
801 words in the original blog post.
Nexmo's Voice API allows developers to build high-quality programmable voice applications in the cloud, enabling features such as managing outbound and inbound calls, recording and storing calls, creating conference calls, and sending text-to-speech messages. Nexmo Stitch enables communications across multiple channels, including in-app messaging and in-app voice. To forward an incoming phone call from a Nexmo phone number to a Stitch user, developers must implement a Webhook and link it to a Nexmo Voice application, requiring the use of Node.js, ExpressJS, and Vonage API Account credentials. The process involves creating a webhook endpoint that logs events from Nexmo Application, responding to HTTP GET requests with NCCO, connecting calls with an existing Stitch user, and associating the application with the virtual number rented from Nexmo.
May 12, 2021
937 words in the original blog post.
The naming convention for Alexa skills can have a significant impact on their usability, as it affects how users interact with the app. Syd Lawrence shares his frustration with the current system, where users must use invocation names to trigger actions, making it cumbersome and limiting for some features. Oscar Merry offers a solution by suggesting that developers hide the invocation name from the user, allowing them to create more engaging experiences while still following Amazon's guidelines. By doing so, skills can benefit from increased usage, as seen in cases where invocation names are hidden from users. Additionally, companies may consider building multiple skills with different invocation names for specific use cases, or wait for future solutions that might eliminate the need for invocation names altogether.
May 12, 2021
792 words in the original blog post.
You will create an application that utilizes the Vonage Voice API to make outgoing text-to-speech phone calls using Java. To complete this, you need a Vonage API account, a virtual phone number, and JDK 11 installed. You'll use Gradle to manage dependencies and run your application. The application will initiate a phone call using the Vonage Java Client Library and execute a text-to-speech message using Nexmo Call Control Objects. To test your application, you need to start it with the `gradle run` command inside the project directory.
May 12, 2021
1,013 words in the original blog post.
The Portuguese city of Lisbon is one of Europe's sunniest cities, a perfect blend of tradition and modernity, attracting many international companies and entrepreneurs. Build Up Labs, a startup studio and incubator in Lisbon, focuses on innovation, creativity, and technology, aiming to simplify the world through its work. The incubator supports early-stage companies with an MVP from outside the EU, providing resources and networking opportunities to help them grow.
May 12, 2021
702 words in the original blog post.
The inaugural OneHack event was a success, bringing together employees from various Vonage offices to collaborate and innovate using the company's APIs and SDKs. The two-day hackathon provided an opportunity for developers to work on projects that integrated Nexmo or TokBox APIs and SDKs, with no set theme to encourage creativity. The event included activities beyond hacking, such as workshops, massages, and socializing, to promote wellness and team building. A diverse range of teams participated, including those from engineering, product management, and support teams. The winning teams showcased innovative projects, including an emergency responder system and a sentiment analysis tool for video conferences. The event received positive feedback, with attendees scoring the overall experience 9.2/10. The OneHack series is planned to be expanded globally in 2019, with the goal of increasing cross-border collaboration and making the event more inclusive for novice coders.
May 12, 2021
1,445 words in the original blog post.
I'm Plushcap, a helpful AI assistant with knowledge of software development and developer marketing.
Paul Ardeleanu is joining the Developer Relations team at Nexmo to work on the mobile developer experience of their new Client SDK. He has a background in programming, including his PhD in Computational Physics from UCLan, where he worked on the Linear Tape-Open project. Paul enjoys writing code in Swift, Ruby, and Objective-C, and is based in London but frequently speaks at European events. He invites developers to connect with him on the Nexmo Community Slack or Twitter to discuss their products and experiences.
May 12, 2021
161 words in the original blog post.
The Nexmo In-App SDK is a tool for building chat features into Android apps, providing better organization, maintenance, and weight reduction in code. By adding lifecycle-aware components, developers can separate concerns and create a more maintainable app. The process involves setting up dependencies, implementing a LifecycleObserver class to monitor the activity's lifecycle, and moving logic related to changes in lifecycle status to this new class. This results in a better-organized and maintained app that is easier for future developers to work with.
May 12, 2021
774 words in the original blog post.
When creating a Vonage Video publisher, you can source the stream directly from a user's camera, a `<video>` element, or a HTML `<canvas>` element. You can manipulate pixels before using them in a Video API session. The process involves several components, including a video element to take the stream, two canvases for drawing and replacing the background image. The code uses JavaScript to loop through pixels, remove green ones, and draw non-green pixels on top of a replacement background image. The project also includes initializing a Vonage Video API session and publishing from the second canvas. Finally, the `<video>` and `<canvas>` elements are hidden using CSS to make them invisible in the webpage.
May 12, 2021
1,150 words in the original blog post.
The Vonage Number Insight API provides real-time validation of user input to protect apps from fraud and spam, as well as details about phone numbers such as validity, reachability, and roaming status. The API is available in three levels: Basic, Standard, and Advanced, each offering different functionality for formatting numbers, identifying number types, blocking virtual numbers, and determining risk based on numbers. The Advanced API is also available asynchronously and synchronously. To use the API, developers need a Vonage API account and follow a series of step-by-step tutorials to set up an ASP.NET project and integrate the Nexmo C# Client Library.
May 12, 2021
591 words in the original blog post.
The Vonage Number Insight API provides real-time information about phone numbers globally, including validity, reachability, roaming status, and more. The API offers three types of requests: Basic, Standard, and Advanced, which return different levels of data. To use the API, a Rails application needs to be set up with a Vonage API account, a virtual phone number, and the necessary credentials. The application will present a form for users to submit a phone number and select the type of request they want to make. Once submitted, the form data is processed and sent to the Vonage Number Insight API using the `nexmo` method. The response from the API is then converted into a hash format and displayed in an HTML table on the show view. The application also includes features such as flash error messages and a secure way to store environment variables using the dotenv gem.
May 12, 2021
1,907 words in the original blog post.
Kelly J Andrews is a developer advocate for Nexmo and has been working in Developer Relations for six years, writing code for over fifteen years, and has recently joined the Extend initiative team as its leader. Kelly's passion for building lasting relationships and his experience in both coding and community outreach make him well-suited for this role. With over 30 years of tinkering with computers, starting with BASIC at age 5, Kelly is a strong advocate for JavaScript, testable code, and fast delivery. His enthusiasm for karaoke, magic, and sports can often be found outside of work.
May 12, 2021
261 words in the original blog post.
This tutorial guides users through setting up an Amazon Transcribe & Comprehend reference connection and a sample application using Vonage Voice API. The process involves setting up AWS AI platforms, including transcription engine Amazon Transcribe and sentiment analysis engine Amazon Comprehend, to enable real-time audio streaming of each party's voice via WebSockets from the Vonage platform. The application allows two parties to connect for a conference call, with separate real-time transcription and sentiment analysis for each party's speech. The setup requires a Vonage API account, virtual phone number, and server public hostname and port information, which are used to set up the sample application and test drive the integration architecture.
May 12, 2021
744 words in the original blog post.
This guide instructs developers to set up a Node.js server as a proxy to interact with the Nexmo Verify API, rather than integrating directly with the API in their mobile app. The server uses Express and body-parser to parse JSON responses, and interacts with the Nexmo REST API client for Node.js. To complete this tutorial, developers need a Vonage API account, which provides an API Key and API Secret that are used to authenticate requests to the Verify API. The server implements three endpoints: /request to initiate verification, /check to verify a code, and /cancel to cancel a verification request. After setting up the server, developers can build Android or iOS apps to network with this server using the Nexmo Verify API. The guide also includes information on how to protect against rate limiting requests to the server.
May 12, 2021
1,287 words in the original blog post.
I'm excited about the new integration between Nexmo and IBM Voice Gateway, which allows for seamless integration with IBM Watson speech and conversation services. This enables developers to build more conversational voice agents that can handle complex customer interactions. With the integration, users can direct voice interactions with a cognitive self-service agent or access real-time transcriptions of phone calls. The Nexmo platform provides the call anchor and core telephony integration for Voice Agent, making it easy to deploy applications in IBM Cloud. A GitHub repo has been created to simplify the process, including code samples and tutorials, using Node-Red as the service orchestration engine. This allows developers to build voice applications that can detect intent and provide Watson-enhanced voice interactions to users.
May 12, 2021
529 words in the original blog post.
The tutorial reviews Apple's new feature Safe Area Layout, introduced at WWDC 2017, and its use in creating a basic conversational user interface with Nexmo In-App Messaging. The Safe Area Layout provides a simplified way to map Auto Layout constraints to views, making it easier to create flexible layouts without UIKit bars. To implement the tutorial, developers need to set up a Vonage API account and a virtual phone number, then create an iOS project with the deployment target set to iOS 11 or higher. They add functionality for two outlets and one action in ViewController.Swift, and control-drag UI elements onto the view controller. The tutorial uses Nexmo In-App Messaging's cross-platform SDKs to integrate messaging experiences into mobile applications. Developers can create a conversation, user, and join the conversation using the Nexmo API, then connect the view controller with the controller, log in the user, send text events, and receive new events.
May 12, 2021
1,584 words in the original blog post.
The rapid advancements in bot and AI technology have led to a reevaluation of the potential for voice as a viable computer interface, with Microsoft Technical Evangelist Martin Beeby and Opearlo Co-Founder/CTO Oscar Merry predicting that voice-led computing will become mainstream sooner than expected. They envision a future where voice becomes the primary input method, allowing users to interact with technology without screens or touch interfaces. This shift could lead to new ways of interacting with technology, such as ambient computing devices that understand natural language and respond accordingly. The conversation highlights the importance of speech recognition research, which is being invested heavily by major technology companies, and suggests that this future may arrive sooner than many people realize.
May 12, 2021
953 words in the original blog post.
This article is about using Nexmo's Number Insight API within an ASP.NET web application to retrieve insights about a phone number, including its international and local format, country of registration, line type detection, mobile country code, and reachability. The article covers setting up the ASP.NET application, creating methods for navigating between views, requesting standard insights from the API, and displaying the results on a view. It also provides hands-on code examples and demonstrates how to use the Number Insight Standard API to retrieve specific information about a phone number.
May 12, 2021
643 words in the original blog post.
This tutorial demonstrates how to build a serverless application using the Chalice framework that invokes the Nexmo Voice API to play a message, ask for user input, and then send a callback with the result of the interaction. The application is deployed on AWS Lambda and uses DynamoDB to store call state information. The process involves deploying the function to AWS, setting up authentication using either private key or JWT authentication methods, and invoking the function with parameters such as the number to be called, initial message, PIN code, callback URL, and callback method. After the call is completed, the Lambda function makes a callback request to a webhook specified during invocation, containing details of the call and result. The application provides flexibility in handling user input, retries, and error messages, allowing developers to customize their implementation as needed.
May 12, 2021
1,189 words in the original blog post.
The author and their collaborator created a DIY Babel fish system that enables two people to communicate in any language, using Nexmo's Voice API and Microsoft Translator Speech API. The system consists of a Tornado web server that handles incoming calls, translates speech in real-time, and speaks the translated text back to the caller. The authors set up their environment, created a Nexmo application, and obtained keys for the Microsoft Translator Speech API. They then implemented the CallHandler, EventHandler, and WSHandler to handle the call flow, events, and WebSocket communication with the translator API. The system can be used for bi-directional calls, allowing users to communicate in their chosen languages.
May 12, 2021
3,602 words in the original blog post.
"In this post, we explored streaming an audio file into an in-progress phone call using the Vonage Voice API and Ruby gem. To achieve this, we created a Sinatra web server that serves four routes: three GET requests to initiate the phone call, provide NCCO instructions, and stream a silent file, and a POST request to stream audio once the call has been answered. We utilized the dotenv gem to store our Vonage account credentials as environment variables, ensuring they are not committed to source control. With approximately 40 lines of code, we successfully created a fully functioning web server that can call any phone number and play streaming audio into that call."
May 12, 2021
1,562 words in the original blog post.
I'm Garann, a JavaScript Developer Advocate at Nexmo, and I'll be working from Glasgow, UK. I've had a diverse background, having worked in England, Spain, Edinburgh, Italy, and Seattle, before moving to Austin for five years. In my previous role as a Developer Educator at Vonage, I was passionate about templates, Node.js, progressive web apps, and offline-first strategies, but my true love is well-documented APIs. My goal is to make the experience of using Nexmo's API the best it can be, and I'm excited to meet you all in the community and chat about application architectures and other topics.
May 11, 2021
308 words in the original blog post.
The following is a neutral, objective, and interesting summary of the provided text:
Building an integrated video call system with Zendesk using Vonage Video API allows customers to have a richer customer experience. The integration involves several components: the server-side application, which handles requests and updates the ticket; the client-side applications for both the support engineer and the customer; and the Vonage Video API, which enables video calls and recording functionality. The system includes features such as session creation, video publishing, screen sharing, and recording with automatic upload to an AWS S3 bucket. An event-driven architecture allows the server to receive notifications when an archive is uploaded to the S3 bucket, enabling dynamic handling of recordings and their upload to Zendesk tickets for both parties to access later. The integration enables a more engaging support experience by incorporating video calls into the ticketing system.
May 11, 2021
4,242 words in the original blog post.
You're going to create an SMS client that supports bulk messages and templates for personalization, using Python and the Nexmo API. The application will have a basic CRM to hold contacts, with multiple choice values such as diminutives, greetings, and valedictions. Templates will be rendered using Jinja2, with random variations added in to make each message look personalized. You'll need to install dependencies, set up environmental variables, and create commands for managing contacts and templates. The client will allow users to select which numbers to send the message to and which template to use, and it will log the results of sending messages to show variation across different contacts.
May 11, 2021
890 words in the original blog post.
Amazon Comprehend provides sentiment analysis with a baseline confidence level of 1, using positive and negative scores to indicate sentiment, with additional features such as entity analysis and syntax analysis available at no extra cost. Accuracy is highest when phrasing and intent are straightforward, but can be challenging due to sarcasm and other language devices. Pricing is based on units, with Amazon's minimum unit being 100 characters. Azure Text Analytics API also charges per 1000 characters, while Google Natural Language API uses a block-based pricing model. IBM Watson Tone Analyzer provides sentiment analysis alone, with a baseline confidence level of 1 and tone_id labels to classify sentiment further. Setup for each service is relatively easy, with minor exceptions. The choice of provider depends on language needs and cost breakdown based on usage volume.
May 11, 2021
1,755 words in the original blog post.
A developer can create an inbound Vonage SMS webhook to translate incoming messages into English using the IBM Watson Language Translator API. To set up this project, they need a Vonage API account, an IBM Watson Language Translator account, and ngrok for public access. The code uses Express.js, body-parser, and the ibm-watson package to handle the translation. After setting up the server and installing necessary packages, the developer can create an index.js file with a webhook function that translates incoming SMS messages using the IBM Watson Language Translator API. The final piece is adding routes for GET and POST methods to handle inbound SMS webhooks and testing the functionality by sending a text message to the purchased phone number.
May 11, 2021
1,196 words in the original blog post.
The Vonage API allows users to automatically forward calls from a virtual phone number to any personal phone number on an iPhone using the Shortcuts app. This tutorial demonstrates how to create a new Shortcut that collects user input, makes an HTTP request to update the incoming call forwarding settings in the Vonage Numbers API, and logs submitted numbers to a file. The process involves creating a virtual phone number, collecting user input, setting up the call forwarding, and logging submitted numbers. The Shortcuts app is used to automate repetitive tasks without writing code, making it accessible to users who want to integrate their iPhone with the Vonage API.
May 11, 2021
1,099 words in the original blog post.
The Nexmo Verify API allows developers to validate users' phone numbers, ensuring that they are indeed reachable on the provided number. To set up this process in Node-RED, developers need a Vonage API account and credentials, which can be found on the dashboard. The `sendverify` node is used to start the verification process by sending an SMS message with a PIN code to the user's phone number. After submitting the received PIN code, the `checkverify` node compares it to the one generated by the Verify API, and if successful, outputs a response indicating that the verification has been completed. The status of the verification can be used to customize notifications to the user, such as displaying a success message or an error message if the verification fails. Additionally, developers can implement buttons to escalate the verification process to a TTS call instantly or cancel the verification process altogether. The Nexmo Verify API Reference provides more information on the available fields and their meanings in the response objects.
May 11, 2021
3,113 words in the original blog post.
The provided text describes how to create a video chat app using the OpenTok API, adding a custom video source with moving snowflakes in real-time, and publishing it to a session. The app requires a TokBox account and an API Key and Secret for authentication. It uses the Canvas API to capture the camera stream and apply a filter to create the snowy effect. The video is then published to the session using OpenTok's publisher object, allowing users to share their live video feed with others in real-time. The code includes event listeners for stream creation and connection establishment, ensuring seamless communication between participants.
May 11, 2021
787 words in the original blog post.
A lot of the heavy lifting done by the Nexmo Messages API happens on the server-side. Messages are sent, received, processed and so on but usually all this activity is hidden away from end users of many of the applications that utilise the API. The display of these messages to the end user is handled by their respective applications or displayed in a browser using WebSockets API. To send an SMS from the browser with Nexmo's Messages API, a virtual phone number needs to be purchased and linked to the application. The client-side involves setting up a WebSocket connection to establish communication between the server and the browser, while the server-side involves setting up routes for handling incoming POST requests from Nexmo and utilizing Nexmo's Messages API to forward messages to recipients' phones. This tutorial covers the process of building a virtual phone in the browser that can send and receive SMS using Nexmo's Messages API.
May 11, 2021
3,666 words in the original blog post.
This tutorial is part of a series on using Voice APIs with ASP.NET, focusing on handling user input during an inbound voice call. The goal is to create an ASP.NET app that receives and responds to user input, such as pressing buttons or entering a PIN. To achieve this, the tutorial uses NancyFX alongside ASP.NET Core to handle HTTP requests and Vonage's Voice API to make outgoing calls. The app sets up a route for handling incoming calls and user input, using Text-To-Speech to greet the caller and collect DTMF (Dual Tone Multi Frequency) input from the caller. The tutorial provides step-by-step instructions on configuring the project, setting up the Vonage account, and testing the code using Ngrok.
May 11, 2021
1,000 words in the original blog post.
Node.js is used to build small APIs using five popular frameworks: Express.js, Koa.js, Restify, and Hapi. Each framework has its own strengths and weaknesses, such as Express.js being lightweight and unopinionated, while Koa.js is async-friendly and lacks built-in features, and hapi being extremely scalable and enterprise-ready. The choice of framework ultimately depends on the developer's familiarity with the best practices for optimizing code performance and the need for specific features like routing and response types.
May 11, 2021
1,184 words in the original blog post.
The text discusses setting up an inbound Vonage SMS webhook to translate incoming messages into English using AWS Translate. To get started, a Vonage API account is required, along with an IAM user with the necessary permissions and credentials for AWS Translate. The application is set up using Express.js, with ngrok used to make the server publicly accessible. The webhook is created to handle incoming SMS messages, which are then translated into English using the AWS Translate service. The code includes examples of how to use the Vonage API, ngrok, and AWS Translate, as well as a completed version of the tutorial on GitHub.
May 11, 2021
1,207 words in the original blog post.
The author of this post, a dad, wanted to create a Santa Delivery Notification system for his family using the Nexmo Dispatch API with Facebook Messenger as the primary notification channel and SMS fallback. The system uses a combination of Node.JS, the Nexmo Dispatch API, the Santa API, Facebook Page and Application to determine where the user is located and compare it to Santa's delivery route. Once subscribed, the system sends notifications when Santa is moving away from the user's location, with an option for SMS fallback if the message isn't read. The author has made the code available on GitHub and invites readers to try out the Dispatch API standalone and suggest enhancements or ideas for improvement.
May 11, 2021
1,008 words in the original blog post.
Nexmo Client SDKs have moved from Developer Preview to Beta, offering real-time communication capabilities across various channels including voice and messaging. The new version enhances performant communication by reducing the need for developers to manage conversation events, while introducing custom events that can be integrated with existing channels. This update also improves rich in-app voice and phone calls, adds media control in multi-member conversations, and provides enhanced developer experiences through performance and API improvements. With this new release, users will have access to a more robust and flexible platform for their unique customer communication needs, allowing them to seamlessly integrate various channels into the conversation.
May 11, 2021
371 words in the original blog post.
The development of Vonage API Developer's documentation platform has undergone significant changes since its inception three years ago. Initially built using Ruby on Rails, it was designed to be flexible and adaptable to meet the evolving needs of the company. Over time, the tooling around the platform has expanded to include automated spell checking, internationalization, and API specification checks. However, as the platform grew in complexity, it became clear that a more modular approach was needed. After exploring alternative solutions, the team behind Vonage API Developer discovered Station, a content-agnostic platform that can support various content forms and media. Station is built to provide a flexible and customizable solution for creating text-driven content websites quickly, empowering non-programmers to contribute content in a streamlined fashion. With its open-source nature and Ruby on Rails foundation, Station is poised to become a robust tool for Vonage's documentation needs.
May 11, 2021
796 words in the original blog post.
This tutorial covers building a simple WhatsApp chatbot that performs currency conversions using the exchange rates provided by Coinbase. The bot is built using Node.js, Express, and Vonage's Messages API. To build the bot, developers need to set up their local environment with Ngrok, create a Vonage API account, and whitelist their WhatsApp number in the sandbox. The bot receives incoming messages via WhatsApp, validates the message format, and performs currency conversions using Coinbase's API. The converted amount is then sent back to the user as a response. The tutorial includes setting up environment variables for the bot and testing its functionality.
May 11, 2021
1,463 words in the original blog post.
This summary highlights the key points of building a web application that enables users to engage in video chat and send messages using OpenTok for video conferencing and Nexmo In-App Messaging. The application structure includes a server-side component built with Express.js, which generates credentials for both OpenTok and Nexmo, allowing clients to connect to these services. The client-side code utilizes the `@opentok/client` library for OpenTok and `nexmo-stitch` for Nexmo, enabling features like video chat, message sending, and conversation history display. The application's frontend is built using EJS templates, which render the necessary HTML elements with the generated credentials. The final step involves running the server with npm start, allowing users to interact with the web application through a user-friendly interface.
May 11, 2021
1,706 words in the original blog post.
This article demonstrates how to build a WhatsApp call center using the Vonage API, with the goal of providing better customer service by making interactions more familiar and engaging for customers. The tutorial shows how to set up a demo app that uses emojis to identify threads between multiple chats, allowing agents to easily distinguish between different customers. To complete the tutorial, users need to have a Vonage API account, a WhatsApp Business Account or a Messages API Sandbox, as well as a public URL for their application. The tutorial guides users through setting up the application, configuring webhooks and credentials, and starting the application locally. Once set up, users can start sending messages to customers and receive responses with emojis that indicate which customer they are responding to.
May 11, 2021
573 words in the original blog post.
Nexmo's Selective Audio Controls allow supervisors to listen to calls without being heard by customers or agents. This feature uses participant IDs and conversation actions to control audio flow. A Node.js application is created using Express, which serves an answer URL that returns a valid NCCO based on the caller's role. The application generates three types of NCCOs: customer, agent, and supervisor, each with specific parameters to control who can speak and hear in the conversation. Once the application is complete, it uses a findParticipants method to search for leg UUIDs by role and stores them when a request is made to the answer URL.
May 11, 2021
1,240 words in the original blog post.
The Vonage developer portal has added a "Run in Postman" button to its Postman page, making it easier for developers to explore and integrate the company's APIs using the popular tool. This feature allows users to access the Vonage API Calls, organized into a collection, with minimal work involved, and also provides features such as environment variables and a pre-configured Vonage Environment. The developer portal also links to the main Postman network for browsing, and includes a tutorial on using the Postman Collection to explore the Numbers API, which allows developers to manage virtual number inventory programmatically.
May 11, 2021
468 words in the original blog post.
The Nexmo DevRel team is attending the Grace Hopper Celebration of Women in Computing, an annual event that brings together over 20K women from 81 countries to learn, network, and build relationships. The team will be represented by Lauren Lee and Amanda Folson, who are eager to connect with attendees and speakers alike. They will also be looking for individuals who have used Nexmo APIs to submit tutorials for the Developer Spotlight program, which aims to publish high-quality technical content and inspiring development stories. The team invites attendees to power up at their charging stations throughout the celebration, where they can meet Lauren and Amanda, get help with Nexmo, and learn more about the Vonage API.
May 11, 2021
349 words in the original blog post.
The Vonage Video API team has released a new version of the Vonage Video Client SDK, v2.18, which includes several new features such as support for Linux SDK on Debian 10, IP Proxy feature to route traffic through reverse proxy servers, improved WebRTC stats, and security patches for iOS, Android, and Windows SDKs. The Linux SDK unlocks new use cases ranging from native desktop applications to IP camera-based streaming, while the IP Proxy API allows applications to route all Vonage Video HTTPS & WS traffic through their reverse proxy server. Additionally, the team has added support for collecting raw WebRTC statistics with the JavaScript SDK 2.18.0, and improved security measures to protect against WebRTC vulnerabilities. The new release is available on the standard environment and will be released to the Enterprise Environment in early October.
May 11, 2021
858 words in the original blog post.
JSON Web Tokens (JWTs) are a popular authentication method used in modern web applications, but debugging issues can be challenging. To diagnose problems with JWTs, it's essential to first check if the token looks plausible and then use specialized tools like jwt.io to inspect its contents. The tool provides detailed information about the token's header, payload, and signature, helping developers identify potential issues. Sometimes, the problem may not be with the JWT itself but rather with the application or configuration. In such cases, generating a new token, creating a new application, or regenerating keys can help resolve the issue. Debugging is a skill that requires patience and persistence, and this post aims to provide valuable insights and techniques for troubleshooting JWT-related problems.
May 11, 2021
684 words in the original blog post.
The Daily Stand Up is a brief meeting where team members share their progress, blockers, and goals. Due to being distributed, the author of the text created a chat-bot in Slack to individually share updates with the whole team. To apply this idea to family, the author used Vonage's Messages & Dispatch APIs to create a consolidated channel for weekly updates. The tutorial guides through creating a Vonage account, purchasing a phone number, and setting up an application using Glitch. The app is designed to send a text once a week, with the option to receive responses from family members and showcase them on the frontend. The project uses Node-Schedule to schedule the text sending and Express.js for routing and logging.
May 11, 2021
1,607 words in the original blog post.
The COVID-19 pandemic has accelerated the adoption of digital technologies in various industries, with facial ID being one of the prominent features. Vonage's Video API is being utilized to enable contactless services while protecting user data and personal information. The API can be used for various use cases such as customer service, voter registration, fraud prevention, and more. To build a complete facial ID application, developers need to use methods and objects provided by the API, including subscribe, detect, identify, and match facial ID, using sample code snippets and integrating with Microsoft Face API. Vonage aims to minimize development time for its customers by providing guided implementation, deployment, and best-guided adoption services.
May 10, 2021
988 words in the original blog post.
Hacktoberfest is a month-long celebration of open source software brought to you by DigitalOcean in partnership with Dev & Intel. Maintainers guide potential contributors towards issues that will help move the project forward, and contributors get the opportunity to give back to projects they like. To participate, individuals must submit four quality pull requests to public GitHub repositories between October 1-31, and can choose a prize such as a Hacktoberfest shirt or a $5 Open Collective Gift Card upon completing their contributions. The event is open to everyone, regardless of coding background or skill level, and Vonage will be supporting participants through various channels including daily streams on Twitch, blog posts, tutorials, and developer community support.
May 10, 2021
467 words in the original blog post.
Bethany Loft, the new Junior Developer Community Event Manager at Nexmo, joins from Goldsmiths University in Anthropology and Media, bringing a background in events, activity administration, and organizing hackathons to her role. Originally from Hull, she moved to London after studying Anthropology and Media while traveling as an au pair. She is excited to create a welcoming atmosphere for the Nexmo community, sharing her passions for anthropology, environmentalism, and reading, as well as cheering on sports games like NFL and netball matches. With a strong connection to the tech community through her involvement with Hacksmiths, Goldsmiths Tech Society, she looks forward to meeting everyone at the London office and using the space for events.
May 10, 2021
270 words in the original blog post.
If you have friends and family in more than one location, the ones that you are not spending Christmas with will probably complain about the costs of calling you at Christmas. At least, I'm pretty sure that's not just me! This post is an opportunity for me to share my favourite Nexmo trick for giving your dad (or whomever) a local rate number to call that won't cost you a small fortune if he decides to talk for an hour. To complete this tutorial, you will need a Vonage API account and a virtual phone number, which can be purchased through the Vonage API Dashboard. A number in the "right" geography is essential as the cost of renting a number varies depending on the country it's from. The author uses the `nexmo number:search` command to find available numbers in the UK, then buys one using the `nexmo number:buy` command. Once purchased, the Nexmo number can be set up to forward calls to the desired phone number, allowing for easy changes and cost-effective calling rates. With this trick, it's possible to stay in touch with loved ones at a lower cost.
May 10, 2021
534 words in the original blog post.
This AI model, GPT-3, is a deep learning language model that can generate new content given a small number of examples of input data. It's trained on thousands of articles from Wikipedia, web sites, and books, and contains 175 billion parameters, making it one of the most complex models ever developed. GPT-3 uses a transformer architecture with attention mechanisms to remember specific parts of the sentence, allowing it to focus on important words and phrases. The model can be used for various tasks such as question answering, summarizing sentences, translation, text generation, image generation, performing three-digit arithmetic, unscrambling words, and more. With access to the OpenAI API, developers can supply training data and use GPT-3 to generate HTML from a given string, create layouts, build text adventures, and even convert English into regular expressions. GPT-3 is a powerful tool that has the potential to revolutionize various industries and applications, but it requires significant computational resources and expertise to train and use effectively.
May 10, 2021
1,732 words in the original blog post.
The tutorial covers building an Ionic app that allows users to make calls across three platforms (web, iOS, and Android) using the Vonage Client SDK. The project uses React as a frontend framework. To complete the tutorial, developers need a Vonage API account, Xcode 12 for iOS development, Android Studio with JDK 8 or newer for Android development, and Node.js installed on their machine. They also need to install Ionic and its dependencies, set up environment variables for Android development, create a Vonage application, generate a JWT for authentication, and configure the NCCO for making calls. The tutorial provides step-by-step instructions for running the project on each platform, including web, iOS, and Android, with minimal code changes required between platforms.
May 10, 2021
1,084 words in the original blog post.
The key to avoiding common pull request mistakes from having an out of date master branch is to set up a workflow where the local main or master branch is always in sync with the upstream project, and this can be achieved by adding the upstream repository as an "upstream" remote before making changes. This allows for easy collaboration and prevents accidental inclusion of additional changes in the pull request. By syncing the local main or master branch with the upstream project before branching, developers can create high-quality pull requests that are consistent with the rest of the project's codebase.
May 10, 2021
393 words in the original blog post.
To build a simple chat application with React and Nexmo's client-side JavaScript tooling, developers need to follow several steps. First, they must have a Vonage API account and create an application to generate conversation IDs. Then, they can add a new component to their React application at `client/src/Chatroom.js` and modify the existing `NexmoApp.js` file to use the new component. The chat room component will contain two states: choosing a chat room and the chat room itself, with functions for joining a conversation, sending messages, and rendering messages. Once the user is logged in and has joined a chat, they can send and receive messages using a textarea and button input field. The events raised by the message input are handled in `setInput` and `sendInput`, which store the inputted text in the component state and pass it to the Conversation using `sendText`. With this setup, developers have a basic chat application that can be extended with additional features such as error handling and performance optimization.
May 10, 2021
1,373 words in the original blog post.
Hacktoberfest is now an opt-in event, but maintaining high-quality pull requests can still be overwhelming for maintainers. To prioritize effectively, consider your project's aims and goals, its contributors, and then yourself. Managing notifications on GitHub is crucial to coping with overwhelm; set up custom routing, watch and unwatch repositories, subscribe and unsubscribe from specific issues or PRs, and move quickly to reject or provide feedback on pull requests. Maintaining a welcoming community is also essential, so take the time to thank contributors for their input and engage in friendly, yet efficient, communication.
May 10, 2021
1,010 words in the original blog post.
This tutorial guides developers through building a simple bot on Glitch that can provide random facts about numbers using the Nexmo Messages API and NumbersAPI. The bot is built using Hapi.js, a Node.js framework, and utilizes a virtual phone number to send and receive SMS messages. The bot's functionality includes receiving inbound SMS messages, processing the message content, and sending a response with a random fact from NumbersAPI if the content is a whole number. The code demonstrates how to integrate Nexmo's Messages API and Hapi.js into a Glitch project, allowing developers to build their own custom bots using these APIs.
May 10, 2021
1,716 words in the original blog post.
This tutorial teaches developers how to set up an Interactive Voice Response (IVR) system using Vonage's Voice API and ASP.NET Core applications, with a focus on collecting Dual-Tone Multi-Frequency (DTMF) input from users over Public Switched Telephone Network (PSTN) calls. The process involves setting up a Vonage API account, creating a Vonage application, installing the Vonage SDK in an ASP.NET Core project, and configuring the app to receive DTMF input from users. The tutorial provides step-by-step instructions and code examples for building the IVR system, including handling incoming calls, processing user input, and sending responses back to the caller. Once set up, developers can test their application by dialing into their Vonage number and interacting with it using a handset or other DTMF-enabled device.
May 10, 2021
1,408 words in the original blog post.
This tutorial guides users through setting up a conference call using Java, Spark framework, and the Vonage API. To start, they need to create a new Java project, add necessary dependencies, define an answer route for incoming calls, configure their Vonage account, and expose their application to the internet. The process involves purchasing a virtual phone number from Vonage, creating an NCCO with talk and conversation actions, and configuring Spark to serve the NCCO. Users can test their application by calling the purchased phone number and having multiple people join the conference call.
May 10, 2021
1,048 words in the original blog post.
Nexmo has improved its call recording capabilities by supporting up to 32 channels in every single recording, making it easier to handle common use cases such as transcription for multi-participant calls. To achieve this, developers can create a Node.js application that uses Nexmo's Voice API to connect multiple participants and record their conversations. The application must handle HTTP requests from Nexmo, including webhook notifications when recordings are available, and transcribe the audio using Google's Speech-To-Text service. With this setup, developers can automatically transcribe multi-participant calls, including separate channels for each participant, allowing them to accurately identify who said what during the conversation.
May 10, 2021
1,765 words in the original blog post.
Spotlight for Donations is a program offered by Vonage's Developer Spotlight, which allows authors to create content and contribute to the community while also having the option to donate their $500 payout to a tech-focused charity. The program aims to grow the library of tutorials on innovative ways to use APIs while supporting tech-focused nonprofits and charities doing important work in the industry. The charities included in the program are identified as 14 organizations that focus on increasing diversity, promoting STEM education, protecting internet user privacy, and providing technology support to non-profits and communities. By contributing to the program, authors can teach others, grow their own expertise, and make a positive impact on the community and industry.
May 10, 2021
983 words in the original blog post.
A lot of contributing to open source changes depending on the angle you approached programming from. Some people find a command line interface easier and more direct for managing version control tasks, while others prefer the convenience of graphical user interfaces. The right tool for the job is the one that feels comfortable to use. For those participating in events like Hacktoberfest, various GUI clients such as GitHub Desktop, GitKraken, and Sourcetree are available to make it easier to contribute. Vonage is a partner in Hacktoberfest 2020 and provides resources on its page for participants. The choice of tool ultimately depends on personal preference and specific needs, with many free and open-source options available.
May 10, 2021
636 words in the original blog post.
Laura Czajkowski is excited to join the Developer Relations Team at Nexmo. She has been active in Open Source communities since 2000 and has led various initiatives on software testing, documentation, and advocacy. Laura believes that building diverse community pools leads to better projects. In her free time, she enjoys rugby, travel, photography, trying new restaurants, and spending time with her pets.
May 10, 2021
271 words in the original blog post.
Nexmo publishes OpenAPI specifications for its APIs, making it easier for developers to explore, evaluate, and integrate the APIs into their own applications. OpenAPI is a machine-readable way to describe an API, providing details such as authentication mechanisms, endpoint descriptions, and response formats in a verbose format that can be easily understood by machines. This allows for automated code generation, testing, and library SDKs, making it a powerful tool within API provider companies. Sharing OpenAPI specs widely outside the organization can also facilitate faster development and reduce dependencies on proprietary documentation. Developers can explore APIs using tools like Postman, which supports OpenAPI v3 files, and generate their own SDKs to speed up API integrations.
May 10, 2021
830 words in the original blog post.
The author proposes creating an interactive scavenger hunt app using Nexmo's Voice and SMS APIs, Express, and Node.js. To start, users need to create a Vonage account, purchase a Nexmo phone number, and set up a Nexmo voice application. They then link their phone number to the application, generating QR codes that lead to a Glitch project. The app allows users to record clues, which are stored in an asset file on Glitch. When a user scans a clue with their smartphone, the app sends an SMS to the designated Nexmo number, and upon receiving the message, the phone makes a call to play the next clue's audio recording. The game continues until all clues have been found, providing a fun and engaging way for users to explore their city or neighborhood.
May 10, 2021
1,656 words in the original blog post.
Transcription of voice recordings has become increasingly accessible thanks to advancements in technology, particularly APIs, allowing for easy incorporation into various workflows. A demo app utilizing the Vonage Voice API and Amazon Transcribe API enables automatic transcription of conference calls, providing a convenient way to revisit and reference them at leisure. The application relies on several moving parts, including cloud storage services like S3 and serverless Lambda functions, to process and analyze the audio recordings. By leveraging these technologies, individuals can streamline their workflow and improve productivity.
May 10, 2021
441 words in the original blog post.
It's been an institution in technology for creating free-to-use tools and seeking contributions since the first directories of open source projects were created. GitHub is a host for code being version-controlled using Git, making it easier for developers to share code and work on projects together by providing a publicly-available home for a repository. For those new to open source or coding, contributing during Hacktoberfest can be an easy way to gain familiarity with concepts like cloning a repo, creating a fork, and making pull requests. GitHub Desktop is a graphical interface that can help beginners get started with these processes, offering features like cloning a repo using the link on GitHub.com, creating a new branch, and making commits. By contributing to open source projects during Hacktoberfest, developers can gain experience with Git and other version control systems, as well as make their first pull requests. The Vonage Community Slack is available for guidance, and the company's Hacktoberfest page provides details on all the planned festivities.
May 10, 2021
1,240 words in the original blog post.
Transcription services are crucial for businesses to understand emerging trends in sales and support phone calls. Four leading cloud providers offer streaming transcription services: Amazon Transcribe, Azure Cognitive Speech Service, Google Cloud Speech-to-Text, and IBM Watson Speech-to-Text. The accuracy of these services varies, with IBM Watson struggling with phrases lacking clear enunciation. Features such as machine learning for accuracy, custom models, audio files, contextual formatting, punctuation support, and language support are similar across the services. However, Google Cloud Speech-to-Text has the highest number of supported languages. Ease of use is also a factor, with Google's simplicity being an advantage over other competitors. The cost of these services varies, but all offer a free tier to get started. Amazon Transcribe is an excellent service, but its implementation can be challenging due to the lack of documentation and authorization process. Ultimately, Google Cloud Speech-to-Text is recommended as a solid pick due to its competitive pricing, robust reliability, and ease of setup.
May 10, 2021
1,244 words in the original blog post.
This summary explains how a Spring Boot application is used to track Santa's location via SMS, utilizing Nexmo for sending and receiving messages, and various services such as GeoNames for postal code lookup and DistanceCalculationService for calculating the distance between the user's location and Santa's current location. The application uses a keyword-based routing system with multiple stages to determine which questions a user is responding to, and it handles various scenarios such as country code lookup, postal code lookup, and distance calculation. The application also provides contextual information to assist users and allows them to provide their postal code to get more detailed information about Santa's location.
May 10, 2021
1,520 words in the original blog post.
A Web Component tutorial is presented, focusing on integrating custom components and widgets into a React application. The tutorial requires a Vonage API account and utilizes the keypad component from a previous post, along with a contacts list component that can save and load names and phone numbers to local storage. Issues with passing data to the web components are discussed, including stringification of arrays and objects, and how React handles events. Solutions for these issues are proposed, including using properties to pass data and creating custom event listeners. The tutorial also covers how to create a basic React "App" component, place Web Components inside it, and handle events and data using different methods, such as class components, function components with hooks, and the useRef hook. Finally, the tutorial demonstrates how to make an in-app voice call using Nexmo CLI and integrates the Web Components into the application.
May 10, 2021
1,988 words in the original blog post.
The author of the text, from Nexmo, discusses their use of text-to-speech in telephony applications and how they can be enhanced with SSML (Speech Synthesis Markup Language) to add expression to the output. They share an example of a Christmas poem that was created using SSML tags to mark up words for emphasis, volume, and pronunciation, allowing them to improve the rhythm and flow of the speech. The author also showcases how they used various SSML tags, such as `<prosody rate="x-slow">`, `<phoneme>`, and `<say-as>`, to achieve specific effects, including slowing down certain words for emphasis and making a word sound like an expletive. By using these techniques, the author demonstrates how SSML can be used to add more personality and expression to text-to-speech outputs.
May 10, 2021
416 words in the original blog post.
PagerDuty is an incident reporting management system that provides notifications and automatic escalations to help engineering teams detect and fix issues as they arise with their infrastructure. The tutorial uses the Vonage Dispatch API to alert members of an engineering team whenever an incident occurs on any of their infrastructure, using Facebook Messenger as the primary medium and SMS as a fallback option. To follow along, you'll need PHP version 7.1 or Higher, Laravel 5.8, Ngrok, a Facebook Account, a PagerDuty Account, and a Vonage API Account. The tutorial covers setting up the Vonage account, creating a custom wrapper around the Vonage API, and integrating it with the Laravel application. It also discusses how to create a job class that dispatches the report incident job when an incident occurs in PagerDuty.
May 10, 2021
1,523 words in the original blog post.
Nexmo, a company, used Facebook Workplace to share photos of their pets and noticed that some people were asking about the breed of dogs in the photos. To solve this problem, Nexmo built a machine learning model using Keras to classify dog breeds from images. The model was trained on a dataset of over 10,000 images of dogs from the Dog Breed Identification Challenge on Kaggle. The model used transfer learning with Xception as the pre-trained base model and added custom layers for classification. After training the model for 10 epochs, it achieved an accuracy of 99% in classifying 12 breeds. A function was created to make predictions on new images, which took a photo from the internet, formatted it to the expected size, made a prediction using the model's `predict()` method, and returned the breed name sorted alphabetically.
May 10, 2021
2,720 words in the original blog post.
The Vonage Number Insights API offers significant cost savings by reducing the time and effort spent on invalid and unreachable numbers, with a sample case study showing a 70% reduction in calls that could be avoided, resulting in a 4,050% ROI. The API can also provide valuable insights into customer data, including carrier information, which can help tailor marketing messages to specific audiences. Additionally, the API allows for data cleaning and aggregation by country or region, enabling more efficient lead generation and targeting of high-quality leads. By leveraging the Vonage Number Insights API, businesses can improve their efficiency, accuracy, and decision-making capabilities, ultimately saving time and money.
May 10, 2021
730 words in the original blog post.
There are thirty-three open source projects dedicated to social change and improving lives, many of which have various open issues and can count towards the four pull requests required for the Hacktoberfest challenge. These projects span across multiple technologies including Python, NVDA, CommCare, Trends.earth, InaSAFE, Code.org, Consul, Stethoscope, Primero, REFUGE, UNEP-GRID MapX, PEcAn Project, SignDict, Kolibri, Terrastories, Global Forest Watch, Community Health Toolkit, Mifos Community App, Sahana Eden, OptiKey, Shadowsocks Windows, EnergyPlus, OBS Studio, Open Machine Learning, LibreHealth EHR, Moodle, Openapi Generator, WHO App, Rainforest Connection Guardian, The Guardian Project - Haven, Jupyter Notebook, Child Growth Monitor, and AutoFocus. Many of these projects have contributor opportunities for those with various skillsets and technologies including Python, JavaScript, C, C++, Ruby, HTML, Elixir, PHP, Java, C#, .NET, and more. These projects aim to make a positive impact in areas such as healthcare, education, environmental conservation, and social justice.
May 10, 2021
1,816 words in the original blog post.
The creator of Whamageddon, a game where players try to avoid hearing Wham!'s "Last Christmas" for as long as possible during the holiday season, has developed a script that uses APIs to play the song on unsuspecting friends' phones. The script, called pvpwham.py, uses the Nexmo Voice API to make outbound calls and play the song, while the Spotify API is used to provide a short sample of the song. To use the script, users need to have Python 3.6 or later, as well as a Vonage API account and a Spotify application with client ID and secret credentials stored in an environment variable file (.env). The script has several dependencies, including pipenv for dependency management, and ngrok is used to expose the script to the public internet. Once installed, users can run the script by typing `python pvpwham.py NUMBER`, where NUMBER is the phone number of the friend they want to target. The script also includes a few extra options, such as specifying a different song or enabling text-to-speech for the warning message.
May 10, 2021
1,610 words in the original blog post.
The Messages API enables developers to connect with customers across various social-messaging channels such as WhatsApp, Facebook Messenger, and Viber. When a customer sends an unsupported message type, the request body of the inbound message contains a "type" field that indicates the unsupported payload. This information can be used by the developer to handle the situation accordingly. For example, if a customer sends a sticker via WhatsApp, the server logs a message indicating that it received an unsupported message from the customer's number. The Messages API provides developers with a way to detect and respond to such messages in their code, allowing them to improve their application's user experience.
May 10, 2021
521 words in the original blog post.
Vonage Campus, a free developer conference, will take place in San Francisco on October 29-30, featuring over 16 in-depth sessions covering tools and APIs for creating engaging customer journeys through conversation. The event includes hands-on workshops on Nexmo messaging, Node-RED, Voice API, OpenTok API, and other technologies, as well as keynotes from Ken Jennings and Duncan Milner. Limited spaces are available to ensure attendees can engage with the team and get hands-on experience.
May 10, 2021
956 words in the original blog post.
Hacktoberfest is an event where individuals can contribute to open-source projects, with non-technical contributions such as translating documentation and removing condescending language being valuable additions. Vonage is participating in Hacktoberfest 2020, offering a limited edition T-shirt and the chance to plant a tree for participants who complete their contributions. Many open-source projects lack non-English documentation, making translations an important contribution. To find contributing opportunities, users can search for "first-timers" or "up-for-grabs" tags on platforms such as GitHub, and participate in initiatives like First Contributions and Up For Grabs to get started with open source development.
May 10, 2021
530 words in the original blog post.
Two-factor authentication (2FA) is a security feature that requires both a password and a one-time passcode generated by a mobile phone to access an account. However, 2FA can be problematic if the user loses or damages their mobile device. To address this issue, researchers have developed a system that allows users to access their 2FA passcodes remotely using a voice call. This system uses the Vonage Voice API to connect with a user's phone and read out the passcode when it is entered. The system can be deployed on various platforms, including local deployment with ngrok and Heroku. To use this system, users need to scan a QR code into their mobile device or other authenticator app, which generates a unique secret key that is used to authenticate the user. The system also requires a Vonage API account and a phone number to be set up. While the system has several benefits, including free HTTPS and easy deployment, it also has some limitations, such as requiring hardcoded secrets and lacking protection against brute-forcing.
May 07, 2021
2,279 words in the original blog post.
The OpenTok Unity sample has been updated to support multiple platforms, including Android, iOS, Windows, and MacOS, without requiring any code modifications. This is made possible by bundling the supported OpenTok platform libraries with Unity, allowing developers to build applications or games that run on different platforms using a single codebase. The sample demonstrates how OpenTok's real-time communication capabilities can be integrated into Unity games and applications, enabling video calls and other RTC comms features.
May 07, 2021
1,098 words in the original blog post.
The development of AI bots faces challenges in tooling and deployment, with many current solutions being browser-based and requiring manual copying and pasting of code. However, as these technologies become more serious, there is a growing need for DevOps-style release platforms that can manage deployments and updates efficiently. Senior bot developers from Microsoft, Opearlo, and The Bot Platform discussed the current state of bot tools and deployments, highlighting the importance of having APIs and approval processes in place to streamline development and deployment processes. While some companies are making progress in this area, there are still edge cases that require manual intervention, such as new preview APIs and services that don't have a code API yet.
May 07, 2021
815 words in the original blog post.
This tutorial explains how to create a voice proxy using the Nexmo Voice API and the Starlette framework, allowing users to make calls without revealing their actual phone numbers. To set up this system, developers need to have Python 3.6+, a Vonage API account, and ngrok to expose their server to the public internet. They must also create a Nexmo Virtual Number, link it to a Voice Application, and install a Starlette server that contains a JSON file with a single action, "connect", which enables them to forward calls to different endpoints without revealing the actual phone numbers. The system uses event webhooks to track the status of proxied calls and can be customized further by modifying the NCCO file or using additional Nexmo APIs.
May 07, 2021
1,238 words in the original blog post.
Building cross-platform bots for voice platforms like Alexa and Google Home is a challenging task due to the differences in platform tooling environments. While there are some similarities with mobile app development, where developers had to build for one platform before expanding to another, the voice bot space has its own set of complexities. The main challenge lies in managing multiple platforms and SDKs, such as API.AI and Google Actions SDK, which can make it difficult to reuse code and manage workflows. However, as additional tools and frameworks emerge, developers will be able to overcome these challenges and build cross-platform bots more easily.
May 07, 2021
1,212 words in the original blog post.
This tutorial builds on the previous "Getting Started with Nexmo SMS and Ruby on Rails" series by explaining how to know when an SMS has been delivered, specifically receiving Delivery Receipts from Nexmo. To do this, developers need to set up a webhook endpoint using tools like ngrok to make their local server accessible to Nexmo, and configure the Nexmo dashboard to forward these receipts to that endpoint. Once set up, Nexmo will notify the application with a DLR containing information about the delivered message, which can then be processed and updated in the database with the new status, allowing developers to track the delivery of their SMS messages.
May 07, 2021
870 words in the original blog post.
Nexmo's Verify API has introduced a new feature called Configurable Workflows, allowing developers to specify a custom workflow for each user when sending a PIN code. This improves the success rates of phone number verification by providing more flexibility and control over the verification process. The available workflows include five different patterns, each with its own set of steps, such as SMS -> TTS -> TTS, or TTS -> TTS, or even just SMS -> SMS. By choosing the right workflow for their use case, developers can increase the verification rates of their customers and make the most of Nexmo's Verify API. With this new feature, users can now tailor the workflow to suit different customer needs and preferences.
May 07, 2021
553 words in the original blog post.
This is the third article in a series of "Getting Started with Nexmo SMS and Ruby on Rails" tutorials, building upon the previous setup to receive a Delivery Receipt for a sent message. To receive an inbound SMS, a similar webhook endpoint needs to be implemented in Ruby on Rails, utilizing a Vonage API account and virtual phone number. The process involves setting up a webhook endpoint using either the Nexmo CLI tool or the Settings page on the Nexmo Dashboard, handling the inbound SMS webhook, and processing the payload to store a new SMS record. An example controller is provided to handle the payload, sending a reply back to the sender as well, before starting the server and testing the setup with an SMS sent to the Nexmo number.
May 07, 2021
651 words in the original blog post.
The Nexmo Conversation API allows users to create customer journeys through conversations, providing a superior customer experience by maintaining the context of those conversations across multiple channels such as voice, messaging, and video. This enables omnichannel communication, robustness, and context retention. The tutorial guides users in building a video chat app using the TokBox API, incorporating the Conversation API into an existing React application to add video functionality. It covers creating a Vonage API account, generating keys and session IDs, organizing components, building the VideoComponent, Publisher, Subscriber, ConnectionStatus, and CheckBox components, testing the app, and collaborating with the Nexmo team for innovative use cases. The Conversation API is currently in beta and encourages users to share their ideas and collaborate on new applications.
May 07, 2021
1,685 words in the original blog post.
The GitLab CI/CD pipeline includes a series of stages such as build, deploy, and notify that are triggered by the push of code to GitLab. The notification stage is particularly useful in case of failures, where it can be configured to send SMS notifications using Nexmo's API. To set up this functionality, environment variables need to be created for the Nexmo account information, such as the API key and secret, and a Node.js application needs to be set up with webhooks that receive messages from Nexmo. The application uses these webhooks to send SMS notifications when the pipeline fails, providing valuable feedback to the development team. Additionally, the Messages API can be used to send messages through other platforms such as Facebook Messenger, Viber, and WhatsApp, offering more flexibility in messaging techniques.
May 07, 2021
1,745 words in the original blog post.
SMS has become a ubiquitous method for sending notifications, often replacing more personal forms of communication like phone calls or emails. However, with the rise of asynchronous programming and the need to make urgent calls, there's a growing interest in using voice APIs to broadcast messages to users. The Nexmo Voice API is one such solution that allows developers to create custom voice broadcasts using various programming languages. By leveraging async/await syntax and libraries like aiohttp and motor, developers can build scalable and efficient voice broadcasting systems. In this tutorial, we'll explore how to use the Nexmo Voice API to make synchronous and asynchronous voice calls, with a focus on implementing backoff mechanisms to handle rate limiting issues.
May 07, 2021
2,892 words in the original blog post.
The OpenTok Linux SDK allows developers to create desktop applications that support video surveillance solutions on embedded Linux systems and other applications where audio and video streaming is needed. The SDK provides a C API for integrating it nearly anywhere, making it suitable for use with reduced consumption of system resources and low memory footprint. Developers can use the same OpenTok concepts as their existing SDK APIs and follow a programming model where the application initiates actions, such as connecting to a session, starting publishing, and subscribing to a stream. The SDK includes callback functions for handling events, such as connection success or error, publisher start or stop, new participant or frame, and more. The OpenTok Linux SDK samples provide examples of how to implement common steps, including connecting to a session, publishing audio and video, subscribing to an audio and video stream, and rendering the video stream. The SDK is currently in closed beta and can be found on GitHub, with developer feedback and resources being actively sought.
May 07, 2021
1,397 words in the original blog post.
The Vonage Voice API allows developers to make worldwide outbound and inbound calls in 23 languages with various voices and accents using a virtual phone number, Ruby Gem, and a few lines of code. The tutorial covers setting up the basics, creating a Vonage Application, installing the Ruby gem, making a voice call with Ruby, and integrating the Vonage API into a Rails application to make outbound calls. The integration includes storing Call records, updating their status, and providing an NCCO to play back text to the recipient during the call.
May 07, 2021
1,285 words in the original blog post.
Aurelia Ventures is an equity-free accelerator program that supports ambitious entrepreneurs in building better companies. The program provides $1.25M in perks and benefits to extend a startup's runway, connects founders with industry experts and mentors, and helps them raise funds through its network of 50+ individual business angels and 80+ VCs. The team at Aurelia has experience building great products across multiple regions and understands the challenges that entrepreneurs face, which enables them to provide personalized support to each startup in their program.
May 06, 2021
1,132 words in the original blog post.
The tutorial provides a step-by-step guide on how to send an SMS using Blazor and the Vonage SMS API, covering topics such as creating a new Blazor project, adding the Vonage NuGet package, injecting an SMS service into a razor page, and configuring the app with the necessary settings. The process involves setting up a Vonage API account, installing the required packages, creating a custom SMS service class, and writing C# code to send an SMS using this service.
May 05, 2021
995 words in the original blog post.
We take our developer documentation very seriously, especially our API Reference. The reference docs are generated from a machine-readable description of each API, in OpenAPI format. This makes maintaining the docs easier for us, but also provides benefits to users such as access to tools that understand these files. Users can import OpenAPI spec files into Postman to create a collection of API requests, generate local reference documentation using tools like Nexmo OAS Renderer and ReDoc, and even mock APIs locally during development with tools like Prism from Stoplight. These approaches make it easier for users to interact with our APIs and improve their integration experience.
May 05, 2021
744 words in the original blog post.
The Vonage API is being used to download recordings of calls made through the Voice API. To complete the task, a Vonage API account and a virtual phone number must be obtained. A webhook is sent by the API at the end of each call, containing information about the recording and a link to download it. The incoming webhook is handled by a Golang application that uses Ngrok to provide a publicly available URL for the local development platform. The application authenticates with the JWT token and downloads the recording file, saving it to disk.
May 05, 2021
830 words in the original blog post.
The application is built using Ruby on Rails and the Vonage Video API to enable video watch parties with real-time chat functionality. The backend is written in Ruby, while the frontend is primarily client-side JavaScript. The code is organized into separate files for different concerns, such as app_helpers.js, chat.js, party.js, and screenshare.js. These classes are then instantiated in the opentok_video.js and opentok_screenshare.js files to create a functional video watch party application. The application also includes styling using CSS to make it visually appealing and accessible.
May 05, 2021
3,623 words in the original blog post.
This tutorial guides users through building a Vonage Voice API-powered contact center solution using ASP.NET Core, allowing customers to leave voicemails when no one answers the phone. The solution involves creating an application in the Vonage Dashboard, linking a virtual phone number to it, and setting up an Answer webhook that uses the Nexmo Call Control Object (NCCO) to record calls. The code is written in C# using ASP.NET Core and utilizes dependency injection for configuration management. Once set up, users can call their assigned Vonage API number, leaving a voicemail that gets recorded and saved to a local file.
May 05, 2021
1,347 words in the original blog post.
This tutorial shows how to build a Code of Conduct Incident Response Line using the Vonage Voice and Messages APIs, along with a simple dashboard to download call recordings and log incoming messages. The line allows attendees to report incidents by calling or texting a provided phone number, which forwards the message to several organizers who can respond accordingly. The system records all calls and sends them to a database for later review. It also stores and displays incoming SMS messages on the dashboard. Once the code is set up, users can call the line, send an SMS, and receive responses from the system, as well as see recorded calls and message logs.
May 05, 2021
1,681 words in the original blog post.
This release of the PHP Server SDK for the Vonage APIs brings several new features and improvements to version 2.2.0, which is a minor release that includes many features from the upcoming version 3.0.0. The new SMS layer has been revamped with strict typing and a fully object-oriented interface, making it easier to use and reducing errors. The Voice API's calls() namespace has been deprecated in favor of a new interface through the voice() namespace, providing a cleaner and more modern way to interact with the Voice API. Additionally, the SDK now includes better debugging tools, such as the ability to query the API handler for requests and responses, and a more complete incoming webhook parser. The Verify product's refactor also brings several new features, including a clearer way to create a Verification request. Overall, this release aims to make it easier for developers to upgrade to the latest version of the SDK while maintaining backwards compatibility.
May 05, 2021
1,820 words in the original blog post.
This tutorial series explores the Vonage Video API, a robust and highly customizable video chat platform. It guides developers through building a basic video chat application that allows participants to engage in real-time video conversations with each other, while also enabling viewers to stream and watch these conversations on a separate page. The application uses Glitch as its server-side setup tool and vanilla JavaScript for client-side development. The tutorial covers the creation of publisher and subscriber tokens, handling routes on the server-side, and implementing authentication mechanisms. By following this series, developers can create their own video chat applications using the Vonage Video API.
May 05, 2021
2,325 words in the original blog post.
When building voice-enabled applications, playing audio into calls programmatically is a fundamental requirement. This tutorial explores how to achieve this using Vonage's Voice API and ASP.NET Core MVC. To play audio into a call, an application needs to return an NCCO (Nexmo Call Control Object) telling Vonage what to play into the call. Two methods will be discussed: one involves returning an NCCO with a stream action, and the other involves using the Text-To-Speech API or websockets to play dynamic audio streams into a call. The tutorial guides through setting up the Nexmo CLI, running ngrok, creating a Vonage application, linking a Vonage number to the application, and configuring the ASP.NET Core MVC project. A basic form is added to the HomeController to make phone calls, and the configuration variables are set in appsettings.json. Finally, the application is tested by running dotnet run and calling the application on a Vonage number.
May 05, 2021
1,519 words in the original blog post.
When building an app to manage SMS messages with the Vonage Messaging API, receiving inbound SMS messages is crucial. This tutorial explores how to receive SMS messages in real-time using Blazor and SignalR Core. To achieve this, developers need a Vonage API account, the latest .NET Core 3.1 SDK, and either Visual Studio 2019, Visual Studio for Mac, or Visual Studio Code. The app uses a controller to receive inbound SMS webhooks from Vonage, which are then sent to all clients connected to an SmsHub using SignalR. The frontend displays incoming messages in a table, and the app is tested with ngrok to create a publicly accessible URL. By combining SignalR, Blazor, and the Vonage APIs, developers can build an app that watches SMS messages come into real-time.
May 05, 2021
1,728 words in the original blog post.
The Vonage Video API tutorial series aims to explore the capabilities of the API and provide hands-on experience with its features. The current tutorial focuses on building a video chat application that allows users to select their role as either a viewer or a participant. Viewers can see all published video streams and interact with others via text chat, while participants can also publish their video to the chat. The application is built using vanilla JavaScript, Glitch for ease of setup, and Node.js. The tutorial covers setting up the project structure, initializing a session, connecting to the session, subscribing and publishing, and handling routes on the server. It also includes client-side JavaScript modifications to redirect users to the correct page based on their selected role and handle token generation for viewers and participants.
May 05, 2021
1,450 words in the original blog post.
To build a serverless video chat application using the Vonage Video API and FaunaDB, start by creating a new directory, installing dependencies, and setting up a Netlify function. Write a basic function to test everything is set up correctly, then create a FaunaDB database and index to store session data. Generate a token for users to authenticate with the video session, and return data to the client including the Session ID, token, and API key. Build a frontend client that submits a request to the endpoint when the button is pressed, and initializes the session in the browser using the OpenTok library. Deploy the function on Netlify and test the application, which should now allow users to create and join video sessions with each other.
May 05, 2021
2,033 words in the original blog post.
In the beginning, all was linear, but as AI technology advanced, a need for visual conversation design arose. The search for a suitable graphs library led to the creation of RxZu, a diagrams engine system built on top of RxJS, designed to simplify and optimize graphic visualization. RxZu is composed of multiple parts, including a core engine handling model synchronization and a rendering engine utilizing the framework. It features nodes, ports, links, labels, and custom entities, allowing for extendibility and customization. The library is currently implemented as an Angular rendering engine, with examples provided for creating a drag-and-drop interface to add more nodes to a graph, showcasing its potential in conversational AI design.
May 05, 2021
1,139 words in the original blog post.
You will deploy a Vonage Verify 2FA client as a microservice to AWS Lambda using Python and Flask, leveraging Serverless technology, with the goal of implementing multi-factor authentication for web services, providing an extra layer of security against unauthorized access. To complete this tutorial, you need a Vonage API account, clone the provided GitHub repository, set up environment variables, install dependencies, run the application locally, deploy it to AWS Lambda, and secure the app before accessing its URL. The client offers four URL endpoints: one for testing, one for requesting a 2FA code, one for checking a code, and one for cancelling a request, with each endpoint providing a specific functionality in the authentication process.
May 05, 2021
699 words in the original blog post.
The Vonage Messages API Sandbox allows developers to test communication channels such as WhatsApp, Viber, and Facebook Messenger for their organization before adding them to production. The sandbox has slight differences compared to the regular Vonage Messages API, and it's recommended to create a server to send messages from any channel in both the sandbox and production environments. To get started, developers need to set up a new project with Node.js, Nexmo Node SDK, Express, body-parser, and dotenv packages. They also need to create a Vonage API account and obtain an application ID, private key, and API keys for each channel. The example code uses Glitch's default Express server setup and creates two nearly identical clients for the sandbox and production environments. One client is used for sending messages in the sandbox, while another client is used for sending messages in production when a specific method is selected. The server handles form submissions from the client-side interface, which sends messages to the selected channel using one of the clients. Once verified, developers can adapt this code to set up testing with the Vonage Messages API Sandbox for their application's logic.
May 05, 2021
1,457 words in the original blog post.
In today's world, uncertainty has made it essential for people to stay connected. To facilitate this, various tools and solutions can be used to enhance communication between individuals, peers, loved ones, or clients. For work, ideas include building a secure video app with Vonage API, transcribing conference calls using Amazon Transcribe and Vonage, translating SMS messages with IBM Watson and Vonage, and more. For home use, solutions like sending group notifications with Google Sheets and Node-RED, building family hotlines and timers, creating Snapchat-style filters with tracking.js and Vonage, and developing health blogs with video coaching are also available. Additionally, Vonage APIs can be used to explore various applications in healthcare, education, and video collaboration, as well as learn best practices for remote work and collaborate with other developers.
May 05, 2021
784 words in the original blog post.
In some countries, throughput limitation on SMS and slow request times add challenges for bulk sending, but using a message queue like AWS SQS can help navigate these limitations. A serverless microservice on AWS Lambda is created to send SMS messages using Vonage API, with the application serving two purposes: adding messages to SQS and facilitating sending through Vonage SMS. The application requires a Vonage API account, Python 3.8, Pip, Node.js, npm, and Serverless setup instructions. To run the app locally, a virtual environment is created, and dependencies are installed using pip and npm. Once deployed to AWS Lambda, authentication must be added to prevent public usage and usage charges. The application provides three URL endpoints: /, /add, and /process, with the latter kicking off the sending process by retrieving messages from SQS and connecting to Nexmo to send SMS messages.
May 05, 2021
674 words in the original blog post.
You can build an application using the Number Management API for Vonage APIs to manage multiple masked phone numbers. The application allows users to buy new numbers, list existing numbers, update number settings, and cancel numbers. The application includes basic authentication and CORS protection to secure API calls. The completed code is available on Glitch and GitHub.
May 05, 2021
2,104 words in the original blog post.
This tutorial explains how to build a Zapier workflow that uses real-time weather data to wake up users at a scheduled time only if certain conditions are met. The workflow uses the Vonage API to make phone calls and send SMS messages. It starts with setting up a trigger using Schedule by Zapier, which runs every day at 6:30am. The next step is to get weather data using Weather by Zapier, followed by filtering the data based on specific conditions such as temperature and precipitation probability. If the conditions are met, the workflow makes a phone call using Vonage Voice API and sends a text message with the weather data via Vonage SMS API. The tutorial provides a step-by-step guide to building this workflow, including setting up the trigger, actions, and integrations with Vonage APIs.
May 05, 2021
1,891 words in the original blog post.
In this demonstration, a Vonage SMS API webhook is received by an ASP.NET Core application and printed to the console. The application uses .NET Core 3.1 SDK and Visual Studio Code for development. A Vonage API account is required to complete the tutorial. Once the application is built, it can be tested using ngrok, which allows a publicly accessible tunnel to be created for the app. The application's endpoint is configured to receive webhooks from Vonage, allowing it to validate SMS message delivery. After sending an SMS message through the nexmo CLI, the received JSON response is printed to the console, demonstrating the successful receipt of the webhook.
May 05, 2021
706 words in the original blog post.
Vonage's Conversation API allows developers to build their own Contact Center solution with voice, text, and integrations to other solutions. The most powerful solutions use AI to route calls, translate text, recommend products, etc. Developers can integrate AI into their application without needing a Ph.D. in AI research. They can also build a machine learning system from scratch using various machine learning libraries. In this post, we'll explore how to predict the likelihood of customer churn using the Vonage Conversation API and the Telecom Churn Dataset from IBM. The project involves building a simple Python server to serve the model, generating user data for prediction, and integrating it into a web app to show churn predictions to a customer service agent. The model achieves 89% accuracy in predicting churn probability.
May 05, 2021
3,025 words in the original blog post.
The app will have three distinct views: Landing Page, Party Video Chat, and Video Watch Party. The entry to the app will be through the landing page, where participants will be asked to provide their name and the password for the party. The landing page will redirect to the Party Video Chat view if the password is correct, and to the Video Watch Party view after a moderator turns on watch mode. The Video Watch Party view will allow the moderator to share their screen with all participants, while the text chat box will remain open for participants to communicate with each other.
May 05, 2021
3,860 words in the original blog post.
This tutorial series explores the Vonage Video API and its capabilities for building robust and customizable video chat applications. The first tutorial in the series focuses on adding screen-sharing functionality to a basic audio-video chat application using vanilla JavaScript, Glitch, and Node.js. The tutorial covers the basics of setting up the Vonage Video API project, initializing an OpenTok session, connecting to the session, subscribing, publishing, and handling screen sharing capabilities. It also provides CSS styles and JavaScript code snippets to fix layout issues and improve the overall user experience for both the publisher and subscriber sides of the video chat application. The tutorial concludes by providing a comprehensive GitHub repository with all the code covered in the post, allowing developers to remix or clone the code and build upon it.
May 05, 2021
1,627 words in the original blog post.
The latest version of our Video Client SDKs, OpenTok v2.17, is now available with several new features and improvements, including support for Microsoft Edge 18 and Safari screen sharing, deprecation of Internet Explorer 11 support, enhanced Android and Windows SDK APIs, and backward compatibility with older API versions.
May 05, 2021
425 words in the original blog post.
This tutorial demonstrates how to integrate Dialogflow with Vonage SMS APIs to build a quiz bot that interacts with users via SMS. To complete this tutorial, you need a Vonage API account and create an application using the Vonage CLI. The Dialogflow agent is set up by importing a pre-exported zip file from the Dialogflow dashboard. The application code sends SMS messages to end-users and receives replies through an incoming webhook endpoint. The responses are then chained as input to the Dialogflow agent, detecting user intent and passing it as input to the agent. The full code for the app can be found in the project repo.
May 05, 2021
900 words in the original blog post.
Automated ordering on WhatsApp is made possible by building a Node.js service using Vonage's WhatsApp sandbox, allowing customers to interact with businesses via messaging. To get started, developers need to create a new directory, install necessary packages, and set up an Express.js server. They also need to add test data, including customer numbers, medications, and prescriptions, as well as configure webhooks for inbound messages. The server listens for incoming messages, checks if the message is related to an order, and responds accordingly. Once tested, the system can be expanded with real data and logic, and eventually applied to a WhatsApp business profile to take ordering live to customers.
May 05, 2021
1,462 words in the original blog post.
The system is capable of performing real-time monitoring of device data independent of internet access, using the Vonage Messages API as a messaging service and Ubidots as an IoT Platform. The architecture integrates these services through an UbiFunction, a Serverless Computing Environment that allows for receiving messages sent to a virtual number over an HTTP request, analyzing it to identify devices and variables, and sending the last value received for each requested variable as a reply. This system can be useful for various use cases, such as monitoring environmental variables like temperature, humidity, light intensity, and pressure in different locations. To deploy this system, you need a Vonage API account, Ubidots account, and any device with internet access to transmit data to the Ubidots API. The system requires the installation of external libraries, including Pycom boards, Pymakr, and the required drivers for Windows OS. The main code is in charge of three processes: checking the network connection, publishing sensor data every 5 seconds, and reading sensors to build a JSON payload to be sent to Ubidots. The system also integrates with Vonage's SMS messaging service to request data via SMS when internet access is not available.
May 05, 2021
4,253 words in the original blog post.
The Vonage Messages API is an excellent tool for sending and receiving messages over various channels such as WhatsApp, Facebook Messenger, Viber, SMS, and MMS. To secure webhooks sent from the Messages API, authentication with JSON Web Tokens (JWT) and payload validation are crucial measures to prevent malicious actors from impersonating legitimate users or falsifying message statuses. Vonage uses HMAC-SHA256 tokens for JWT Bearer Authorization, which can be verified using a shared secret between the developer and Vonage. Payload validation involves checking the payload hash claim in the decoded JWT with the SHA-256 hash of the incoming message body to prevent token replay attacks. Additionally, verifying the "issued at" timestamp helps detect stale tokens. By implementing these security measures, developers can ensure secure webhooks for their applications.
May 05, 2021
1,443 words in the original blog post.
This summary explores how to broadcast a video chat live to many viewers online using the Vonage Video API (formerly TokBox OpenTok) and Node.js. The tutorial covers setting up a server-side code using Glitch, client-side code in vanilla JavaScript, and implementing the startBroadcast() and stopBroadcast() methods for broadcasting with the Vonage Video API. It also includes creating a shareable HLS link to stream the video chat to a player that supports the format. Additionally, it provides a basic implementation of copy to clipboard functionality. The tutorial concludes by providing the final code on Glitch and GitHub, as well as resources for further learning and support.
May 05, 2021
2,987 words in the original blog post.
This Python application provides a microservice that enables applications to request a video chat session using the Vonage Video API, allowing users to obtain a session ID and token to interact with OpenTok. The application uses Flask and Serverless to deploy to AWS Lambda, where it can be accessed via an API Gateway URL. To use the application, users must set up their environment by cloning the repository, renaming `.env.default` to `.env`, and adding their Vonage Video API credentials. Once set up, users can run the app locally or deploy it to AWS Lambda using Serverless. The application provides four URL endpoints for testing and interacting with OpenTok: a GET endpoint that returns a generic message, a POST endpoint that creates a session ID, a token endpoint that returns a token needed to interact with OpenTok, and another token endpoint that takes a session ID as input. Users must secure the app if they intend to leave it active, as anyone with access to the URL provided after deployment can access it without authentication or verification.
May 05, 2021
560 words in the original blog post.
The Nexmo Developer Relations team has been recognized with four awards in two separate competitions, the DevRel Awards and the DevPortal Awards. The DevRel Awards recognized Nexmo's "Best Developer Relations Program Overall", while the DevPortal Awards awarded Nexmo three categories: Best Onboarding, Best API Reference Documentation, and Best Post-Integration & Maintenance Support. These awards acknowledge the team's efforts to make genuinely useful contributions to developer communities and their success in spreading awareness of their APIs. The recognition is a testament to the team's diverse, broad, and passionate approach to developer relations.
May 04, 2021
379 words in the original blog post.
This tutorial series teaches developers how to receive inbound voice calls using ASP.NET Core and the Vonage Voice API. It covers creating an ASP.NET app, setting up a NancyFX application, and handling inbound calls with NCCO responses. The tutorial requires a Vonage API account, Visual Studio 2017, and some configuration steps to link a Vonage phone number to the application. Once set up, developers can test their application by calling the linked Vonage number, which will return a dynamic response with the caller's phone number.
May 04, 2021
893 words in the original blog post.
The Nexmo team is re-writing their Command-Line Interface (CLI) due to limitations of the commander.js framework used in the current version. The new CLI aims to improve developer experience by adding interactive prompts, supporting multiple capabilities on a single application, and reducing dependencies. The team conducted a retrospective to identify areas for improvement, gathered use cases and requirements, and assigned target versions for core features and plugins. They also established standards for command naming, flags, and formatting to ensure consistency in the new tool. The project is being tracked on GitHub, and the team invites users to provide suggestions or issues.
May 04, 2021
1,063 words in the original blog post.
This summary provides an overview of the key concepts related to AI in customer communication tech, including bots, artificial intelligence, machine learning, and virtual assistants. Bots are automated tools that use decision trees to complete tasks, but do not learn or improve on their own. Artificial intelligence is used in these systems through techniques such as statistical models and neural networks, which enable them to make accurate guesses and predictions. Machine learning is a key component of AI, allowing systems to improve over time with more data. Virtual assistants like Alexa and Siri combine multiple services and use natural language understanding to provide a unified interface to customers. The goal of developers in this space is to balance the hype surrounding new technologies with their actual capabilities and to think ahead to how they can be used to build revolutionary customer communication systems.
May 04, 2021
1,205 words in the original blog post.
The Vonage development team has been working on improving their Server SDKs for developers who use their APIs. They revisited the server specifications to ensure a better experience for developers, focusing on cleaning up the user experience and aligning with language-specific expectations. The team aims to deliver modern, idiomatic, and clean libraries that meet developer expectations, evolving with languages as they change. The audit process involved reviewing SDKs for code clarity, exposing usage in a clear manner, and identifying areas for improvement. The team also refactored various SDKs, including the .NET v5.0.0 release, to improve error handling, logging, and documentation. The goal is to provide better developer experience, tools, and support to help developers solve their problems efficiently.
May 04, 2021
1,292 words in the original blog post.
The concept of state machines and statecharts is not new and is a mathematical model used in many things around us. XState helps define state machines, create events and effects, and control application flow using JavaScript methods and objects. The Vonage Video State Chart project uses XState to build an application similar to Google Meet, allowing users to create a meeting room, share the URL, and have a meeting with multiple streams. The project covers basic concepts such as states, state nodes, hierarchical state nodes, parallel state nodes, events and transitions, guarded transitions, context, actions, services, and resources. The goal is to build a Vonage Video app that mimics Google Meet's functionality, using XState to manage the application flow and user interactions.
May 04, 2021
1,868 words in the original blog post.
The newly released Nexmo Java Client Library version 4.0.0 introduces a new major version, dropping official support for Java 7 and targeting Java 8 instead. This change aims to improve the user experience by providing a more intuitive way of instantiating the NexmoClient object, renaming NCCO classes to action classes with names like TalkAction and InputAction, and introducing a builder pattern for number insight requests. The library now uses a six-month release cadence, and some internal classes have been updated to discourage direct use and encourage updates. The change also includes improvements in the handling of authentication schemes and API keys.
May 04, 2021
1,428 words in the original blog post.
You will create a voice transcription pipeline using Amazon Transcribe to process an entire conversation into channels and then insert the results into an RDS MySQL database instance, utilizing two AWS Lambda functions: one for retrieving an MP3 file and submitting it to Amazon Transcribe, and another as a callback function to store the results into a MySQL database. You will need a Vonage API account with an associated virtual phone number to complete this tutorial, which includes setting up AWS credentials, creating an S3 bucket, linking the app to Vonage, obtaining a new virtual number, updating environment variables, deploying to Lambda, and migrating transcription to a database using another Lambda function that triggers upon completion of the transcription. With the deployment completed, you can place calls to your virtual number, retrieve MP3 files from Vonage, start transcription jobs in AWS Transcribe, monitor job status, and trigger a callback Lambda function to parse the transcription and insert it into the MySQL database.
May 04, 2021
802 words in the original blog post.
The application is designed to allow teachers to log in with their Google account and view a list of their most recent assignments from their Google Classroom courses. They can then select an assignment to remind students about, and the application will send an SMS reminder to each student using the Vonage Messages API. The application also includes features such as displaying a teacher's roster and student work for a particular assignment, allowing users to customize a message to send to each student, and storing phone numbers in a database so that teachers don't have to enter them every time.
May 04, 2021
2,822 words in the original blog post.
As a seasoned community developer, Clarisse joins the Developer Relations team in APAC as a Developer Community Manager, bringing her expertise in marketing communications, events planning, and community engagement to drive meaningful connections between developers and Microsoft. With a background in hardware and retail marketing, she successfully built and managed communities in Singapore, including startup weekends, hackathons, and seminars, before transitioning into the tech industry. Clarisse is passionate about empowering developers to create innovative solutions for pressing global issues like sustainability, disaster relief, eldercare, and education, and enjoys balancing her work with yoga, baking, volunteering, and spending time with her loved ones.
May 04, 2021
307 words in the original blog post.
Abdul Ajetunmobi is joining the Developer Relations team at Vonage, bringing experience in consumer products and mobile development with Android and Swift. He previously worked as an iOS engineer and was involved in hackathons and developer events during his university days. Abdul also supported community leaders through GitHub Education and enjoys mentoring and exploring new hobbies outside of work.
May 04, 2021
204 words in the original blog post.
The Vonage Video API has seen a significant increase in usage, with video minutes increasing by 727% in the healthcare industry alone. To provide high-quality service, businesses need to understand what type of quality of service they're providing their customers. The Insights and Advanced Insights APIs were created to help build scalable, reliable solutions for end-users. These GraphQL APIs provide data on session metadata, usage metrics, video quality, errors, and more. The Insights API allows filtering and grouping of data by various parameters, while the Advanced Insights API provides detailed data at the session and stream level, including in-stream statistics that can be used to optimize applications across platforms. However, data retention periods for both APIs are limited, with Insights data available for 60 days and Advanced Insights data available for 21 days. To integrate these APIs effectively, businesses should query them regularly and account for database maintenance periods.
May 04, 2021
908 words in the original blog post.
This tutorial describes how to recreate a messaging service using Nexmo and AWS, similar to old pagers that were popular in the 90s. The service allows users to leave messages for each other, with the message being transcribed into text and sent via SMS or email notification. The system uses Amazon Transcribe to transcribe audio recordings stored in an S3 bucket, and Nexmo to receive incoming calls, answer them, and send notifications. The application is built using Python and the Chalice framework, which makes it easy to deploy to AWS Lambda and API Gateway. Once deployed, users can leave messages for each other, and the system will automatically transcribe and notify them when a new message is received.
May 04, 2021
2,016 words in the original blog post.
With the rise of online shopping, fraud and unauthorized payments are becoming increasingly common, prompting the introduction of a new standard for authenticating online payments in Europe called "Secure Customer Authentication" (PSD2). This initiative aims to add an extra layer of security to transactions by requiring multiple authentication methods, such as something the user knows, is, or has. The Verify API from Vonage can help implement this feature, allowing developers to send a code to the customer's phone and check if it matches their PIN, thereby confirming the payment. By following these steps, developers can integrate PSD2 into their applications and ensure secure transactions.
May 04, 2021
766 words in the original blog post.
You will update an AWS Lambda function to use Amazon Comprehend for tone analysis of a conversation's content, which is then stored in an RDS MySQL database instance. You need a Vonage API account and have access to the nexmo-community repos to complete this tutorial. To deploy the app, you'll update the index.php file with new code that includes sentiment analysis functionality and deploy it to AWS Lambda. The updated code will store the tone analysis results in the conversations table of the RDS database instance. With the changes made, your app is now ready to include tone analysis for future conversations.
May 04, 2021
386 words in the original blog post.
The Vonage Messages API and Dispatch API can be used to send messages to customers through various channels, including SMS, Facebook Messenger, and WhatsApp. The APIs provide a single interface for sending messages across multiple platforms, making it easier for developers to implement modern messaging features in their applications. The Dispatch API adds an additional layer of reliability by detecting when a message fails to deliver and automatically retrying with alternative channels. By using the Messages API and Dispatch API, developers can build resilient and multi-channel messaging systems that provide better customer communication and engagement.
May 04, 2021
2,915 words in the original blog post.
Avital Tzubeli joined Vonage in 2019 after attending DevRelCon SF, where she met Rabbi Ben Greenberg and discovered a shared love for hummus. She was drawn to the company's Developer Relations role and has since become a member of the Community Team, tasked with building a local developer community in Tel Aviv. With a background in computer science and studio art, Avital brings a unique perspective to her work, which includes empowering other tech people to find their creative voice and turning technical subjects into engaging stories. She is excited to continue her journey at Vonage and looks forward to the opportunities that lie ahead, even in the face of challenges such as the COVID-19 pandemic.
May 04, 2021
621 words in the original blog post.
To create a "Dial-a-Carol" service using Nexmo and Vonage APIs, users need to set up a virtual phone number, configure webhooks, and use Python code to handle incoming calls. The code uses Flask to create a web application that interacts with Nexmo's API to play Christmas carols when a user dials in. The application sets up an answer webhook to send the option menu to the user, and a DTMF webhook to receive the user's input, which is then used to select a carol from a predefined list. Once set up, users can dial into Nexmo using their assigned number, make a selection, and listen to a festive carol. The code includes detailed explanations of how the webhooks work, as well as resources for further exploration.
May 04, 2021
1,230 words in the original blog post.
At Nexmo, we've adopted an OpenAPI-led development process to balance up-front specs with discovery, improving developer experience through human versus machine readability, automation, and a single source of truth. By creating OpenAPI specs first, we can make intentional design decisions that lead to consistent, intuitive APIs, uncover potential usability issues, and enable automation for client libraries, tests, and documentation. This process has led to higher quality API implementations, time saved, and deeper understanding, and is expected to improve the quality of APIs across the industry.
May 04, 2021
819 words in the original blog post.
The PyCascades Code of Conduct Hotline has been enhanced to improve its functionality and user experience. The hotline now features an auto-recorded call, automatic logging of activities in Google Spreadsheets, and a more personalized approach for staff members joining the conversation. The enhancements were made possible by integrating Nexmo Voice API and Zapier, which enabled the creation of a custom web service to receive and process calls, as well as automate tasks such as sending notifications and recording conversations. The hotline now also includes features like hold music, greeting messages, and the ability to download recordings after the conversation is completed. These enhancements aim to improve the overall experience for callers and staff members, making it easier to report code of conduct issues and maintain a welcoming environment for attendees.
May 04, 2021
2,801 words in the original blog post.
The project is a fully-working Eurovision voting system built using the Vonage Number Insights API to validate the origin of a number and the Nexmo node client library to send and receive SMS messages. The system uses a MongoDB database to store country data, votes, and results. It includes endpoints for retrieving countries, getting results by country, and persisting scores between refreshes. The project is hosted on Netlify with Vue.js used for the minimal front-end.
May 04, 2021
3,623 words in the original blog post.
We're excited to announce the launch of our new developer champions program, Vonage Voyagers, which aims to build a deeper connection with our community and reward valuable contributors who use our APIs to build communications into their applications and inspire others. The program is designed for enthusiastic developers who want to get hands on new communication technologies first and be part of a group of like-minded peers who support and learn from each other. As an official member, participants will have access to pre-release products, mentorship opportunities, training, cool limited edition swag, an exclusive summit invitation, and the chance to provide feedback on our documentation and contribute to our Open Source projects. To participate, developers must be fluent in English, over 18 years old, have a Vonage API account, show how they've used our APIs in their content or projects, demonstrate expertise within a specific developer community, and display empathy when helping others grasp technological concepts.
May 04, 2021
497 words in the original blog post.
Vonage has released Automatic Speech Recognition (ASR) as a new feature on the Voice API, providing a great opportunity to build an entertaining voice application that leverages this capability. A Deno-based voice application will be built to receive a phone call, accept speech input from the caller, convert it into text using Vonage ASR, translate it into a random language using Microsoft Azure, and then speak back both the original English text and the newly translated text. The application uses Opine as its web framework for the server. It defines routes for incoming calls, converted speech to text, and call lifecycle event data. The application also includes helper functions such as token creation, translation, language picker, and voice picker. Environment variables need to be defined for Azure API key, endpoint, and Vonage ASR webhook. A Vonage virtual phone number needs to be provisioned using the CLI or dashboard. Once set up, the application can be run with ngrok to make it externally accessible. The application allows users to give their Vonage-provisioned phone number a call, say a message, and hear it converted into text and translated into a random language.
May 04, 2021
4,629 words in the original blog post.
The school can call the developer's number and are presented with a menu of options to connect to either parent or join a conference call in case of an emergency. The system uses Vonage's API to make outgoing calls and generate NCCO actions for incoming calls, allowing for dynamic configuration of parents' details and error checking to ensure correct functionality. A unique conference ID is generated for each call, enabling the caller to select which parent to connect to or join a conference call.
May 04, 2021
2,875 words in the original blog post.
This is my first major release since joining the Platform & Developer Experience team at Vonage last year, and I'm excited to share what's new with the .NET 5.0.0 SDK, which includes a rebuilt SDK around .NET conventions, a new logging methodology built on Microsoft.Extensions.Logging, an added summary documentation file, and improved error handling. The SDK has also undergone significant enhancements under the hood, including refactored internal request methods and the addition of a new suite of unit tests to ensure seamless testing. While there are some breaking changes, the team has made efforts to minimize disruption and encourage users to upgrade to the latest version for easier maintenance.
May 04, 2021
640 words in the original blog post.
The Nexmo Ruby SDK has released version 7.2.0, which includes rewritten JSON Web Token generation using the new nexmo-jwt gem to provide users with more flexibility in designing tokens for their specific needs. This feature was previously only available within the SDK and is now accessible to every user. The use of JWTs serves as a secure mechanism for sharing information between machines, with Vonage APIs utilizing them for authentication and communication. A new library, nexmo-jwt, has been created to simplify JWT generation, allowing users to generate tokens both inside and outside of the Ruby SDK. The new release simplifies the process of generating JWTs by eliminating the need for separate parameters and providing default values for expiration and other settings. Users can customize their JWTs with additional parameters such as custom paths, subject, and time-to-live information.
May 04, 2021
860 words in the original blog post.
Google's MLKit allows developers to easily integrate machine learning into their apps, with features like image labelling, face detection, and barcode scanning. The platform provides a simple API for common ML use cases, allowing developers to create custom models and run them on-device or in the cloud. A tutorial demonstrates how to build an app that uses MLKit's image classification feature to detect specific entities in an image, including strawberries. The tutorial covers both local (on-device) and cloud-based models, with the latter providing more accurate results but requiring a paid Firebase plan. The code for this tutorial is available on GitHub, along with information on how to get started with MLKit and other resources for learning about machine learning.
May 04, 2021
1,963 words in the original blog post.
Providing a healthy environment is crucial for attendees' happiness and well-being during hackathons, which are increasingly focused on addressing issues like burnout, mindfulness, and overall wellbeing. Incorporating wellness into the event can lead to a successful outcome where attendees feel comfortable and have enough recovery time before returning to their daily routine. This can be achieved by providing healthy food options, creating quiet spaces, considering the duration of the event, offering wellbeing sessions such as massages or yoga, choosing a venue with shower facilities, managing temperature, scheduling fun activities, and leveraging sponsorships to support wellness initiatives.
May 04, 2021
931 words in the original blog post.
To address computationally expensive tasks in web applications, Laravel framework uses a job queue system with built-in support for queued jobs and workers to process them later, utilizing Redis as a datastore. However, traffic spikes can cause jobs to accumulate in the queue if not enough workers are assigned. To mitigate this, a threshold is set to send an SMS notification when the queue wait time exceeds a specified limit using Nexmo's event-based services, allowing developers to quickly increase worker capacity and resolve issues.
May 04, 2021
658 words in the original blog post.
The Nexmo SMS API uses HTTPS protocol to send messages, which involves a TCP handshake, TLS encryption, and a POST request to the server. The cURL command-line tool is used to send the request, which includes parameters such as API key, sender ID, recipient number, and message content. The output of the request shows the DNS lookup, TCP connection establishment, TLS handshake, and server response headers and body. The response body contains information about the sent message, including the message count, status, balance, cost, and recipient network ID.
May 04, 2021
1,282 words in the original blog post.
This tutorial demonstrates how to set up a webhook that sends an SMS message using the Nexmo Messages API and the Node.js framework Hapi, when a Typeform is submitted. To complete this tutorial, you need to create accounts with Vonage, install the necessary dependencies, and configure the application with the Nexmo Messages API. The code uses the hapi server to receive incoming webhooks from Typeform and sends an SMS message using the Nexmo Node JS Client Library. The process involves setting up a new Messages & Dispatch application via the Nexmo Dashboard, creating a skeleton application with a POST route, initializing the Nexmo instance with your API key and secret, and updating the route handler to send an SMS message. Once you've completed these steps, you can connect the webhook to Typeform and test it by clicking the "Test Webhook" button, which will receive an SMS message with the details.
May 04, 2021
1,152 words in the original blog post.
Nexmo has announced that it will disable legacy TLSv1 and TLSv1.1 protocols on August 7, 2018, to facilitate a transition to more secure encryption protocol TLSv1.2, which is now the only supported encryption protocol for HTTPS connections. The deprecation process started with a temporary shutdown of these protocols in July, followed by a two-week extension until August 21st, after which they will be permanently disabled. To ensure compatibility with Nexmo's new standard, users are advised to verify their system supports TLSv1.2 and update their software or underlying platforms accordingly, as most modern operating systems and runtime environments already support this protocol. Users can check for TLSv1.2 support using online tools or by making a GET/POST request to the verification endpoint provided by Nexmo.
May 04, 2021
635 words in the original blog post.
This article guides on building a basic image classification model using Python and TensorFlow for processing images sent by members of an iOS app integrated with Nexmo In-App Messaging. The model is trained on the CIFAR-10 dataset, which contains 10 classes with 6000 images per class. After training the model, it is converted into Core ML format to facilitate its use in the iOS app. The article provides a step-by-step guide on building and deploying the model, including importing it into an Xcode project and integrating it into a Stitch Demo Application. The final accuracy of the model is 81%, with a loss of 0.7, indicating that it can classify images accurately but may have some errors in certain cases.
May 03, 2021
2,112 words in the original blog post.
Nexmo's Secret Rotation feature allows enterprise developers to update their API credentials regularly without disrupting their applications or services by providing a way to create, test, and deploy new API secrets in a controlled manner, enabling them to maintain a high degree of security while minimizing the risk of unauthorized access to their APIs. This feature is made possible through the Secret Management API, which enables programmatic management of API secrets, control over secret renewal frequency, and control over secondary API secrets. With Secret Rotation, enterprise developers can rotate their primary and secondary account secrets at will, ensuring that only authorized users have access to their accounts, thereby minimizing the risk of fraudulent activity.
May 03, 2021
445 words in the original blog post.
This tutorial provides three different ways to create a WebSocket server in Java using Spring Boot, Spark Framework, and the Java API for WebSockets. To start, you need a Vonage API account and set up your project with Gradle and the Spark framework. You then create a WebSocket handler that can handle both text and binary messages, which is used to echo back messages received from clients. The handler is registered in the `App` class, and a client is created using JavaScript to test the server. The client sends both text and binary messages, which are echoed back by the server. The tutorial concludes with a summary of the finished code and an invitation to learn about creating WebSocket servers with Spring Boot or the Java API for WebSockets.
May 03, 2021
1,007 words in the original blog post.
The Nexmo Audit Events API is a tool that allows users to retrieve and monitor audit events from their Nexmo account. The API provides various features, including retrieving a list of all supported event types, obtaining filtered lists of events, and retrieving details of specific audit events. The API endpoints include `https://api.nexmo.com/beta/audit/events` for obtaining a list of all audit events and `https://api.nexmo.com/beta/audit/events?event_type=...` for filtering events by type. A Python web application has been created to demonstrate how to use the Nexmo Audit Events API, using libraries such as Flask and Requests. The application allows users to select a specific event type or view all events, and displays the results in a table format.
May 03, 2021
788 words in the original blog post.
You will need a Vonage account to complete this tutorial, which includes a phone number and API key and secret. You'll use Gradle to manage your dependencies and create a new Java project, then set up routes for handling incoming calls and user input using the Spark framework. The application responds with an NCCO instructing Vonage to speak back to the caller or capture user input, which is then sent to Vonage for processing. You'll also use ngrok to expose your local application to the internet and configure your Vonage account to link your phone number to the application. Once set up, you can test your application by making a call to your Vonage number and interacting with it using your keypad.
May 03, 2021
1,226 words in the original blog post.
The goal of this demo is to add two-factor authentication (2FA) to a Microsoft Bot application using the Nexmo Verify API on sign-up, allowing developers to integrate 2FA with their bots and enhance security. The demo involves creating a user profile form, sending a verification code via Nexmo's Verify API, and verifying the code entered by the user, ensuring that only authorized users can access the bot.
May 03, 2021
1,298 words in the original blog post.
This tutorial guides users in creating a web-based caller ID application using Java, Spark framework, and the Nexmo Number Insight API. The application allows users to input a phone number, perform a lookup with the Nexmo API, and display the results on the page. It also includes a user interface built with JavaScript and CSS. The tutorial covers setting up a new Java project, configuring Spark, defining routes, and serving static content. Additionally, it provides an example of how to use the Nexmo Number Insight API to gain insights into phone numbers.
May 03, 2021
1,905 words in the original blog post.
This summary highlights the benefits of using SMS for user interaction, the use of serverless platforms like IBM Cloud Functions to deploy a scalable and cost-effective solution, and the process of setting up an SMS-based fortune cookie system. The text covers the deployment of a serverless function, handling incoming SMS, discovering the sender's phone number, setting up secrets, and sending a response back to the user. It also provides resources for further learning on SMS and messaging topics.
May 03, 2021
2,452 words in the original blog post.
Nexmo, a communication platform provider, has launched a Developer Spotlight guest blogging program to provide high-quality tutorials and interesting development stories for its community of developers. The program aims to create a destination for developers seeking valuable content on Nexmo's products and services. The company is open to submissions from technical writers, bloggers, influencers, and innovators, with a focus on original, well-written, technical, helpful, and interesting posts. Successful submissions will be published on the Nexmo blog, potentially shared in newsletters or featured as part of "Tutorial Tuesday" weekly highlights, with contributors earning $400 per post. The program seeks passionate, authoritative, and knowledgeable developers to share their stories and experiences with the Nexmo community.
May 03, 2021
730 words in the original blog post.
To integrate Nexmo Stitch's In-App Messaging into an iOS app using a UITableView, developers need to update their app layout, add a prototype cell, and configure the delegate and data source. They must then implement the required methods for UITableViewDataSource, such as numberOfRowsInSection and cellForRowAt, to display chat history. The implementation involves accessing properties from the ConversationClient instance, downcasting events, and assigning them to the prototype cell's textLabel.text property. By following these steps, developers can showcase a chat's history in their app using Nexmo Stitch In-App Messaging.
May 03, 2021
1,223 words in the original blog post.
As a Community Manager at Nexmo's Developer Relations team, Myrsini will be supporting and engaging with developers worldwide, drawing from her diverse background in events, content creation, and DevRel experience. She previously worked at PayPal, Braintree, MLH, and as a freelancer, where she was involved in initiatives like the global hackathon series BattleHack. Recently, she's been exploring content creation, but is excited to rejoin the Developer Relations field and connect with new communities.
May 03, 2021
328 words in the original blog post.
Nexmo has developed a connector for Mulesoft's Anypoint Platform, enabling users to integrate real-time messaging with enterprise apps and data, including WhatsApp's 1.5 billion active monthly users. The connector allows users to create messaging flows where messages will fallback to other channels like SMS if the initial message doesn't get a response. This solution is part of Nexmo's WhatsApp Business initiative, which has seen strong demand from businesses looking to integrate WhatsApp with their operations. The connector enables businesses to leverage WhatsApp for customer engagement and support use cases while maintaining end-to-end encryption for privacy. With this integration, users can build various workflows such as opt-in to WhatsApp messaging via SMS, CRM flows, connections to support chat platforms, and financial service transactional notifications. A demo of the WhatsApp Business solution will be shown at Dreamforce 2018 in San Francisco, showcasing how straightforward it is to set up notifications via WhatsApp for customer service.
May 03, 2021
622 words in the original blog post.
I'm excited to join Nexmo's Developer Relations team as a junior community manager/developer advocate/designer/intern, bringing my passion for education, design, and coding to help provide great developer experiences. With a background in industrial product design and computer science, I've developed skills in learning new things, experimenting with programming languages and frameworks, and building stuff. I'm looking forward to coding, learning, and helping developers build fantastic things while also enjoying the perks of Developer Relations, including swag! I'll be reachable on Twitter at an event soon.
May 03, 2021
297 words in the original blog post.