November 2020 Summaries

A Jamstack site's ability to gather analytics is vulnerable due to the lack of a backend, which can be mitigated by using a Netlify Function that sends events off to Google Analytics. The function returns an SVG image with query string parameters, allowing for server-side analytics without relying on traditional trackers or tracking pixels. This approach bypasses blockers and provides a way to track user behavior while maintaining privacy and speed concerns. By using a redirect rule in the `netlify.toml` file, the site can be proxied to use the Netlify Function, enabling server-side analytics with minimal technical effort.

To make an outgoing text-to-speech phone call using Go and the Vonage Voice API, you need a Vonage API account and a virtual phone number. You create a new application under "Your Applications" in the Dashboard, toggle on Voice capabilities, and note your Application ID. Then, you set up a new file called `make-an-outbound-call-ncco.go` with the necessary code to make the call. The code uses the Vonage SDK for Go to authenticate and create a call request with the specified phone numbers and NCCO object. After running the command in the terminal window, you should see the call UUID output and receive an incoming call with the text-to-speech message.

Vonage Verify API` is used to implement a verification token system, which includes creating a verification request and checking if the provided code is valid. The `Vapor` framework is utilized for building the server-side application, with `SwiftUI` being used for the client-side application. A Vonage account is required to complete this tutorial as it provides the necessary API credentials. The project covers the creation of a server-side endpoint to receive verification requests and check if the provided code is valid using the Vonage Verify API. Additionally, it includes a client-side application built with SwiftUI that can test the server's functionality.

We migrated a WordPress site to Jamstack using Netlify CMS, simplifying our workflow and consolidating processes. The decision was driven by concerns with speed, security, and reliability, as well as the complexity of managing an unmaintained platform. We used Jekyll initially but ultimately chose Nuxt.js due to its performance, server-side rendering, and compatibility with our design system, Volta. The migration process involved reviewing content manually, using rewrite rules for redirects, and prioritizing most-read content for swift migration. The new platform has delivered transformative results, enabling faster content delivery, improved reliability, and enhanced analytics capabilities.

The Vonage Voyagers program is a one-year initiative that brings together developers who want to explore new communication technologies and collaborate with like-minded peers. The program aims to recognize valuable contributors to the community by nominating or applying individuals directly. Two recent additions, Gabriel Cruz from Brazil and Matthew Stein from California, share their projects, interests, and what they're looking forward to as Voyagers. Both are excited about working with communication APIs to create innovative applications, such as automated bots and puzzle-solving tools, while also learning from the community and expanding their skills.

We’re happy to announce that Speech Recognition (ASR) is now generally available! Here is the summary of improvements we have made during the Beta stage based on valuable feedback: Call ID Is Now Optional, allowing for more flexibility in IVR or voice bot scenarios where a single leg in the call is typical. The uuid parameter is optional and can be used to specify a different leg if needed. Input Type is now configurable with a new type parameter that allows setting DTMF, speech, or both inputs explicitly. All Server SDKs now support ASR, making it easy to convert existing DTMF IVRs to natural speech voice assistants or create new ones from scratch.

The Vonage Messages API Sandbox allows users to test and develop automated services for Facebook Messenger without leaving their web presence on Facebook. To set up a quick service, developers need to create a server using Node.js, Express.js, body-parser, and axios, and configure the middleware to listen on port 3000. The server needs to be publicly available, which can be done with ngrok or Glitch. Developers also need to obtain API credentials and the sandbox Messenger ID from the cURL command on the sandbox page. Once the server is set up, developers can send messages using axios and receive incoming messages by listening for a received message first. The endpoint responds with a confirmation of what was sent. With this setup, developers can now build a reply to their user and try it out with a whitelisted Messenger client.

This tutorial is a comprehensive guide to building an SMS spam detection web application using Python, Flask, and the Vonage SMS API. The application uses a machine learning model trained on a dataset of labeled SMS messages to classify new incoming messages as spam or ham. The tutorial covers the setup of the project, data preprocessing, feature engineering, model training, and deployment in a Flask web application. It also includes explanations of various machine learning algorithms and techniques used throughout the process.

The Vonage Video API is being used to integrate augmented reality (AR) features into video calls, allowing for more interactive and immersive experiences. The API can be combined with the DeepAR SDK to add AR filters to video calls, such as replacing backgrounds or adding animated effects. This integration enables developers to create new use cases for video communication, such as shopping and remote assistance, and provides a way to enhance user engagement and experience. The Vonage Video API team is committed to investing in AR product features and partnerships to ensure customers have access to the best technology and expertise available.

This tutorial shows users how to receive SMS delivery receipts of SMS messages sent from their Vonage account by setting up a publicly accessible webhook and handling the corresponding POST request. Users need a Vonage API account and a virtual phone number to complete this tutorial, which also uses ngrok to expose the project to the internet. The code provided in the tutorial handles the incoming request and outputs the status part of the body of the request. Once set up, users can test their webhook endpoint by sending a test SMS message from another terminal window. With the webhook successfully configured, Vonage will send delivery receipt requests to this endpoint, which will be received and processed according to the code's logic.

This tutorial guides users through integrating the Vonage SMS API with Zapier, allowing them to automate text messages from Greenhouse recruiting platform, enhancing candidate experience and communication. To set up this integration, users need a Vonage API account, as well as accounts for Greenhouse and Trello. The goal is to create two Zaps that trigger when a new candidate applies for a role in Greenhouse, creating a Trello card and sending an SMS message to the candidate. Users will customize their Trello card with information from Greenhouse and connect it with the Vonage SMS API to send automated "Thank you for Applying" messages. Additionally, users can set up another Zap that allows them to text the candidate at will, adding notes to the profile in Greenhouse when a comment is added to the Trello card.

The Vonage Video API platform is used to embed real-time, high-quality interactive video, messaging, screen-sharing, and more into web and mobile apps. A lightweight JavaScript library called Tracking.js is used for face detection and color tracking in the browser environment. The application uses a base from OpenTok web samples for stream filters that can be edited. To start coding, you need to configure the application as it is and get a feel for the starting point by creating a project with Vonage Video API, generating a token, and setting up dependencies. The application then creates a new filter called "Brighten" and another one called "Threshold". Facial tracking with Tracking.js is added to render an image over the face like a mask. Two masks are created: Guy Fawkes and Batman, which can be applied to the stream using a select box in the application. The application also includes a live video stream that allows users to see their own faces with the different filters.

The Vonage Voyagers program is a one-year initiative that rewards and recognizes valuable contributors in the community by providing them with new communication technologies first and allowing them to learn from each other. The program highlights individual developers who are part of this community, showcasing their projects, interests, and experiences as Voyagers. A group of three recent Voyager participants - Mary Jo Staebler, Matthew Groves, and Hector Zelaya - share their backgrounds, recent projects, expectations for the program, and what excites them about working with communication APIs, including voice and text APIs by Vonage. These individuals come from diverse locations across the United States and Central America, highlighting the global nature of the community. By applying or nominating a colleague to become a Voyager, others can join this community of like-minded peers and learn from their experiences.

A multi-factor authentication system, commonly referred to as MFA, is used to add extra security to applications and verify a user's identity. To implement an MFA system using the Go programming language and the Vonage Verify API, developers need to create a client using the vonage-go package, which requires an authentication set created by invoking the CreateAuthFromKeySecret function. The client is then used to start a verification request, which sends a code to the user's phone number. The user must input the code on a confirmation page, and the application will confirm if it is valid using another function called VerCheck. This process ensures that applications are secure and safe for users, protecting them from hackers who could expose their data.

ngrok is a tool used to expose local developer environments to the public internet for demoing, writing blog posts, and creating guides, allowing developers to receive inbound webhooks without setting up a local server or forwarding ports. It provides a simple way to serve an NCCO JSON file and has various features such as HTTPS support, region selection, HTTP Basic Auth, custom domains, IP whitelisting, and paid features like reserved domains and IP whitelisting. However, users should be aware of the security implications of using ngrok on their work networks or without proper configuration.

The text discusses ways to keep Video API sessions safe from bad actors, including implementing processes such as identifying who joins a session, removing users and redirecting them away, and utilizing the signaling feature of the Video API to mute attendees. It also covers how to use the Video API's built-in capabilities for user moderation, including sending signals to guests to mute their audio or video streams, and forcing guests to be disconnected from the session if necessary. The text provides examples of code snippets in JavaScript to demonstrate these concepts.

You've built an app that triggers outbound phone calls using the Nexmo PHP client, utilizing voice calls as an excellent communication method for immediate messages. The code uses a virtual phone number, ngrok to expose the app to the public, and Vonage API account credentials. You've created a simple NCCO with a talk action, generating a text-to-speech message. The app also handles incoming calls by returning a JSON response in the correct format. Additionally, you've made an outbound call using the Nexmo client and added dynamic NCCOs to fetch jokes from the Chuck Norris Database for customized responses.

To receive an SMS delivery receipt with PHP, you need to install the Slim framework Let's install it now with composer `Vonage will make either a GET or a POST request to your application with the data, depending on how you configured your account`. You'll create a new Slim application and register a handler that responds to both HTTP methods. To handle the incoming request, you'll log the request values to the terminal using error_log. Once your local PHP server is running, you can expose it to the internet by using ngrok to generate a URL. Finally, you'll configure the webhook URL for delivery receipts in the Vonage dashboard and send an SMS to test the functionality.

This article explains how to use Vonage's SMS API with Azure Functions and Node.js to send and receive SMS messages. The author starts by setting up a Vonage account, installing the required libraries, and creating an Azure Function App. They then create a Webhook function that receives incoming SMS messages from Vonage and logs them to the console. To test this functionality, the author sets up a Vonage phone number, deploys the Azure Function App, and sends an SMS message using the Vonage Node.js SDK. The response is converted into emojis, demonstrating how to send a response back to the original sender.

The Vonage Conversation API enables the creation of conversation features that can take place across multiple mediums such as IP messaging, PSTN voice, SMS, and webRTC audio and video. The API maintains context through each communication event within a conversation, regardless of the medium used. This allows for the recording and working with the history of a conversation to be incredibly valuable for businesses and customers alike. A tutorial is provided on how to build a dashboard with Flask and React that monitors all current conversations within an application in real-time, showcasing relevant data from live conversations. The tutorial assumes a Vonage API account and follows a workflow of creating an application, cloning the repository, installing dependencies, setting up the Flask backend and React frontend, and connecting it all together to display conversation data in real-time.

Event sourcing has been growing in popularity as a way to build systems that protect against data loss, model complex business scenarios more clearly, and provide flexibility in how they can be extended. The Vonage API makes it super easy to track phone calls, which is used to build an event-sourced system for auditing these conversations. The system stores the entire history of everything that happens in the application as a log of events, called a stream. Events are associated with a primary stream that represents the entity or process they belong to, such as a customer or order. The system uses Marten, a .NET library, to easily use Postgres as a document DB and event store. It also handles updating the read-side view-models whenever any new events are appended to the event streams. The system creates C# objects to represent the domain events in the application, which are then used to create an individual stream per phone conversation. The system uses a command handler to trigger when receiving a message from the Vonage call-tracking API, and displays the current state of the system by "re-playing" and transforming all those events into view-models. The system also includes a UI to display phone conversations, which is used to view the data from the system. Finally, the system configures its Vonage time tracking application using ngrok and Nexmo, allowing it to receive real-time call tracking events from the Vonage API.

Machine Learning models enable us to do all sorts of neat things. We will learn how to translate a call received on a Vonage Number, translating the caller's speech and sending all of the translated text to our frontend using a .NET Core hosted Blazor WebAssembly App and SignalR.` This tutorial covers setting up a Vonage API account, creating an application, purchasing a number, and linking the application to the purchased number. It also covers building a Blazor WebAssembly app that uses SignalR to receive translations from the Vonage API. The app will use Azure Cognitive Services for speech recognition and synthesis. The tutorial includes code examples in C# and Razor components for the frontend.

