Forem: Vonage Developers

The Vonage Dev Discussion: Open Source

Liz Acosta — Wed, 25 Mar 2026 16:59:12 +0000

At Women+ in Open Source Day, I got to try my hand at making a contribution to Apache Spark. While I didn’t manage to clone and build the project within the allotted time, I did get to speak with one of the project’s key contributors, Holden Karau, and was inspired by her encouragement for all sorts of people to get involved.

Contributing to open source can be intimidating! And in the age of AI, contributors from diverse perspectives are even more important.

So for our second ever Dev Discussion, we want to know: What is your advice for getting started contributing to open source projects?

Share your advice in the comments below along with links to some of your favorite open source projects! 🖥️ 🎉👇

MCP, n8n, Symfony: New tutorials to kickstart 2026 🚀

Daniela Facchinetti — Fri, 20 Feb 2026 11:07:25 +0000

Hello Developers!

Let’s kick off the new year with a quick look at our Q4 2025 launches. Then get ready for two new releases: Identity Insights in GA plus Silent Authentication Advanced in Verify API. And don’t forget the fresh tutorials — including AI-powered WhatsApp agents, Symfony SMS to 2FA, phone number insights, and Network APIs — to help you build smarter and more securely.

Check them out and start building something amazing.

RELEASES and ANNOUNCEMENTS

Vonage Q4 2025 Recap: Highlights and Insights

Last quarter doubled down on the fundamentals you count on every day. From stronger identity signals and AI-ready workflows to unified reporting and Video API improvements, the team shipped updates that make building easier and more reliable. Revisit how the updates help you build with confidence on Vonage.

Identity Insights API Now Generally Available

Your feedback was invaluable to refine real-time, production-ready phone number intelligence for identity verification, fraud prevention, and data enrichment. And now it’s all backed by enterprise-grade support.

Introducing Silent Authentication Advanced in the Verify API

The next evolution of authentication brings seamless, device-based verification beyond cellular networks to Wi-Fi and VPN. U.S. developers can be among the first to test this next-gen authentication flow.

TUTORIALS and INSPIRATION

Contribute to the Open Source Vonage MCP Tooling Server

The Vonage MCP Tooling Server lets you power AI agents across messaging and voice channels. Tap into the open-source design to add new capabilities like MMS, SIM swap checks, or Voice API features. Benjamin Aronov shows how to add a new tool and submit a Pull Request to help shape the future of the platform.

What Are Network APIs?

Jeremy Foster provides a quick, developer-friendly intro to Vonage Network APIs. He also explains carrier-verified signals to help you verify identity, reduce fraud, and build trusted authentication experiences at scale.

Eliminating Hallucinations in LLM-Driven Virtual Agents

Vonage AI Studio lets you build smart, low-code virtual agents. Recent updates improve LLM accuracy, stability, and reliability. Shir Hilel shares insights and how these changes make conversations more predictable and grounded.

Build a 5-Node AI WhatsApp Receptionist With n8n and Vonage MCP Tools

Benjamin Aronov reviews the steps to automate guest support — such as managing routine questions, escalating urgent issues through SMS or voice, and keeping context with a simple, reusable workflow.

Learn About Phone Number Validity

Accurate numbers are key for one-time passwords, updates, and support efficiency. Vonage Identity Insights API helps verify numbers across formats, carriers, and reachability checks. Amanda Cavallaro explains how ensuring number validity improves user experience and reduces errors.

Send SMS Text Message With Symfony

Symfony keeps innovating in PHP, from API Platform to FrankenPHP. Curious about CPaaS? In this video, Alexandra Williams shows Symfony developers how to send an SMS with Vonage.

Add Two-Factor Authentication With Node.js, Express, and Vonage

Two-factor authentication (2FA) adds an extra layer of security using a password plus a verification token. Julia Biro demonstrates 2FA implementation with Vonage Verify API and Express.js.

The Vonage Dev Discussion: Music

Liz Acosta — Tue, 17 Feb 2026 20:50:55 +0000

Hey developers! We want to hear from you for a series we’re calling the Dev Discussion.

What is the Dev Discussion? We want it to be a space where we can take a break and talk about the human side of software development.

Our first Dev Discussion topic is about music 🎶

Speaking of music and tech, you’ve probably heard this track while waiting on hold ☎️🎵

Did you know it was composed in 1989 by Darrick Deel and Tim Carleton, a self described, “Yanni-loving computer nerd” who was just “messing around with a drum machine and a synthesizer” in his parents' garage in California?

You can make it your hold music too!

Besides cool drum machines and chill synthesizers, we want to know:

What is currently playing in your headphones?

Does what you listen to change according to what you are working on?

Do you ever work in complete silence?

Feel free to drop those playlists in the comments below 🎶 👇

🎁 Holiday Update: MCP Tooling Server + LinkedIn Page

Daniela Facchinetti — Fri, 09 Jan 2026 13:41:41 +0000

Hi!

An eventful 2025 closes with two big announcements: the introduction of the Vonage MCP Tooling Server and the launch of the Vonage Developer LinkedIn Page. Read on for more updates, fresh tutorials, and new ways to get the most out of Vonage APIs.

Happy Holidays, and see you in the new year!

Daniela, Developer Relations Content Manager

RELEASES and ANNOUNCEMENTS

Introducing the Vonage MCP Tooling Server

Now, AI agents like Claude and Cursor can send messages, provision numbers, check balances, and manage your Vonage apps directly from a prompt. It’s open-source and secure, plus it comes with ready-to-use tools you can easily extend.

Introducing the Vonage Developer LinkedIn Page

Here’s your space to stay up to date with insights and news, learn, connect with the community … not to mention participate in events, webinars, contests, and more. Make sure to follow us.

Announcing SSL Security Enhancements

These updates keep Vonage APIs securely encrypted and compatible with modern clients — and the benefits now extend to other Vonage domains. Learn how these SSL updates help protect your data and ensure secure end-to-end communications.

TUTORIALS and INSPIRATION

Spread Holiday Cheer With AI Agents and Vonage MCP Messaging Tools

One-size-fits-all messaging no longer works. Some users prefer SMS, others like WhatsApp, and RCS adoption is growing fast. Benjamin Aronov shows how to integrate an AI agent with the Vonage MCP Server to send holiday messages that automatically respect preferences, channels, and even language.

Monitor Your Webhooks With Laravel Nightwatch

Monitoring PHP applications can be daunting. Laravel Nightwatch changes that with a native, easy-to-use way to track application events and performance. Jim Seconde spins up a simple webhook and monitors it all through the Nightwatch dashboard.

Send and Receive WhatsApp Messages With Python

Alexandra Williams teaches you to use Flask to send and receive messages — without the full Vonage app or WhatsApp Business Account — making it the fastest way to experiment with Vonage Messages API.

Improve the User Video Experience With Real-Time Quality Monitoring

Did you know there’s a standard for how good your video looks and feels? The Mean Opinion Score (MOS) bridges the gap between technical metrics like jitter and latency with actual user satisfaction. Amanda Cavallaro explains MOS, why it’s subjective, and how your Vonage video application can use it to enhance user experience.

Identity Insights API Use Cases for Fraud Prevention