Vonage provides APIs that need to be integrated with servers to handle calls, but Microsoft Azure Functions can simplify this process by allowing developers to write small, standalone functions in Python and deploy them easily to the cloud. This tutorial shows how to build a simple Vonage app with two webhooks hosted on Azure Functions, using the Vonage CLI tool and Ngrok to tunnel requests from the development machine to the Azure Function. The app allows users to enter their mood, which is then processed by the Azure Function and sent back to the user as an NCCO response. After completing this tutorial, developers can deploy their code to Azure Functions and integrate it with other APIs to build more complex applications.

This tutorial demonstrates the deployment of a simple function on Google Cloud Platform using Python 3.7 to send a text message to a user via the Vonage SMS API, showcasing the benefits of "Functions-as-a-Service" or serverless architecture in breaking down applications into small, scalable pieces without managing servers or paying for unused services. To get started with Google Cloud Platform, one must sign up and create a Vonage API account, then set up pre-requisites such as environment variables and CORS handling. The function is deployed to Google Cloud Functions using the inline editor, where it can be tested and integrated into a front-end via JavaScript, highlighting the potential of serverless architecture for integrating with static sites, JavaScript front-ends, or mobile apps.

Developing cross-platform mobile applications with Ionic and connecting to the Vonage SMS API allows for sending SMS messages, enabling businesses to communicate efficiently. To start building this application, one needs an IDE like Visual Studio Code or Sublime Text, Node.js, a Vonage API account, and the necessary packages such as `@ionic/angular` and `@hapi/hapi`. The process involves creating an Ionic application using Angular, installing the required packages, configuring the HttpClient, and building a basic UI. Additionally, a back-end server is created using Hapi to handle incoming requests from the client-side application. To overcome CORS issues during development, one can modify their hosts file to re-route HTTP requests to localhost. Once both the front-end and back-end are set up, they can be run concurrently in separate consoles, allowing users to send SMS messages using test numbers provided by the Vonage dashboard.

You can use environment variables to safely handle sensitive information like private keys with JWTs (JSON Web Tokens). This approach allows for secure transfer and handling of credentials across different platforms, including local development environments and cloud deployments. By using environment variables, you can avoid hardcoding sensitive data into your codebase, reducing the risk of security breaches. The Vonage Node SDK example demonstrates how to securely handle private keys as strings by encoding them in base64 and storing them in environment variables. This approach enables flexible deployment across various platforms while maintaining security and integrity.

The Vonage SMS API allows developers to send and receive messages around the world using a virtual number rented from Vonage. This tutorial uses Node.js, Express, Ably, and Angular to demonstrate how to receive an SMS, send it via Ably to a web browser, and display it as a notification in a Single Page Application. The process involves creating a Webhook endpoint with Express, registering it with Vonage, sending the message via Ably, and displaying the notification in an Angular application.

The text discusses various tools for building Web Components, including Vanilla JavaScript, hybrids, Lightning Web Components (LWC), LitElement, and Stencil. Each tool is compared based on features such as documentation, ease of setup, support, backing, and more. The comparison highlights the differences in approach, syntax, and complexity between these tools, with some focusing on declarative programming, others on functional programming, and all aiming to simplify the process of creating Web Components. The text also mentions the importance of considering factors like boilerplate code, performance, and compatibility when choosing a tool for building Web Components.