Fraud threats are evolving fast, with AI-driven scams targeting businesses of all sizes. Staying ahead requires smarter detection, stronger prevention, and constant vigilance. Amanda Cavallaro explores four identity insights use cases and how Vonage Identity Insights API provides real-time access to carrier, subscriber, and device data to help combat fraud.

EVENTS

Laravel Community Meetup (London, 21 Jan.)

The Vonage London office is hosting the next Laravel community meetup. Join us for an evening of networking, great talks, and friendly faces. Whether you’re a long-time member or brand new to the community, we’d love to see you there.

Now live: U.S. Network APIs + Video API updates

Daniela Facchinetti — Fri, 28 Nov 2025 17:19:10 +0000

Hi!

November brings exciting news: the launch of Network APIs in the U.S and important Video API updates.

As always, we bring you fresh tutorials to explore — including guides on RCS, MCP, and Laravel — perfect for levelling up your developer skills. Stay tuned, dive in, and make the most of these updates to supercharge your projects.

Best,

Daniela - Developer Relations Content Manager @ Vonage

RELEASES and ANNOUNCEMENTS

Vonage Launches First Aggregated Network APIs in the U.S.

Vonage brings aggregated Network API access for AT&T, T-Mobile, and Verizon. Developers can now tap into carrier-verified insights with a single integration to enable smarter, real-time identity, security, and connectivity features — minus individual carrier complexities.

Vonage Reports API Now Supports Video API

Attention Unified Dashboard users — track all your Video, SMS, Messages, Voice, and Verify analytics in a single, easy-to-use interface.

Announcing v1.3.0 of the Vonage Video Reference App for React

The latest release introduces major UX upgrades, polished interfaces, and enhanced backend customization.

Announcing v2.32.0 of the Vonage Video API

You’ll enjoy advanced monitoring tools, finer video quality control across all major SDKs, and numerous stability and performance improvements, especially for web and iOS.

TUTORIALS and INSPIRATION

Step-by-Step: Adding Vonage APIs to Your Agent With MCP

Chris Tankerlsey guides you on how to create a chatbot using Anthropic Claude API and the Vonage Model Context Protocol (MCP) Tooling Server. So go ahead and chat, plus perform actions like checking account balances.

Introducing MCP: AI Meets Programmable Communications With Vonage

AI agents can now handle tasks like “Send a text” with no code required. The Model Context Protocol (MCP) makes it possible by giving agents access to APIs and data across systems. Alexandra Williams details how Vonage is adopting this open standard with our newly launched Documentation MCP Server.

Integrate RCS Into Your Authentication Workflows

RCS brings SMS into the modern era with features like verified branding and read receipts. Amanda Cavallaro shows how to integrate RCS-based 2FA using Vonage Verify API, with automatic fallback to SMS when needed.

Sandbox Quickstart: Send and Receive WhatsApp Messages With Python

It’s time to test a chatbot, build a quick messaging prototype, and explore Vonage Messages API. Benjamin Aronov shows you how to send and receive WhatsApp messages using Python and the Vonage WhatsApp Sandbox — with no need for a full app setup or WhatsApp Business Account (WABA).

The Laravel AI Experience: Coding Basic RCS Functionality

AI is rapidly changing the developer experience, from tools like LaraCopilot to specialized MCP servers such as Laravel Boost. Jim Seconde explores how AI can help you prototype a Laravel app that sends and receives RCS messages, highlighting the new possibilities in PHP and Laravel development.

Laravel 12 Starter Kits Explained: React, Vue, and Livewire

The updated Laravel 12 starter kits simplify setup. Choose React, Vue, or Livewire to match your preferred workflow and get routes, controllers, and authentication ready out of the box. Diana Pham shows what each kit offers and how to find the best fit for your next Laravel app.

EVENTS

AWS re:Invent(Las Vegas, 1 to 5 Dec.)

The Vonage Developer Ecosystem team is headed to Vegas. If your startup will be there, we’d love to connect. Book a meeting at: startups@vonage.com.

🚀New Reports API, Documentation MCP Server, RCS tutorials

Daniela Facchinetti — Mon, 03 Nov 2025 12:59:07 +0000

Hi!

This month brings some big updates: the launch of our new Reports API and the Documentation MCP Server. You’ll also find plenty of fresh content, from deep dives into RCS to hands-on tutorials that showcase what’s possible with our APIs. Plus, don’t miss your chance to join our Developer Community survey or meet us at an upcoming event. We’d love to hear from you!

Daniela (Developer Relations Content Manager @ Vonage)

RELEASES and ANNOUNCEMENTS

Introducing Vonage Reports API

No more stitching data from multiple sources. Get a centralized, consistent view of your communications in one place. Track delivery status, view billing info, detect fraud, and feed live data into your own dashboards with ease.

Vonage Q3 2025 Highlights: New APIs, Tools, and Features

Q3 was all about giving developers more power with less friction. We launched Beta Identity Insights API, added smarter post-call tools with AI summaries, improved messaging reliability, made video calls smoother with scalable video coding and live captions, and more!

Introducing the Vonage Documentation MCP Server

Vonage Documentation MCP Server gives you access to Vonage Docs directly from your development environment or AI assistant. Whether in VS Code, Cursor, or with tools like Claude, documentation is now right where you need it, without interrupting your workflow.

SURVEY

Your Viewpoint Questionnaire — Developer Community

The Vonage Developer Community offers workspaces, channels, events, and activities to help developers connect and support one another. We’d love your feedback to improve the Developer Community. Complete the questionnaire by Nov. 30, 2025, *to receive a *€10 Vonage coupon. Limited to one entry per person. Open to Vonage Viewpoint User Group participants only.

TUTORIALS and INSPIRATION

Introducing MCP: AI Meets Programmable Communications With Vonage

With the new Model Context Protocol (MCP), agents can dynamically discover and use tools and APIs. Benjamin Aronov explains how Vonage is bringing this to life with our Documentation MCP Server and upcoming Tooling Server.

RCS LLRE: RCS With Laravel, Livewire, Reverb, and Echo
What better way to show off Laravel Livewire’s real-time power than building an RCS messenger? James Seconde combines Laravel Livewire with Vonage Messages API to create a sleek, real-time messaging app.

Play an Audio File Into a Voice Call With PHP

Curious how automated calls work for businesses? Alexandra Williams demonstrates how to send an automated voice call and play an audio file when the call is answered using Vonage PHP SDK.

Send Visual Weather Forecasts With Vonage RCS and Google AI

In this tutorial, Amanda Cavallaro builds a Node.js app that fetches the weather, generates a descriptive image with Google’s Imagen, creates a short summary using Gemini, and sends it all as a rich RCS card via Vonage Messages API. Create interactive, visually engaging weather updates for your users in just a few steps!

Detect SIM Swap Fraud With Go and Vonage

SMS-based 2FA can be vulnerable to SIM swap attacks, where fraudsters hijack your number to steal security codes. With Vonage Identity Insights API, you can detect SIM swaps in real time. Benjamin Aronov shows how to integrate it with Go (Golang) to keep your users safe

Getting Started With the Vonage Live Captions API in Node.js

Add live captions to your video for accessibility and better focus! Dwane Hemmings walks you through integrating Live Captions API, with support for multiple languages and a one-click GitHub sample.

JWT Authentication in Go With Gin

Learn how to build secure JWT authentication in Go with Gin using golang-jwt/jwt/v5. In this guide, Benjamin Aronov covers access and refresh tokens, HttpOnly cookies, Redis-based revocation, and Vonage API integration.

EVENTS

Live!360 (Orlando, Nov. 18-19)

We’re heading to Live! 360, the ultimate tech conference for devs, data pros, and IT leaders. Swing by our booth, grab some swag, and let’s connect!

🚀New Identity Insights API + RCS Tutorials and Events

Daniela Facchinetti — Fri, 26 Sep 2025 14:19:25 +0000

Hi!

September brings a new API - Identity Insights — plus major Video API improvements. The Vonage Viewpoint Questionnaire is ready for your feedback. You’ll also find fresh tutorials on RCS and SIM swap fraud … not to mention the latest tech trends. And get ready for a busy events season. Circle the dates and come meet the team.

Daniela (Developer Relations Content Manager @ Vonage)

SURVEY

Your Viewpoint Questionnaire — Developer Community

The Vonage Developer Community offers workspaces, channels, events, and activities to help developers connect and support one another. We’d love your feedback to improve the Developer Community. Complete the questionnaire by November 30, 2025, *to receive a *€10 Vonage coupon. Limited to one entry per person. Open to Vonage Viewpoint User Group participants only.

RELEASES and ANNOUNCEMENTS

Identity Insights API Now in Beta

It’s time to access powerful mobile network features that simplify the understanding and manipulation of phone number data. Look at what’s possible and how to get started.

VP9 SVC in Vonage Video API Released for General Availability

VP9 offers better video quality at lower bandwidths, making it ideal for bandwidth-constrained networks. SVC enables video streams to dynamically adapt to network conditions and device capabilities. This enables more efficient, resilient, and scalable video experiences.

Announcing v2.31.0 of Vonage Video API

The latest update introduces new features and enhancements to Vonage Video Client SDKs — which boost bandwidth management, session moderation, and telephony integration. All to help you build high-quality video apps faster and more reliably.

Now Receive Audio With the Vonage Video API Audio Connector

You can now send audio back into your sessions just as easily as you receive it. This update simplifies integration with voice services — including OpenAI, voice-to-text tools, and agentic bots — all through a single WebSocket. See the release blog post and start using bi-directional audio today.

TUTORIALS

Build a Real-Time Interactive RCS Experience With Node.js and Vonage

Benjamin Aronov shows how to create interactive messaging experiences using suggested replies, rich cards, and carousels in a single seamless journey. Build richer, real-time conversations for sports, music, or any live event with Vonage Messages API.

Prevent SIM Swap Fraud in Python With Identity Insights API

SIM swap fraud is a growing mobile security threat, with attackers hijacking phone numbers and intercepting calls, texts, and 2FA codes. Benjamin Aronov uses Vonage Identity Insights API in Python to detect potential SIM swaps and keep your users safe.

How Vonage Uses CAMARA APIs to Improve Developer Experience

Vonage fully supports open standards like CAMARA to simplify access to network capabilities. Rather than standalone endpoints, we’ve embedded CAMARA APIs directly into our products to give developers more flexibility and a smoother experience. Alvaro Navarro offers real examples of how this approach enhances Vonage APIs.

Man in the Loop vs. LLM in the Loop

Vonage AI is rethinking speech-to-text benchmarking by combining human oversight with automation. The teams use large language models (LLMs) to generate consensus transcriptions from multiple STT outputs — which then enable scalable, unbiased, and context-aware evaluation.Yotam Luz compares this approach with traditional methods and the key insights from our experiments.

Send an SMS Message With PHP

Alexandra Williams offers a step-by-step tutorial using the Vonage PHP SDK. This includes everything you need to quickly begin … such as setting up, writing your script, and creating a POST route.

EVENTS

Devfest Nantes(Nantes, Oct. 16 to 17)
The Vonage booth is where you’ll experience spellbinding live demos, gather mystical swag, and immerse yourself in the wonders of our APIs.

APIAddictsDays25 (Madrid, Oct. 22) [25SEP_DEV-NEWS_IMGS_API-DAYS]

The largest API event in Spanish discusses security, design, architecture, business models, and the latest API developments. Say hello at the Vonage booth and don’t miss Alvaro Navarro and his talk:Cómo evitar el derrumbe: diseña tus APIs antes de poner el primer ladrillo at 1:15 pm.

All Things Open (ATO)(Raleigh, Oct. 12 to 14)
ATO is the largest open-source and technology conference in the eastern United States. Stop by the Vonage booth and meet the team.

Longhorn PHP (Austin, Oct. 23 to 25)
The conference helps PHP developers improve their skills, learn about modern PHP development, and connect with the wider PHP community. Be sure to visit the Vonage booth and don’t miss Chuck Reeves’s talk “PHP Security Mechanisms You Aren't Using”.

Vonage CodeConnect Webinar — Stopping Fraud Before It Happens: Smarter Security for Banking (Online, Oct. 30)

Fraud is on the rise — from account takeovers to SIM swaps — and traditional authentication can’t keep up. Join our webinar to see how Vonage Verify and Identity Insights APIs help fintechs and banks stay a step ahead with stronger security.

Vonage CodeConnect Webinar Replays (online)

Missed the Vonage CodeConnect webinars? Enjoy the replays:

How to Send RCS Rich Card Carousels With Node.js

Benjamin Aronov — Fri, 12 Sep 2025 15:23:13 +0000

Introduction

Rich Communication Services (RCS) gives you the tools to build modern, interactive brand experiences right inside a user’s default messaging app. Among its most powerful features is the rich card carousel: a horizontally scrollable set of cards that can include videos, images, text, and tappable actions.

In this tutorial, you’ll learn how to send an RCS carousel using Node.js and the Vonage Messages API. You’ll combine video and image cards with actions to boost engagement.

>> TL;DR: View the full working code on GitHub

Use Case: Fashion Popup Announcement

Let’s say your brand is launching a limited-time fashion pop-up shop. You want to generate buzz and showcase key items. With an RCS carousel, you can package this all in one clean, interactive message.

Your RCS carousel will include media and suggested actions:

Card 1: Event Launch Video
- Video trailer for the popup
- 2 actions: “Save the Date” and “See Location”
Card 2: T-Shirts image:
- An image of the featured tee
- action: “See All Shirts”
Card 3: Hats image:
- An image of your hat collection
- action: “See All Hats”

What Is an RCS Carousel?

An RCS carousel is a set of swipeable rich cards, each with its own:

A title (max 200 characters)
A description (max 2000 characters)
Media: image or video
Up to four suggested replies or actions

The cards appear horizontally, allowing users to swipe through them.

Important notes:

All cards in a carousel must use the same type of suggestion.
Media files must be publicly accessible and under 100MB.
You can include between 2 and 10 cards.

Prerequisites

Before you start, you’ll need:

Node.js installed on your machine.
ngrok installed for exposing your local server to the internet.
A Vonage API account.
A registered RCS Business Messaging (RBM) Agent, see managed accounts below.
A phone with RCS capabilities for testing.