This tutorial series aims to help developers get started with using Vonage's SMS API in conjunction with Node-RED, a popular low-code development platform. The Vonage SMS API allows users to send and receive SMS messages worldwide through a simple HTTP-based API. With the addition of Nexmo nodes to the Node-RED palette, interacting with this API has become easier. To start, developers need a Vonage API account, a virtual phone number, and install the necessary runtime and editor for Node-RED. They can then set up a flow using the Nexmo nodes to send SMS messages, including customizing parameters such as the recipient's number, message text, and timestamp. The tutorial also covers setting up a webhook endpoint to receive delivery receipts from Vonage and exposes the local server to the internet using ngrok. By following this series, developers can gain hands-on experience with sending SMS messages using Node-RED and Vonage's SMS API.

The Conversation API is a low-level API that allows developers to create various objects such as Users, Members, and Conversations. It revolves around conversations which are containers of communications exchanged between two or more users. The API enables developers to integrate various communication channels with their applications using custom events. In this blog post, the authors demonstrate how to use the Conversation API to establish an external communication channel with a WeChat application, enabling two-way messaging between a WeChat client and a Vonage client. To set up the integration, developers need to register for a WeChat account, add the official account to their WeChat, and obtain an API key and secret. They also need to set up a middleware server to interact with WeChat's public API using custom events. The authors provide example code in JavaScript to dispatch a WeChat event and demonstrate how to send and receive messages between the WeChat client and Vonage client.

This tutorial teaches developers how to implement two-factor authentication (2FA) in a web app using Node.js and the Vonage Verify API, making it more secure for users. To start, a web app is set up with an Express.js framework, and a simple form is created for users to input their phone number. The backend code receives the value from the form via POST and uses the Nexmo module to send a 4-digit PIN code to the user's phone number. Once the PIN code is received, the user enters it into another form field on a new page, which checks the PIN code with the Nexmo Verify API to verify its correctness. If successful, the app renders an "Account Verified" message. The tutorial emphasizes the importance of handling all error statuses in the app UI for better user experiences.

The article describes the creation of a keypad component using Material Design Web Components. The component will render a display and buttons with digits 0-9, *, and #. It will also have an 'Action' button that sends all the digits pressed as a custom event to the application outside of the component. Another button is available to 'End' the action, which clears the display and sends another custom event. The Web Component has a public method that switches it to the 'active' state, displaying the 'End' button. It uses lit-html and Open Web Components (Open-WC) for building and rendering. The component accepts various attributes and properties, such as noAsterisk, noHash, noDisplay, actionText, cancelText, actionStarted, and digits. After publishing the Web Component on npm, it can be used in a project by installing it locally or using a Content Delivery Network (CDN) like unpkg.com. The component is now available for use in web applications with minimal hassle.