Vonage API Account

To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

How to Contact Your Vonage Account Manager

In order to send and receive RCS capabilities in your Vonage application, you will need to have a registered Rich Business Messaging (RBM) agent and a phone with RCS capabilities.

Currently, RCS Messaging through Vonage is only available for managed accounts. You will need to contact your account manager to request Developer Mode activation for your RBM agent. Developer Mode allows you to test RCS messaging to allow-listed numbers before completing the Agent Verification process and launching in production.

Please contact our sales team if you do not have a managed account.

Understand the difference between RCS and RBM.

How to Set Up Your Node.js Project

This guide assumes you're familiar with JavaScript and Node.js basics.

Initialize the Project

Create a new directory and initialize a Node.js project:

Install Required NPM Packages

Install the necessary node packages with Node Package Manager (NPM):

express: Creates the web server
dotenv: Loads your environment variables
@vonage/server-sdk: Sends messages through the Vonage Messages API

Create Your Project Files

Create the main application file and environment configuration file:

How to Configure Your Environment

In the .env file, add your Vonage credentials and configuration:

VONAGE_APPLICATION_ID: Your Vonage application ID.
VONAGE_API_SIGNATURE_SECRET= Your Vonage API Secret
VONAGE_PRIVATE_KEY: Your Vonage application’s private key file.
RCS_SENDER_ID: Your RBM SenderID (the Name of the Brand). The SenderID requires special formatting, such as not having any spaces. Check with your account manager if you’re unsure.
PORT: Port number for the Express server.

You will obtain your Vonage Application ID and private.key file below, in the “How to Create and Configure Vonage Application” section. Find your API Secret in the developer dashboard homepage.

How to Send an RCS Carousel

Now that your environment is set up, let’s write the code that actually sends your RCS rich card carousel.

In this step, you’ll create an Express server that sends a custom RCS message using the Vonage Messages API. The carousel will contain three swipeable product cards, each with media (video or image), a title and description, and actionable buttons your users can tap.

Load Dependencies and Initialize the Vonage Client

We’ll start by importing the necessary packages, loading your environment variables, and initializing the Vonage client. Add the following code to your index.js file to get things going:

Define an Express Endpoint to Send a RCS Carousel

A few small but important details are worth knowing before we send the carousel. All media files must be publicly accessible over HTTPS, ideally hosted on a CDN or cloud storage. We’re using GitHub-hosted assets for simplicity in this example, but in production, you’ll want faster, more reliable media hosting.

>> Keep individual media files under 100MB to meet RCS constraints.

Each card includes one or more action buttons using postbackData, openUrlAction, or createCalendarEventAction. The postbackData value is a short string (50 characters max) that your server can use to track what users tap. You can also link directly to maps or pre-filled calendar events for added interactivity, making the carousel feel more like a mini-app than just a message.

How to Receive RCS Suggested Actions via Webhooks

Sending off a carousel is great! But wouldn’t it be nice to know if your user interacted with your carousel? With Vonage webhooks, you can do just that.

Create the following endpoint, which will handle inbound RCS requests from our Vonage application. This code:

Validates that the request is coming from Vonage using a JWT signature
Looks for the button property since you’re expecting an action instead of a reply property, and stores the payload in userAction
Logs the userAction to our Node server to see what the user selected

How to Define Your Express Server

At the bottom of your index.js, add this code to build your Express server.

And finally run your server from the command line:

>> See the full index.js file.

How to Expose Your Server with ngrok

To receive webhooks from Vonage, your local server must be accessible over the internet. Use ngrok to expose your server by running the following command in a separate tab from your Express sever:

Note the HTTPS URL provided by ngrok (e.g., https://your-ngrok-subdomain.ngrok.io).

You can read more about testing with ngrok in our developer portal tools.

How to Create and Configure Your Vonage Application

Now that your Node App is ready, you’ll also need to create and set up your Vonage Application. First, create your app in the Vonage Dashboard. Give the app a name and turn on the Messages capability.

Vonage dashboard showing the creation of a new application configured for RCS messaging.

In your Vonage application settings:

Set the Inbound URL to https://YOUR_NGROK_URL/inbound_rcs.
Set the Status URL to https://example.com/rcs_status. ** Message statuses will be covered in a future article.
Generate a public and private key by clicking the button. Ensure to move your private.key file to the project root directory (rcs-carousel-node).
Save the changes.

Then link your RCS Agent by clicking the “Link external accounts” tab:

Dashboard view showing the Vonage-Node-RCS application linked to the Vonage RoR RCS external account, with voice and message capabilities enabled.

How to Test Your Node Application

Use this curl command to trigger your endpoint (replace placeholders):

On the recipient's phone, the Rich Card Carousel will appear and they can select an action!

Final Notes

You’ve now built an interactive RCS product carousel with Node.js and the Vonage Messages API. This is a great way to showcase products, promote events, or offer dynamic choices in a single message.

Want to go further?

Respond to taps and selections via postbackData
Load product cards dynamically from an API
Add location-based filters or categories

Come show off what you’re building in theVonage Community Slack or tag us on X (formerly Twitter). We’d love to see your carousels in the wild!

🚀RCS, Vibe Coding, Golang Tutorials + Events

Daniela Facchinetti — Fri, 29 Aug 2025 15:02:06 +0000

Hi!

Ready for some exciting news? We’ve rolled out powerful new features and enhancements **designed to help you build faster and smarter. And as always, you’ll find the **latest tech tutorials and upcoming events to keep you inspired. Read on to explore everything that’s new.

Daniela (Developer Relations Content Manager @ Vonage)

RELEASES and ANNOUNCEMENTS

Post-Call Text Insights Now in GA — Featuring AI-Generated Summaries
Developers can now access AI-generated summaries of recorded video sessions. Forget digging through transcripts … it’s now about smarter and faster insights for telehealth, education, recruiting, and more.

Introducing Message Failover in Vonage Messages API
This blog post details the failover functionality — including what failover is, how to use it, and some situations where it might be useful.

Number Verification API To Be Replaced by Verify With Silent Authentication
Vonage is consolidating its silent authentication solutions to reduce complexity and facilitate easier adoption. This includes Number Verification API sunsetting on September 30. All customers are encouraged to migrate to Vonage Verify API with the Silent Authentication workflow.

TUTORIALS

Vibe Coding With Cursor and Vonage APIs
Alexandra Williams demonstrates coding with Cursor, using Vonage developer documentation as context, to receive a WhatsApp message without needing to manually write code.

Send and Receive RCS Suggested Replies With ASP.NET Core and Vonage
Benjamin Aronov shows how to build an ASP.NET Core Web API that sends and receives RCS messages using Vonage .NET SDK. This tutorial covers suggested replies, secure webhooks, and end-to-end testing with ngrok and an RCS-enabled phone.

How To Send RCS Text Messages in GoLang
In this step-by-step tutorial,Benjamin Aronov builds and tests rich messaging with interactive content in your Go apps.

How To Create a Virtual Green Screen Using Vonage Video API
Richard Sabbarton uses Vonage Video API to overlay presenters onto shared content, leveraging background replacement and HTML5 canvas to create a virtual green screen.

Build a Storytelling Service With RCS and Gemini
Amanda Cavallaro walks you through building a generative AI storytelling service using Vonage Messages API for RCS and Google Gemini AI. This includes sending and receiving RCS Rich Card messages — and integrating Gemini to generate bedtime stories.

EVENTS

API World (Online, Sept. 3 to 5; in-person, Santa Clara, California, Sept. 10 to 12)
Alex Barnett will be a keynote speaker. Be there for his talk: “How network capabilities are powering the next wave of digital transformations".

Knowledge Quest, Video Edition Webinar (Online, Sept. 10)
Maybe you only associate Vonage Video API with a standard meeting format. But this API is flexible enough to support other topologies, including remote monitoring. We’ll review how remote monitoring works and guide you on setting up your application effectively.

Vonage CodeConnect Webinars (Online, Sept. 24)
Here’s a great chance to learn about Vonage Network and Communications APIs, such as SIM Swap and Device Location, to verify user identities and prevent fraud before it occurs. The session — Build Fraud-Resistant Mobile Banking With Network and Communications APIs — includes a live demo, with integration into banking platforms and ecommerce sites.

API Platform Conference (Lille, Sept. 18 to 19)
Jim Seconde discusses all things tooling, HAL, and HATEOS. Don’t miss his talk “2025, an API Platform Odyssey” on Sep 19, 2025 at 15.30. And check out the Vonage booth for PHP swag and our live demos.

Commit Your Code (Plano, Texas, Sept. 25 to 26)
Commit Your Code is more than just a web development conference — it’s a celebration of community, collaboration, and giving back. Whether you're into frontend, backend, or full-stack development, you'll find inspiring talks, like “What Online Dating Taught Me about Algorithms” by Diana Pham. Don’t miss it!

Sending SMS Messages with PHP

James Seconde — Wed, 20 Aug 2025 13:45:00 +0000

In this tutorial, we’re going to send SMS messages with as few lines of PHP as possible. Firstly, with a raw script, and secondly, using a minimal web application framework.

Prerequisites

PHP 8.1+
Composer, for package management
A Vonage API Account

How to Send Text with Raw PHP

We’re going to start by creating a new Composer project and pulling in the Vonage PHP SDK. Using the command line, add the following:

mkdir vonage-sms
cd vonage-sms
composer init

Composer will ask you a series of questions - you can leave these all to the defaults as we’re only doing the bare minimum of effort. The process should create your composer.json file. So, we can add the Vonage PHP SDK now:

composer require vonage/client

Now, to create our script.

touch send-sms.php

Open the new PHP file and make sure Composer’s autoload is pulled in:

<?php

require_once './vendor/autoload.php';

To send an SMS, we need three things:

A set of credentials taken from the Vonage Dashboard
A Client object
A text to send

Given this, here are the final lines of code:

$credentials = new \Vonage\Client\Credentials\Basic(YOUR_API_KEY, YOUR_API_SECRET);
$client = new Vonage\Client($credentials);
$message = new Vonage\Messages\Channel\SMS\SMSText(
  YOUR_NUMBER,
  'Vonage',
  'Hello from Vonage!'
);

$client->messages()->send($message);

Plug in the required details to the constant variable placeholders and hit send:

Four lines of code is pretty good! The second part is plugging this into a basic web framework so that you can POST a message instead of hard-coding it as we have above.

How to Send SMS via. Slim Framework

For the second example, we’re going to be using the Slim Framework, so install that with Composer:

composer require slim/slim:"4".*
composer require slim/psr7

The second command here installs Slim’s PSR-7 (Request Interface) implementation. We’re going to create a route that takes a POST request with a JSON body containing some text.

Here is the modified send-sms.php file:

<?php

use Slim\Psr7\Request;
use Slim\Psr7\Response;

require_once '../vendor/autoload.php';

$app = \Slim\Factory\AppFactory::create();

$app->post('/send', function (Request $request, Response $response) {
   $rawBody = $request->getBody()->getContents();
   $requestData = json_decode($rawBody);
   $text = $requestData->text;

   $credentials = new \Vonage\Client\Credentials\Basic('232130c9', 's09IJad98fa0t9j09ad8fa90s');
   $client = new Vonage\Client($credentials);
   $message = new Vonage\Messages\Channel\SMS\SMSText(
     YOUR_NUMBER,
     'Vonage',
     $text
);

   $client->messages()->send($message);

   $response->getBody()->write("Vonage sent this text!");
   return $response;
});

$app->run();

Instead of running this code, we’re mocking using a web platform instead, so we’re going to use PHP’s built-in webserver to fire up a development environment from the command line:

php -S localhost:8888 -t send-php.php

To send the message, you’ll want an HTTP tooling client that makes it easy to send POST requests - I’ve opted for Kong’s Insomnia but you could also use Postman or even a raw cURL request.

Conclusion

Now we have a route where you can send the message text to a server for it to complete the process. You can, of course, add additional keys to the JSON payload to add the from and to cellular numbers. Fancy building something out of it? Check out our Laravel integration or check out further reading on sending messages with this API in Symfony.

Have a question or something to share? Join the conversation on the Vonage Community Slack, stay up to date with the Developer Newsletter, follow us on X (formerly Twitter), and subscribe to our YouTube channel for video tutorials. Stay connected, share your progress, and keep up with the latest developer news, tips, and events!

Additional Resources

Sending SMS from PHP with Failover: The Cupcake Bakery

Type Safety Done Right - PHP Array Hacking

Scrub Up! Cleaning Your PHP Application With PHPStan

Vonage PHP SDK

Build a Storytelling Service With RCS Rich Cards and Gemini

Amanda Cavallaro — Tue, 19 Aug 2025 14:27:06 +0000

Introduction

This tutorial shows you how to build a generative AI storytelling service using the Vonage Messages API for RCS and Google’s Gemini AI. You'll learn what RCS is, how to send and receive RCS Rich Card messages, and how to integrate Gemini to generate short bedtime stories.

Inspired by my toddler's bedtime routines, I wanted to create something useful. So I combined RCS messaging with Gemini AI to develop a simple storytelling service.

You can find the complete source code on the Vonage Community GitHub repository.

Prerequisites

Node.js is installed on your machine.
An API tunneling service, such as ngrok.
A registered RCS Business Messaging (RBM) agent.
A phone with RCS capabilities.
A Vonage API account.
Vonage API Account
To complete this tutorial, you will need a Vonage API account. If you don’t have one already, you can sign up today and start building with free credit. Once you have an account, you can find your API Key and API Secret at the top of the Vonage API Dashboard.

How to Get RCS Working on Your Phone

To send and receive RCS messages in your Vonage application, you need a registered RBM agent and a phone with RCS capabilities.

RCS through Vonage is currently only available for managed accounts. You’ll need to contact your account manager to activate Developer Mode, which allows testing with allowlisted numbers.

If you don't have a managed account, reach out to the Vonage Sales Team for support.

Terminology

RCS (Rich Communication Services): An industry standard that enhances traditional messaging with rich media, branded content, and read receipts. If a recipient’s device or network doesn’t support RCS, messages automatically fall back to SMS to ensure they are still delivered.

Learn more in our RCS documentation.

SMS (Short Message Service): Traditional SMS supports only plain text. RCS allows branded buttons, images, and message status updates. Learn to send SMS messages with Node.js.

MMS (Multimedia Messaging Service): Unlike MMS, which often has lower media quality and file size limits, RCS supports high-quality media and features such as typing indicators and delivery status updates. Learn what you can do with MMS and how to send MMS with Node.js.

To create an application, go to the Create an Application page on the Vonage Dashboard, and define a Name for your Application. \
If needed, click on "generate public and private key". A private key (.key file) will be generated. Download and store it securely. This key is needed for authentication when making API requests. Note: Private keys will not work unless the application is saved.
Choose the capabilities you need (e.g., Voice, Messages, RTC, etc.) and provide the required webhooks (e.g., event URLs, answer URLs, or inbound message URLs). These will be described in the tutorial.
To save and deploy, click "Generate new application" to finalize the setup. Your application is now ready to use with Vonage APIs.

Messages API Capability

Start an ngrok Tunneling Instance

If you haven’t used ngrok before, you can start here. I’ve added the steps to run an instance below the image in the next section.

Run the following command to start an ngrok tunneling instance.

ngrok http 3000

In the output, you’ll find a URL that starts with https:// and ends in .ngrok.app/. Make a note of it as you’ll need it for the next step to configure your webhooks.

Forwarding https://94cd51b63460.ngrok.app/ -> http://localhost:8000

Configure Webhooks

Back in the Vonage API Dashboard, under your Apps, toggle the Messages option under capabilities and set your server's public URL from ngrok as the endpoint for inbound messages and events. it should look like: https://94cd51b63460.ngrok.app/webhooks/inbound for inbound and https://94cd51b63460.ngrok.app/webhooks/status for status. If you’d like to learn more about webhooks, you can find information on our Vonage documentation.

Initial Project Setup for Vonage Messages API

Clone the Vonage Community GitHub repository for this project and npm install the dependencies.

npm install express debug @vonage/messages @vonage/server-sdk dotenv

Create the Environment Variables File

Create a .env file in your project root.

VONAGE_APPLICATION_ID=YOUR_VONAGE_APPLICATION_ID, can be found within the application you’ve created

VONAGE_PRIVATE_KEY=./private.key, is the path to the private.key file that was generated when you created your application

RCS_SENDER_ID=YOUR_RCS_SENDER_ID

PHONE_NUMBER=YOUR_PHONE_NUMBER_E164 that will receive the RCS messages

PORT=3000

VONAGE_API_SIGNATURE_SECRET= is the secret used to sign the request that corresponds to the signature secret associated with the api_key included in the JWT claims. You can identify your signature secret on the Dashboard settings

In your project, you'll also find a vonage.js file that contains the Dotenv and Vonage Client Setup.

Add JWT Verification

Add a JWT verification function to verify if the incoming request (e.g., message or call) came from Vonage.

The VONAGE_API_SIGNATURE_SECRET variable is the secret used to sign the request corresponding to the signature secret associated with the API key included in the JWT claims. You can identify your signature secret on the Dashboard settings.

You can learn more about verifying the request.

const verifyJWT = (req) => {
  // Verify if the incoming request came from Vonage
  const jwtToken = req.headers.authorization.split(" ")[1];
  if(!verifySignature(jwtToken, process.env.VONAGE_API_SIGNATURE_SECRET)) {
    console.error("Signature does not match");
    throw new Error("Not a Vonage API request");
  }

  console.log("JWT verified");
}

Make sure to install the @vonage/jwt dependency.

npm install @vonage/jwt

Send an RCS Rich Card Message

In your server.js file, you'll find the finalized code with Gemini integration, but I wanted to give you a starting point on how to send a Rich Card Message in RCS with a hardcoded text so you can have a first experience with it and see it running before any more complex setup, with everything we've set up so far.

Start off by adding the imports and defining your variables.

import Express from "express";

import { RCSCustom, RCSText } from "@vonage/messages";

import { vonage } from "./vonage.js";

import "dotenv/config";

const app = new Express();

const port = process.env.PORT || 3000;

const recipientNumber = process.env.PHONE_NUMBER;

if (!recipientNumber) {

  process.exit(1);

}

if (!process.env.RCS_SENDER_ID) {

  process.exit(1);

}

We'll also use an async wrapper for error handling in routes.

const catchAsync = (fn) => (req, res, next) => {

  fn(req, res, next).catch(next);

};

app.use(Express.json());

app.get(

  "/send-story-request",

  catchAsync(async (req, res) => {

    await sendBedtimeStoryRequest(recipientNumber);

    res.status(200).json({ message: "Bedtime story request sent!" });

  })

);

Create the /webhooks/status endpoint.

app.post(

  "/webhooks/status",

  catchAsync(async (req, res) => {

    res.status(200).json({ ok: true });

  })

);

Create the /webhooks/inbound endpoint.

app.post(

  "/webhooks/inbound",

  catchAsync(async (req, res) => {

    const { channel, message_type, reply, from } = req.body;

    if (channel === 'rcs' && message_type === 'reply' && reply) {

      const receivedId = reply.id;

      const receivedTitle = reply.title;

      if (receivedId === 'GENERATE_STORY_REQUEST' || receivedTitle === 'Generate Story') {

        const replyToNumber = from;

        const helloWorldMessage = "Hello world!";

        await sendRCSGreeting(replyToNumber, helloWorldMessage);

      } else {

        // Unhandled reply

      }

    } else if (channel === 'rcs' && message_type === 'text') {

      if (req.body.text && req.body.text.toLowerCase() === 'generate story') {

        await sendRCSGreeting(from, "Hello world!");

      } else {

        await sendRCSGreeting(from, "I received your message: " + req.body.text);

      }

    }

    res.status(200).json({ ok: true });

  })

);

Add some error handling messages, and the app listens on the defined port (3000).

app.all("*", (req, res) => {

  res.status(404).json({

    status: 404,

    title: "Not Found",

  });

});

app.use((err, req, res, next) => {

  res.status(500).json({

    status: 500,

    title: "Internal Server Error",

    detail: err.message,

  });

});

app.listen(port);

Create the sendBedtimeStoryRequest that sends a new RCS Custom message that says ‘Bedtime Story Generator’, containing a button to generate a new story.

const sendBedtimeStoryRequest = async (number) => {

  const message = new RCSCustom({

    to: number,

    from: process.env.RCS_SENDER_ID,

    custom: {

      contentMessage: {

        richCard: {

          standaloneCard: {

            cardOrientation: "VERTICAL",

            cardContent: {

              title: "Bedtime Story Generator",

              description: 'Tap "Generate Story" for a magical tale!',

              media: {

                height: "MEDIUM",

                contentInfo: {

                  fileUrl:

                    "https://cdn-icons-png.flaticon.com/512/2917/2917637.png",

                },

              },

              suggestions: [

                {

                  reply: {

                    text: "Generate Story",

                    postbackData: "GENERATE_STORY_REQUEST",

                  },

                },

              ],

            },

          },

        },

      },

    },

  });

  try {

    await vonage.messages.send(message);

  } catch (err) {

    if (err.response) {

      err.response.text().catch(() => {});

    }

  }

};

Create the sendRCSGreeting that sends an RCS message using the Vonage Messages API.

const sendRCSGreeting = async (to, messageText) => {

  const message = new RCSText({

    to: to,

    from: process.env.RCS_SENDER_ID,

    text: messageText,

  });

  try {

    await vonage.messages.send(message);

  } catch (err) {

    if (err.response) {

      err.response.text().catch(() => {});

    }

  }

};

To run the app, start the server:

node server.js

Then visit the following URL in your browser, which triggers the first message to the user’s phone, inviting them to generate a story. The JSON confirmation in your browser, along with the received RCS message on your phone, are signs that the system is working.

http://localhost:3000/send-story-request

Integrate Google Gemini

Now that we have the RCS messaging and webhook working, let's add Google Gemini to our storytelling service.

When you navigate to AI Studio), log in, and create a new chat, you can see ‘<>Get Code' at the top right and select your programming language of choice. Choose the model. I've used “Gemini 1.5 Flash Experimental,” but you can choose the one that makes the most sense for your project.