This tutorial guides users in setting up a chatbot using Dialogflow, Firebase, and Vonage Messages API to interact with customers and handle incoming requests such as reservations, bank inquiries, FAQs, and initial support. The user needs to have a Vonage API account, create a Firebase application, set up the Dialogflow agent, download service account keys, build functions locally, and deploy them to Firebase. The chatbot can then be tested on Facebook Messenger using the Vonage Messages Sandbox Inbound webhook. The tutorial provides sample code for sending messages to the Vonage Messages Sandbox and forwarding user input to the Dialogflow agent to determine the intent of the message.

This tutorial enables chat functionality in an Angular web application using the JavaScript SDK and the In-App API, allowing users to communicate within the app. To complete this tutorial, a Vonage API account is required, along with basic knowledge of Angular and Node.js. The middleware code from GitHub is cloned and installed, followed by creating an RTC application on the Vonage platform to use within the code. The app creates users and conversations, then authenticates users using the In-App SDK's login method. An Angular service is created to handle data from the middleware, which includes generating a new Angular application with routing, adding Material Design components, and implementing methods for selecting a conversation, sending text, and recreating chat history. The app also features a login component with a form that calls onLogin() when submitted, and a conversation component with a sidenav, conversation members list, and input section to send messages into the conversation. After making these changes, the app can be run at "http://localhost:4200" to see it working.

The article guides users through the process of building an application that enables users to make phone calls directly from a web browser using Vue.js and In-App Voice with Vonage. The application uses the Vonage Client SDK for JavaScript, requires a server setup with Express.js to generate a User JWT, and utilizes Ngrok to create a local tunnel for communication between the browser and the Nexmo platform. After setting up the client-side functionality, users can enter a valid phone number, click the call button, and initiate an outbound call from their web browser. The application also supports receiving inbound calls using In-App Voice in Developer Preview.

This tutorial explains how to use the Nexmo Call Control Object to make anonymous calls using a Vonage virtual phone number as a proxy. The tutorial covers setting up an application and webhook endpoints, using a Vonage Call Control Object to forward a call between two temporary phone numbers, and demonstrates a real-life scenario where a buyer can communicate anonymously with a seller without revealing their phone numbers. For production applications, it's recommended to use multiple APIs to build a complete solution, such as handling incoming calls, determining the virtual number of the rider, and sending SMS messages to private numbers.

The text discusses the author's experience building a custom video chat app using Vonage Video API and React components. The author created a portal for students of an Ada Developers Academy bootcamp to get in touch with tutors and receive real-time face-to-face help from industry mentors. They used the OpenTok React wrapper to integrate high-quality video and audio streaming into their React app, which provided customizable components that were flexible enough to embed within any of their future React apps. The author built out reusable React components for publisher, subscriber, connection status, and checkbox, demonstrating how to use these components to create a modularized and reusable video chat app. They also created a simple CSS style guide to enhance the user experience.

When expecting large volumes of messages, using a message queue like AWS SQS can help navigate issues such as ensuring all messages are received. A serverless microservice on AWS Lambda can be created to add messages to SQS and facilitate sending through Vonage SMS, serving two purposes in the process. To complete this tutorial, prerequisites include Python 3.8, Node.js, npm, a Vonage API account with API Key and Secret, and setup instructions involving cloning a repository, renaming files, updating environment variables, and creating AWS credentials. Once set up, the application can be run locally or deployed to AWS Lambda, where it provides four URL endpoints for testing: / (no action), /add (stores message in SQS), /get (retrieves message from SQS FIFO queue), and /delete (deletes message from SQS).

Vonage Voyagers is a one-year program that rewards and recognizes valuable contributors in the communication technology space by providing them with opportunities to work with new technologies, collaborate with peers, and learn from experts. The program aims to foster a community of like-minded individuals who support and learn from each other. It offers developers the chance to get their hands on new communication technologies first and be part of a global network of innovators. Applicants can apply directly or nominate others to join the program. Recent participants include Joe McAlister, Michael Owolabi, and Henry Shepherdson, who share their experiences working on various projects, including an online version of playable theatre, a web application for property rentals, and a personal productivity app. As Voyagers, they look forward to learning from experts, networking with peers, and contributing to the development of communication APIs.