To learn more, visit the Gemini Developer API documentation page.

Install the Gemini SDK

npm install @google/generative-ai

Add your Gemini API key to .env.

GEMINI_API_KEY="YOUR_GEMINI_API_KEY"

Initialize Gemini

import { GoogleGenerativeAI } from "@google/generative-ai";

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

const geminiModel = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

Generate Stories with Gemini

With Gemini initialized, we update our/webhooks/inbound handler. When the user clicks "Generate Story," instead of replying "Hello world!", we now call geminiModel.generateContent with a specific prompt for a bedtime story.

The generated text is then sent back to the user using sendGeneratedStory. We also added handling for users who might type "Generate Story" manually.

The sendGeneratedStory function now takes the generated story text and uses RCSText to send it back as a regular RCS text message.

Test the Storytelling Service

To run the app, (re)start the server:

node server.js

Then visit the following URL in your browser: http://localhost:3000/send-story-request

From your device, you'll receive an RCS message. Tap the "Generate Story" to receive a Gemini-created bedtime story.

Conclusion

This tutorial showed you how to build a Gemini-powered storytelling service using Vonage’s RCS API. The last time I did anything related to RCS was in 2020. I participated in a workshop where each attendee was sent an RCS-enabled SIM card. It was nice to get back to working with RCS again, and I can't wait to write more blog posts about this.

Send and Receive RCS Suggested Replies with ASP.NET Core and Vonage

Benjamin Aronov — Fri, 15 Aug 2025 14:37:43 +0000

Rich Communication Services (RCS) represents the evolution of SMS: bringing branded, interactive, and app-like experiences into your native messaging app. With Vonage’s Messages API, you can deliver RCS messages with Suggested Replies: clickable options that improve engagement and streamline response handling.

In this tutorial, you’ll build an ASP.NET Core Web API from scratch that uses Vonage’s .NET SDK to send and receive RCS suggested reply messages. You’ll also learn how to configure the application, set up secure webhooks, and test the end-to-end flow using ngrok and your RCS-enabled phone.

TL;DR: View the full working code on GitHub

RCS message sent using the Vonage Messages API, prompting the user to select a preferred appointment time with suggested reply buttons.

Prerequisites

Before we get started, make sure you have:

.NET 9.0 SDK
Visual Studio 2022+ or VS Code
ngrok for local tunneling
A Vonage API account and a registered RBM agent. (See below)
An RCS-capable device for testing

Vonage API Account

Ready to start building?

Experience seamless connectivity, real-time messaging, and crystal-clear voice and video calls—all at your fingertips.

How to Contact Your Vonage Account Manager

In order to send and receive RCS capabilities in your Vonage application, you will need to have a registered Rich Business Messaging (RBM) agent and a phone with RCS capabilities.

Please contact our sales team if you do not have a managed account.

Understand the difference between RCS and RBM.

Create the ASP.NET Core Project

We’ll start by generating a minimal ASP.NET Core Web API using the built-in CLI template.

dotnet new web -n RcsSuggestedReplies
cd RcsSuggestedReplies

Add Required NuGet Packages

Install the necessary dependencies:

dotnet add package Vonage
dotnet add package Microsoft.AspNetCore.Mvc.NewtonsoftJson
dotnet add package Microsoft.AspNetCore.OpenApi
dotnet add package Swashbuckle.AspNetCore

Vonage: To use the Messages API
Newtonsoft.Json: JSON handling for API requests and responses
OpenApi: OpenAPI specification support for your endpoints
Swashbuckle: Swagger UI for testing your API in the browser

Create a Configuration Class

Create CustomConfiguration.cs in the root of your project and add:

namespace RcsSuggestedReplies;

public record CustomConfiguration
{
    public string SenderId { get; init; } = string.Empty;
}

This class uses C#'s record type to define a simple immutable configuration object. It allows you to bind strongly typed settings from appsettings.json, making your code cleaner and less error-prone than using raw strings everywhere.

Configure Application Settings

Create or update your appsettings.json file:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "Vonage": {
    "Application.Id": "YOUR_APPLICATION_ID",
    "Application.Key": "-----BEGIN PRIVATE KEY YOUR_PRIVATE_KEY"
  },
  "CustomConfiguration": {
    "SenderId": "YOUR_SENDER_ID"
  }
}

Your appsettings.json stores runtime configuration such as credentials, sender ID, and log levels. Keeping sensitive settings like these in a config file allows for the separation of code and environment-specific values.

Update these variables once you have completed the “Create and Configure Your Vonage Application” section below.

Create the Send Message Endpoint

Create a file named SendRcsMessageEndpoint.cs in the root of your project. This file defines the API logic for sending RCS messages. The SendRcsRequest record models the incoming JSON body, while the SendRcsMessageEndpoint handles the logic for sending the message via the Vonage Messages API. We separate the logic that builds the message payload into its own method, BuildRcsCustomRequest. This improves readability and makes the function easier to test or extend. For example, you could customize the suggestions dynamically in the future.

For now, this endpoint handles sending RCS messages with 3 hardcoded suggested replies for appointment scheduling.

using Microsoft.Extensions.Options;
using Vonage.Messages;
using Vonage.Messages.Rcs;

namespace RcsSuggestedReplies;

public record SendRcsRequest(string To);

public class SendRcsMessageEndpoint(IMessagesClient messagesClient, IOptions<CustomConfiguration> customConfiguration)
{
    public async Task<IResult> SendRcsMessage(SendRcsRequest request)
    {
        try
        {
            var response = await messagesClient.SendAsync(BuildRcsCustomRequest(request));
            Console.WriteLine($"Message sent: {response.MessageUuid}");
            return Results.Ok();
        }
        catch (Exception exception)
        {
            Console.WriteLine($"Error sending message: {exception.Message}");
            return Results.Problem(exception.Message);
        }
    }

    private RcsCustomRequest BuildRcsCustomRequest(SendRcsRequest sendRcsRequest)
    {
        return new RcsCustomRequest
        {
            From = customConfiguration.Value.SenderId,
            To = sendRcsRequest.To,
            Custom = new
            {
                ContentMessage = new
                {
                    Text = "What time works best for your appointment?",
                    Suggestions =
                        new[]
                        {
                            new
                            {
                                Reply = new
                                {
                                    Text = "9am",
                                    PostbackData = "time_9am"
                                }
                            },
                            new
                            {
                                Reply = new
                                {
                                    Text = "11am",
                                    PostbackData = "time_11am"
                                }
                            },
                            new
                            {
                                Reply = new
                                {
                                    Text = "2pm",
                                    PostbackData = "time_2pm"
                                }
                            }
                        }
                }
            }
        };
    }
}