Creating an AWS Lambda Function for Python using Serverless involves several steps, starting with installing the Serverless framework globally and setting up AWS credentials. The user then guides through creating a new project, selecting the type of project (in this case, Node.js) and providing additional details such as the name of the project and whether to activate added services. A basic `serverless.yml` file is generated, which outlines the service name, provider information for AWS Lambda with Python runtime, function details, and deployment criteria. The user can then deploy the function to AWS Lambda using Serverless, test it using the AWS Console or CLI, and also create an API Gateway trigger to test the function as an HTTP endpoint.

Angular is a popular single-page application (SPA) framework used by .NET developers for building real-time web applications, including a basic video chat application using the Vonage Video API. The project begins with setting up Visual Studio and creating an Angular project, followed by importing necessary NuGet packages and configuring the Entity Framework to create a database. A SessionController is created to handle session-related logic, while a StateService is used to manage state between components. The application consists of two primary views: Join and Video, which are built using Angular components and services. The application uses the Vonage Video API to establish real-time communication between users.

With the help of the Vonage SMS API, developers can send SMS messages anywhere in the world using their virtual phone number, Ruby SDK, and a few lines of code. To integrate Nexmo into a Rails application, one needs to set up the basics, including obtaining an API account, installing the Nexmo Ruby Gem, and initializing it with credentials. The integration allows for sending SMS messages from within the application, storing the data in a model, and then sending the message using the Nexmo API. The process involves creating a form, storing the SMS record, and then sending the message using a method that updates the message ID on the SMS record if the status equals 0.

Vonage's Voice API allows developers to connect multiple parties to the same call by using a webhook endpoint and a conversation action in the Nexmo Call Control Object (NCCO). This is achieved by creating a Flask application that defines a webhook endpoint, making it accessible over the public Internet through tools like ngrok. The developer needs to create a Vonage Voice API Application, link it to their virtual phone number, and configure security information before initiating a conference call. The process involves purchasing a virtual phone number, installing dependencies, setting up the Flask application, and running the Vonage CLI commands to create an application and link it to the number.

We've developed a new feature for our Voice API that enables real-time streaming of conference call audio to web browsers, using Web Audio APIs. This allows for "listen-only" mode in large-scale calls where most participants are passive listeners. The new WebSocket support simplifies server-to-server communication between the Vonage Voice API and speech AI platforms like IBM Watson or Amazon Alexa. Our demo at AWS ReInvent showcases this feature by streaming the audio of a conference call to web browsers, playing it back with Web Audio APIs. This technology opens up possibilities for integrating voice with web applications, such as reducing costs and improving efficiency in large company calls. The WebSocket API provides a low-latency, one-way audio stream that can be easily integrated into web clients.

To create an application that sends SMS notifications using Nexmo whenever Stripe sends out a charge succeeded event, one needs to set up several components including Laravel 5.8, Composer, a Vonage API account, a virtual phone number, and Ngrok. The application requires environment variables such as Nexmo API key and secret credentials, SMS FROM and TO numbers, and a webhook endpoint that Stripe will make a POST request to when a charge succeeds. A WebhookController is created to handle the webhook event, which triggers a notification using Laravel's Notification Facade. The notification class, NewSaleOccurred, is also generated to send an SMS notification with the sale amount. Finally, Ngrok is set up to make the application publicly accessible and Stripe's webhook endpoint is configured to send test events to the application, allowing it to receive instant SMS notifications.

This tutorial demonstrates how to use ASP.NET Core MVC, SignalR, and the Vonage Messages API to receive SMS messages in real-time. The application uses a virtual phone number purchased from Vonage to receive incoming SMS messages. When an SMS message is received, it is sent to all connected browser clients through SignalR, allowing them to display the message in real-time on their web page. The tutorial covers the necessary steps to set up the project, including installing dependencies, creating an SMS hub, configuring middleware, building an SMS controller, and adding a frontend. It also includes instructions for testing the application using Ngrok.

Nexmo's WebSocket feature allows for real-time audio streaming from phone calls, enabling various applications such as two-way conversations with AI bots, sentiment analysis, or keyword tracking. To utilize this feature, speech recognition or transcription is required to convert the audio into text, a process that can be performed in real-time using AI platforms like IBM Watson. The connection between Nexmo and Watson involves a relay server due to their different interfaces, requiring the use of a WebSocket interface for seamless communication. By establishing a WebSocket connection with Watson, users can receive transcription messages with confidence scores, allowing them to refine or correct the output as needed. The process also includes handling incoming messages from Vonage, parsing audio parameters, and sending requests to Watson to initiate transcription. When the call ends, Nexmo closes the WebSocket connection, triggering an action to stop the transcription stream in Watson.

This tutorial aims to build a Single-Page-App (SPA) using Blazor WebAssembly, MVC, Entity Framework Core, and SignalR, which can send and receive SMS messages. The application will store received messages in the database and push them to client applications using SignalR. It will also handle delivery receipts by storing them in the database and pushing them to clients. The project requires a Vonage API account and Ngrok for testing. The tutorial covers setting up the solution, installing dependencies, building the model, creating the database, adding SMS hub, configuring middleware, building controllers, and finally, building the frontend.

The Vonage API Developer Platform was migrated from Ruby on Rails to Vue.js as part of an effort to unify the company's JavaScript frameworks and improve code reusability. The migration involved migrating four React components, including a feedback widget, search bar, SMS character counter, and JWT generator, into Vue.js. The choice of Vue.js was driven by its simplicity, ease of use, and compatibility with classic web technologies. The migration process involved iterative testing and validation to ensure the new components worked as expected. The new component, SMS character counter, was built using single-file components, computed properties, and conditionals, which simplified the rendering logic compared to React. The migration demonstrated the benefits of using a unified JavaScript framework across the company's applications, improving code reusability, maintainability, and scalability.

Two-factor authentication is a security process that requires two different authentication factors to verify a user's identity. This tutorial will guide you through implementing 2FA for web applications using the Vonage Verify API and Koa.js framework. To complete this tutorial, you'll need a basic understanding of JavaScript, Node.js, and a Vonage API account. You'll also set up a virtual phone number to send verification codes via SMS. The tutorial covers creating a login page, handling user inputs, triggering verification codes, checking verification codes, and canceling verifications. It emphasizes the importance of error handling and suggests implementing frontend validation and using additional APIs for more robust security measures.

The Ethereum blockchain is used to create a distributed ledger where users can agree upon code execution and data updates. Smart contracts emit events from the blockchain which a user interface can listen for to enable specific actions and write event logs (data) to the blockchain. The Vonage Conversation API provides a host of APIs to enables real-time communication over several channels (voice, text, video). Interactions via these channels can be initiated by creating a Conversation, and users are created to interact in this conversation via membership. A Node.js application is set up with environment variables for easy interaction with the Vonage Conversation API and the Ethereum blockchain through Web3. The application sends a message to the network, creates a Conversation event once the transaction hash becomes available, and listens for Blockchain events such as NewText emitted from the Ethereum Blockchain.

The Vonage Voice API WebSockets feature has become generally available after leaving beta status. This feature allows for two-way communication over a single persistent TCP connection, simplifying the HTTP response and request cycle. The tutorial covers building a small web server in Ruby to work with WebSockets, handling incoming voice calls, WebSocket connections, and rendering HTML. It requires Ruby 2.7 or higher, several gems, and a Vonage API account with a virtual phone number. The application uses Rack as the web interface and Thin as the web server. The tutorial covers creating a folder structure, defining dependencies, building the server, and creating routes for handling WebSocket connections, serving the index view, returning instructions to the Vonage Voice API, and acknowledging event lifecycle data.

Let's create a mobile app that allows users to sign up using their phone number and SMS 2FA. We'll use React Native for the UI and a Node/Express server on the backend, with Vonage APIs to integrate features like two-factor authentication. The app will request verification codes via SMS and allow users to verify their code once they receive it. Additionally, we'll enable users to send invites to friends via SMS.

Hacktoberfest is an annual event that encourages people to contribute to open-source projects, with Vonage participating for the first time. The event saw a 254% increase in pull requests compared to the average of the last 12 months, and over 43 hours of live streaming content were broadcast on Twitch. Vonage hosted various events, including Hacktoberfest Tuesdays, which featured talks from team members and special guests, as well as official and community-organized events. The company also created new education resources, such as tutorials and articles, to support the community during the event. Participants who contributed to open-source projects were rewarded with swag, including a t-shirt and stickers, and had the opportunity to plant a tree or receive a $5 gift card. Vonage is committed to supporting open-source contributions beyond the event, with resources available on their website for anyone looking to get involved.

Gradle's dynamic dependency mechanism can lead to issues such as unpredictable build behavior and introducing new bugs into an application. This is because the version of external libraries used by the application can change over time, making it difficult to reproduce a specific build. The use of dynamic dependencies can also cause problems for library creators, who may not be aware that their users are using outdated versions of their library. To mitigate these issues, developers should consider specifying dependency versions explicitly or using Gradle's locking feature or plugin to manage version updates and ensure deterministic builds.