Create the Receive Message Endpoint

Create another file called ReceiveRcsInboundEndpoint.cs in the root of your project.This class handles inbound webhook messages from Vonage. It verifies the request's authenticity using JWT validation and sends a confirmation reply when the user selects one of the suggested responses. JWT signature verification ensures you're not processing spoofed or malicious messages, and that incoming requests are indeed coming from Vonage.After parsing the user's reply, we send a friendly confirmation message. Keeping this logic in a separate method keeps the ReceiveRcsInbound function focused and easier to read.

using Microsoft.Extensions.Options;
using Vonage;
using Vonage.Messages;
using Vonage.Messages.Rcs;
using Vonage.Messages.Webhooks;
using Vonage.Request;

namespace RcsSuggestedReplies;

public class ReceiveRcsInboundEndpoint(IMessagesClient messagesClient, IOptions<CustomConfiguration> customConfiguration, Credentials credentials)
{
    public async Task<IResult> ReceiveRcsInbound(HttpContext httpContext, MessageWebhookResponse messageWebhookResponse)
    {
        var token = httpContext.Request.Headers.Authorization.ToString().Split(' ')[1];
        if (!Jwt.VerifySignature(token, credentials.ApplicationKey))
        {
            return Results.Unauthorized();
        }

        if (messageWebhookResponse is {Channel: "rcs", MessageType: "reply"})
        {
            var userSelection = messageWebhookResponse.Reply?.ToString();
            Console.WriteLine($"User {messageWebhookResponse.From} select: {userSelection}");
            try
            {
                var response =
                    await messagesClient.SendAsync(BuildConfirmationMessage(messageWebhookResponse, userSelection));
                Console.WriteLine($"Confirmation sent: {response.MessageUuid}");
            }
            catch (Exception exception)
            {
                Console.WriteLine($"Error sending confirmation: {exception.Message}");
            }
        }

        return Results.Ok();
    }

    RcsTextRequest BuildConfirmationMessage(MessageWebhookResponse messageWebhookResponse1, string? s) =>
        new()
        {
            To = messageWebhookResponse1.From,
            From = customConfiguration.Value.SenderId,
            Text = $"{s} is a great choice!",
        };
}

This endpoint handles incoming RCS messages, verifies their authenticity, and sends confirmation responses.

Configure the Program.cs File

Update your Program.cs file to the following.

Here, we configure dependency injection, which is a core part of ASP.NET Core's design. We register the Vonage client and our custom endpoints so they can be injected where needed, making the code more modular.

using RcsSuggestedReplies;
using Vonage.Extensions;
using Vonage.Messages.Webhooks;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Register Vonage and application services
builder.Services.AddVonageClientScoped(builder.Configuration);
builder.Services.Configure<CustomConfiguration>(builder.Configuration.GetSection("CustomConfiguration"));
builder.Services.AddScoped<SendRcsMessageEndpoint>();
builder.Services.AddScoped<ReceiveRcsInboundEndpoint>();

var app = builder.Build();

// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.MapControllers();

// Define our API endpoints
app.MapPost("send-rcs",
    async (SendRcsMessageEndpoint endpoint, SendRcsRequest request) => await endpoint.SendRcsMessage(request));
app.MapPost("inbound-rcs",
    async (ReceiveRcsInboundEndpoint endpoint, HttpContext context, MessageWebhookResponse inbound) =>
        await endpoint.ReceiveRcsInbound(context, inbound));

app.Run();

How to Expose Your Server with ngrok

To receive webhooks from Vonage, your local server must be accessible over the internet. Use ngrok to expose your ASP.NET Core server, which will run on port 5000:

ngrok http 5000

Note the HTTPS URL provided by ngrok (e.g., https://your-ngrok-subdomain.ngrok.io).

You can read more about testing with ngrok in our developer portal tools.

Your application might be running on a different port. You can check in launchSettings.json to confirm.

Create and Configure Your Vonage Application

Now that your ASP.NET App is ready, you’ll also need to create and set up your Vonage Application. First, create your app in the Vonage Dashboard. Give the app a name and turn on the Messages capability.

To create an application, go to the Create an Application page on the Vonage Dashboard, and define a Name for your Application.
If needed, click on "generate public and private key". A private key (.key file) will be generated. Download and store it securely. This key is needed for authentication when making API requests. Note: Private keys will not work unless the application is saved.
Choose the capabilities you need (e.g., Voice, Messages, RTC, etc.) and provide the required webhooks (e.g., event URLs, answer URLs, or inbound message URLs). These will be described in the tutorial.
To save and deploy, click "Generate new application" to finalize the setup. Your application is now ready to use with Vonage APIs.

In your Vonage application settings:

Set the Inbound URL to https://YOUR_NGROK_URL/inbound-rcs.
Set the Status URL to https://example.com/rcs-status. \ ** Message statuses will be covered in a future article.
Generate a public and private key by clicking the button. Ensure to move your private.key file to the project root directory (RcsSuggestedReplies).
Save the changes.

Then link your RCS Agent by clicking the “Link external accounts” tab:

Dashboard view showing the Vonage-ASP-NET-RCS application linked to the Vonage RoR RCS external account, with voice and message capabilities enabled.

Update Your Vonage Credentials

Replace the placeholder values in appsettings.json with your actual Vonage credentials:

"Vonage": {
  "Application.Id": "YOUR_ACTUAL_APPLICATION_ID",
  "Application.Key": "YOUR_PRIVATE_KEY"
},
"CustomConfiguration": {
  "SenderId": "YOUR_ACTUAL_SENDER_ID"
}

Run Your Application and Test

Start your application:

dotnet run

Your RCS messaging application is now running! You can use a tool like Postman or cURL to send a POST request to your /send-rcs endpoint with the recipient's phone number:

curl -X POST https://**YOUR_NGROK_URL***/send-rcs \
  -H "Content-Type: application/json" \
  -d '{
    "to": "**YOUR_RCS_TEST_NUMBER"
}'

On the recipient's RCS-enabled device, the message with suggested replies should appear.

When the recipient selects a suggested reply, your /inbound-rcs endpoint will handle the response, and a confirmation message will be sent back.

RCS conversation where a user selects a time from suggested replies and receives a confirmation message, powered by the Vonage Messages API.

Conclusion

You’ve now built a working ASP.NET Core application that can send and receive RCS Suggested Replies using the Vonage Messages API. This simple UI improvement, letting users tap a response instead of typing, can dramatically enhance how users interact with your app.

With webhook verification, structured response handling, and confirmation messages, this template gives you a solid foundation to expand on. You try adding RCS Cards, storing replies in a database, or dynamically generating suggested replies from user history

If you run into any questions or have ideas for what you'd like to build next, come join the conversation in our Vonage Community Slack or reach out onX (formerly Twitter). We’d love to see what you build!