The Bootstrap Chat application is built using standard components and minimal CSS editing, resulting in a simple yet appealing messaging UI. The guide enhances an existing chat application with Bootstrap 4, covering topics such as adding navigation, styling the message feed, lists, inputs, avatars, and auto-scrolling to the bottom of messages. The demo application demonstrates these techniques, allowing developers to style their own messaging UIs using Bootstrap.

The Apollo client library within a Node.js Express app can provide a middleman to a third-party endpoint, abstracting GraphQL queries and mutations without requiring direct access from the frontend JavaScript app. An Express application can use this middleman to forward requests to the third-party endpoint, handling authentication with custom headers as needed. The example uses the Apollo client library to create an HTTP link that injects node-fetch, providing a solution for scenarios where CORS headers are not provided by the third-party endpoint. The code also demonstrates how to generate valid JWT tokens and attach them to custom headers using the jsonwebtoken package. With this setup, requests can be sent to the Express application to retrieve data from the third-party endpoint.

You can receive an SMS with PHP using the Vonage API, which makes an HTTP request to your application containing information about the incoming SMS. To do this, you'll need a Vonage API account and a virtual phone number purchased through the Vonage CLI. You'll use the Slim framework to handle both GET and POST requests to the `/webhooks/inbound-sms` endpoint, logging the received parameters in the console. Once your application is complete, you can expose it with ngrok to send HTTP requests to your local application, configuring your Vonage account to use this URL as the callback for inbound SMS.

In a previous post, we showed you how to send an SMS with Go. This post will show you how to receive SMS messages with your Vonage virtual number. A publically accessible webhook is required and configured with your Vonage account to receive an inbound SMS. To complete this tutorial, you need a Vonage API account and a virtual phone number. You can find the code used in this tutorial on our Go Code Snippets Repository. The tutorial covers the process of setting up a publically accessible webhook, and the functionality to receive inbound SMS messages. Ngrok is used to expose the project to the internet. To test the setup, you need to purchase a Vonage virtual phone number, configure your Vonage account, and run the code in a new Terminal window. The code listens for any request sent to the /webhooks/inbound-sms endpoint and outputs the msisdn and text part of the body of the request. With Ngrok already running, you can test the webhook by sending an SMS to your virtual number. The webhook receives more fields than are displayed above, including the API key, message ID, and timestamp.

When Vonage receives an SMS message on a Vonage number, it looks up the webhook endpoint associated with that number and calls it with a big blob of JSON describing the message that was just received. To handle this, we use Ngrok to tunnel incoming requests from Vonage's servers to our local machine, where Jetty is running. We configure Jetty to run on port 8080 by default, which makes life easier. A small servlet written in Java receives and processes the JSON data sent by Vonage, printing it to the console for debugging purposes. The servlet is then configured with a URL pattern of /inbound to receive the webhook calls from Vonage. Once configured, sending an SMS message to the number should trigger the servlet to print the received parameters to the console.

Vonage Voyagers is a one-year program that rewards and recognizes valuable contributors in the communication technology space, offering them an opportunity to get hands-on with new technologies and connect with like-minded peers. The inaugural Voyager crew includes Naomi Pentrel from Amsterdam, Victor Steven from Lagos, Nigeria, and Omer Geva from Tel Aviv. Each Voyager has recently worked on a project related to their interests and is looking forward to developing content, collaborating with others, and learning about communication APIs. They find working with APIs exciting because it allows developers to build communication into everything easily, connect users in creative ways, and cater products to different lifestyles. The program aims to provide valuable support and recognition to community contributors, and interested individuals can apply or nominate someone to join the Voyager crew.

This summary provides a comprehensive overview of incorporating Web Components into a Vue application, covering both Vue 2 and Vue 3 versions. In Vue 2, the `ignoredElements` array is used to let the application know that a Web Component is present, while in Vue 3, the `config.isCustomElement` function is used instead. The Composition API introduces new features such as tracking values with the `ref` function and accessing component methods using the `value` property. Additionally, the Vonage Verify API can be integrated into a Vue application to provide a secure verification process for users. The integration involves creating a custom Web Component that communicates with the server-side API to send and verify security codes. Overall, this summary highlights the key points of incorporating Web Components into a Vue application and demonstrates how to use the Vonage Verify API in a real-world example.