DEV Community: Vonage Developers

Seeking Validation: Data Validation in Python with Pydantic and Vonage Verify

Liz Acosta — Thu, 06 Aug 2026 19:59:45 +0000

This blog post provides an introduction to Pydantic, the popular data validation library for Python. It includes a demonstration of the value Pydantic provides using the Vonage Verify API.

Introduction

What is Duck-typing in Python?

To understand why Pydantic is such a useful library, it is important to first understand how typing works in Python. In programming, “typing” refers to systems of classifying and categorizing data. How data is typed determines how it can be acted upon – for instance, you can’t add the word “two” with the number 2.

Python owes a lot of its success and popularity to its flexibility around typing. Unlike most compiled languages that require you to explicitly declare types, Python implements something called duck-typing. Duck-typing is a dynamic type system that assumes that if an object “walks like a duck and quacks like a duck, then it must be a duck.”

More specifically, according to the Python documentation, duck-typing is:

“A programming style which does not look at an object’s type to determine if it has the right interface; instead, the method or attribute is simply called or used … By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution. Duck-typing avoids tests using type() or isinstance().”

In practice, an example of this is Python’s len function. len() returns “the length (the number of items) of an object.” In the code below, observe how len() successfully produces an output regardless of the type of object it is called with:

>>> example_1 = "Hello? World!"
>>> type(example_1)
<class 'str'>

>>> example_2 = [1, 3, 5, 8]
>>> type(example_2)
<class 'list'>

>>> example_3 = {"hello" : "world", "foo": "bar"}
>>> type(example_3)
<class 'dict'>

>>> len(example_1)
13                                 # 13 letters in "Hello? World!"

>>> len(example_2)
4                                  # 4 items in the list

>>> len(example_3)
2                                  # 2 key-value pairs in the dictionary

In an example of dynamic typing that more likely represents what you might see in Python in the real world, the code below defines three different classes of dog breeds that can each bark():

class Pug:
    def bark(self):
        print("The pug goes arf arf!")

class LabradorRetriever:
    def bark(self):
        print("The labrador retriever goes arf arf!")

class Wolfhound:
    def bark(self):
        print("The wolfhound goes arf arf!")

You can instantiate one of each kind of dog breed and call bark() on every one of them without error because they all possess the same interface. Because of duck-typing, the following code runs successfully:

>>> pets = [Pug(), LabradorRetriever(), Wolfhound()]

>>> for pet in pets:
...     pet.bark()

The pug goes arf arf!
The labrador retriever goes arf arf!
The wolfhound goes arf arf!

pet can be of class Pug, LabradorRetriever, or Wolfhound and Python will still call the bark function without error.

This can be convenient, and in many contexts, it's exactly what you want. For scripting, data science, and exploratory work, Python's dynamic typing is a feature, not a bug. Duck-typing lets you iterate quickly without the overhead of rigid type declarations. This is a big part of why Python has become the dominant language for AI and data science workflows.

However, the calculus changes significantly in production backend code. A Flask or Django application with no declared types can introduce maintenance and debugging friction. With Python’s duck-typing, type mismatches surface as cryptic runtime errors rather than clear, early failures. The problem becomes even more acute when applications rely on specific types of data in order to run as intended, such as when working with APIs, processing configuration files, or handling user input.

For instance, if you defined the following class:

class Sphynx:
    def meow(self):
        print("The sphynx goes meow meow!")

And then updated the example code to include an instance of Sphynx in the list of pets to iterate through, you will run into an error:

>>> pets = [Pug(), LabradorRetriever(), Sphynx()]

>>> for pet in pets:
...     pet.bark()
...     

The pug goes arf arf!
The labrador retriever goes arf arf!
Traceback (most recent call last):
  File "<python-input-74>", line 2, in <module>
    pet.bark()
    ^^^^^^^^
AttributeError: 'Sphynx' object has no attribute 'bark'

As this example illustrates, within certain contexts, the flexibility of duck-typing becomes a liability. For example, a wrong type passed to an API call might not fail until the request is already in flight, potentially costing you money on a chargeable call that was always destined to fail.

One way to address some of the issues that arise with dynamic typing is with Python’s type hints.

What Are Type Annotations?

A type hint is a code annotation that “specifies the expected type for a variable, a class attribute, or a function parameter or return value.” Therefore, a type annotation refers to how type hints are used syntactically in Python.

The following code is a basic example of using type annotation:

def greeting(name: str) -> str:
    return 'Hello ' + name

In this example, the type hint is str and the type annotation is the name: str and -> str syntax. The type annotation tells us that the expected type of the parameter name is a string and that the expected return type of the function greeting is a string.

Adding type annotations to the example Pug class could look like this:

class Pug:
    def init(self, name: str) -> None:
        self.name: str = name

    def bark(self) -> None:
        print(f"The pug {self.name} goes arf arf!")

And if we update our pets iteration code to include type annotation, it could look like this:

def make_dogs_bark(pets: List[Pug | LabradorRetriever | Wolfhound ]) -> None:
    for pet in pets:
        pet.bark() 

make_dogs_bark([Pug(), LabradorRetriever(), Sphynx()])

As the name suggests, these are merely type hints. They help make the code more readable and maintainable, but they are not enforced by the Python interpreter. We could use an additional tool like mypy to check the types and receive an error like this:

error: List item 2 has incompatible type "Sphynx"; expected "Pug | LabradorRetriever | Wolfhound"  [list-item]

This would have to be performed as an additional step – nothing is preventing this code from executing and generating an error at runtime.

Seeking Validation

To prevent errors at runtime – such as an API call with incorrect data – you could validate the data in your request before sending it. In the example code, we could define some sort of validation to ensure each item in the list pets can bark():

def make_dogs_bark_safely(dogs):
    """Manual validation in the function"""
    for dog in dogs:
        if not hasattr(dog, 'bark') or not callable(getattr(dog, 'bark')):
            raise TypeError(f"Invalid dog type: {type(dog).__name__}")
        dog.bark()

# Now this fails immediately with a clear message:
pets = [Pug(), Sphynx()]

make_dogs_bark_safely(pets)
# TypeError: Invalid dog type: Sphynx

In addition to quickly becoming tedious and unwieldy, this pattern undermines some of the conveniences of Python’s inherent dynamic-typing while also missing out on some of the benefits of type annotation.

Fortunately, Pydantic provides data validation while maintaining the ease and speed of the language using syntax already baked in.

What is Pydantic?

Pydantic is a data validation library for Python offering the following benefits:

Leverages type hints to control schema validation and serialization.
Uses Rust under the hood for its core validation logic resulting in minimal impact on performance.
Supports validation of many standard library types including dataclass and TypedDict.
Works in either strict or lax mode when handling types.
Can output JSON Schema out of the box, which enables seamless integration with other tools.
Automatically generates documentation from models.

Let’s take a closer look at how these features come together in practice to provide reliable, efficient data validation in harmony with Python syntax and structure.

Core Validation Features of Pydantic

It is important to understand that in Pydantic, “validation” refers to “the process of instantiating a model (or other type) that adheres to specified types and constraints.” In other words, Pydantic’s validation applies to the output of a model instantiation, not the input data. As such, Pydantic raises a ValidationError when data cannot be successfully parsed into an instance of a model.

BaseModel

BaseModel lies at the heart of Pydantic. You inherit from it to define data models with type-annotated fields. One of the primary methods to define schema in Pydantic is via models. When you instantiate a BaseModel Pydantic automatically validates the data against the defined schema.

Using Pydantic, the Pug class now looks like this:

class Pug(BaseModel):
    name: str
    age: int
    color: str = "fawn"

    def bark(self):
        print(f"The pug {self.name} goes arf arf!")

If you were to instantiate Pug, Pydantic would make sure the resulting object has a name of type string, an age of type integer, and a color of type string with fawn as the default.

Type Hints and Required Fields

Type annotations control schema validation and serialization. Fields declared with just a type annotation are required; fields with defaults are optional.

In the Pug example, the name field is annotated with str meaning any string will suffice, but a string must be provided; the same applies to the age field. The color field, however, provides a default of fawn and thus not required when instantiating a Pug.

Type Coercion

Pydantic can be used in either strict or the default lax mode. In lax mode, the library will automatically convert data to the type defined in the schema.

So, for example, if we supplied "5" as a string for the age of a Pug, Pydantic would convert it to an integer.

Field Configuration

The Field function enables the addition of metadata and constraints for schema fields.

Some commonly used parameters are:

Constraints such as greater than gt) and greater than or equal to ge), and min_length and max_length
Aliases for mapping input and output field names using alias, validation_alias, and serialization_alias)
Strict mode to prevent type coercion on certain fields strict=True)

To enforce constraints on the name field for Pug, you would use the following code:

class Pug(BaseModel):
    name: str = Field(..., min_length=1, description="The pug's name")
    age: int
    color: str = "fawn"

    def bark(self):
        print(f"The pug {self.name} goes arf arf!")

Serialization

Pydantic model instances can be converted to dictionaries without writing any additional serialization code by using model_dump(). This makes it straightforward to serialize to JSON or other formats to use elsewhere in a project. For example, model_dump_json() serializes a model directly to JSON.

Below is an example of creating an instance of Pug and then serializing it using one of Pydantic’s built-in functions:

matty_pug = Pug(name="Matty", age=14)

result = matty_pug.model_dump()

print(result)

Which would produce the following output:

{'name': 'Matty', 'age': 14, 'color': fawn}

What is a Real-World Use Case of Pydantic?

Since its inception, Pydantic has quickly become one of the most widely used data validation libraries for Python. Approximately 8,000 packages on PyPI use Pydantic including (and most famously) FastAPI, huggingface, Django Ninja, SQLModel, LangChain, and Vonage.

In November 2024, Vonage released a full, ground-up rewrite of the Vonage Python SDK. It’s not always easy to start over completely, but the rewrite was an opportunity to make some critical structural enhancements and improve user interaction with the SDK.

Among some of the changes included in this initiative was the addition of Pydantic to the SDK in order to facilitate calling Vonage APIs and parsing the responses.

Check out the video below to hear from one of our developers who works on the Python SDK and see what he has to say about using Pydantic.

How the Vonage Python SDK Uses Pydantic Models

Using Pydantic models to form requests enforces correct typing and makes it easier to pass the right objects to the Vonage APIs. With version 4 of the SDK, API responses are now deserialized into fully documented Pydantic models, which provide more consistency than returning dictionaries like in the prior version. Additionally, you can still turn Pydantic models into dictionaries or JSON strings with model.model_dump and model.model_dump_json respectively.

For this demonstration, we’ll take a look at the Vonage Verify API and how it is modeled using Pydantic in the SDK.

What is the Vonage Verify API?

The Verify API is Vonage’s next generation two-factor authentication (2FA) product. With Verify API, you can authenticate your users and prevent fraud with a simple, easy-to-use API that abstracts away the complexity of 2FA at a global scale.

It expands on traditional authentication methods by supporting a wider range of channels, including over-the-top (OTT) channels like WhatsApp, as well as SMS, voice, and email. The API supports both JSON web tokens (JWT) and Basic authentication. Basic authentication is easier to get started with, but does not support advanced features such as ACLs. You can use either JWT or Basic authentication, but not both at the same time. You can read more about authentication in the documentation.

At a high level, the Verify API follows this workflow:

An end-user triggers a 2FA request in an application
On the backend, this 2FA request initiates a Verify API request
The Verify API sends a one time password (OTP) to the end-user via the configured channel (SMS, voice, WhatsApp, or email)
The end-user provides the OTP to the application
This initiates a Verify request to check the OTP provided by the end-user against the OTP generated by the API
The result of that check then determines what happens next (the end-user is authenticated, etc)

A diagram of the Verify V2 Request with Summary Callbacks.
A typical initially verification request includes the following payload:

{

   "locale": "es-es",
   "channel_timeout": 180,
   "client_ref": "myPersonalRef",
   "code_length": 4,
   "code": "e4dR1Qz",
   "brand": "ACME",
   "template_id": "4ed3027d-8762-44a0-aa3f-c393717413a4",
   "workflow": [
      {
         "channel": "sms",
         "to": "44770090000"
      },
      {
         "channel": "voice",
         "to": "44770090000"
      }
   ]
}

Which is explained more in-depth below:

Key	Description	Required or optional
locale	The locale to use for the verification message	Optional, defaults to `en-us`
channel_timeout	The time in seconds to wait between attempts to deliver the verification code	Optional, defaults to 180 seconds
client_ref	A unique identifier for the verification request	Optional
code_length	The length of the verification code to generate	Optional, defaults to 4
code	An optional alphanumeric custom code to use, if you don't want Vonage to generate the code	Optional
brand	The name of the company or service that is sending the verification request – this will appear in the body of the SMS or TTS message	Required, maximum length of 16 characters
template_id	A custom template ID to use – works only when `channel` is `sms` or `rcs`	Optional
workflow	The list of channels to use in the verification workflow, used in the order they are listed	Required, maximum length of 3 items

To learn more about the API and how it works, refer to the Vonage Verify documentation.

A successful request responds with a 202 OK to indicate that the verification request has been initiated. The response will also include a request_id which is required to complete the verification process:

{"request_id": "c11236f4-00bf-4b89-84ba-88b25df97315",}

At the same time, Vonage sends an OTP to the end-user via the configured workflow, attempting each channel in the order in which they are defined.

Once the end-user receives and provides the OTP to the application, another request to the Verify endpoint with the request_id as a path parameter https://api.nexmo.com/v2/verify/:request_id) and the OTP in the request body for the code key.

If the code provided matches the code generated and sent by Vonage, a 200 OK response is returned along with a "status": "complete" .

Demonstration: How Does the Verify API Use Pydantic?

The Vonage Python SDK facilitates implementing the Vonage APIs within a Python application. Introducing Pydantic to the SDK makes it even easier to use the APIs. With Pydantic, rather than discovering an error after making an API call and incurring any charges, request models are validated before execution without the need for additional code to do so.

The demonstration for this blog post is a minimal 2FA application using the FastAPI framework. The end-user navigates to a web page where they enter their email address. Using the Verify API, the application then generates an OTP code which is sent to the end-user provided email address. The end-user provides that code to the application and if the Verify check is successful, the end-user is rewarded with an animated gif.

If you want, you can go straight to the code and use the README to get it up and running.

The following code is where the Verify request is created:

   verify_request = VerifyRequest(
        brand=settings.verify_brand_name,
        workflow=[
            EmailChannel(to=email),
        ],
        channel_timeout=60,
        code_length=5,
    )

If we step into the VerifyRequest object, we find a Pydantic model:

class VerifyRequest(BaseModel):
    brand: str = Field(..., min_length=1, max_length=16)
    workflow: list[
        Union[
            SilentAuthChannel,
            SmsChannel,
            WhatsappChannel,
            VoiceChannel,
            EmailChannel,
        ]
    ]
    locale: Optional[Locale] = None
    channel_timeout: Optional[int] = Field(None, ge=15, le=900)
    client_ref: Optional[str] = Field(None, min_length=1, max_length=16)
    code_length: Optional[int] = Field(None, ge=4, le=10)
    code: Optional[str] = Field(None, pattern=r'^[a-zA-Z0-9]{4,10}$')

    @model_validator(mode='after')
    def check_silent_auth_first_if_present(self):
        if len(self.workflow) > 1:
            for i in range(1, len(self.workflow)):
                if isinstance(self.workflow[i], SilentAuthChannel):
                    raise VerifyError(
                        'If using Silent Authentication, it must be the first channel in the "workflow" list.'
                    )
        return self

The schema translates the API request into types using Python annotation and the Field function to define constraints. The workflow field defines a Union type of other modeled types, demonstrating how types can be nested.

Lastly, the model_validator(mode='after') is a Pydantic decorator that provides additional configuration for how the VerifyRequest model is to be validated. In this case, the def check_silent_auth_first_if_present method is executed after the VerifyRequest model has been constructed to ensure that if SilentAuthChannel is included in the workflow, it must be listed first.

Verification By Email

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.

After generating and activating a virtual environment, and installing the required dependencies per the README, you can run the demonstration application with the following:

fastapi dev

This will spin up a web app on http://127.0.0.1:8000:

A screenshot of the index page inviting the end-user to enter their email address to try out the Vonage Verify API.

Clicking on Submit verification code triggers the Verify API workflow. You should be directed to a web page where you can enter the code sent to the email address you provided:

A screenshot of the verification page inviting the end-user to enter the code they received in their email.

Entering the correct code here will direct you to a success page.

Under the hood, the code makes use of the Pydantic models in the SDK to ensure the Verify request is correctly formed and handled.

Verification Without Validation: Testing Without Pydantic

Now let’s take a look at how Pydantic facilitates the Verify API.

In the following code, we have two functions that perform the same task: make a request to the /verify endpoint. One of the functions creates the request body manually and the other one uses Pydantic.

Using a manually created request body:

def without_pydantic(request_payload):

    jwt_client = JwtClient(
        application_id=settings.vonage_application_id,
        private_key=settings.vonage_private_key_path,
    )

    jwt_token = jwt_client.generate_application_jwt()

    payload = {
        "brand": request_payload["brand"],
        "workflow": [
            {
                "channel": "email",
                "to": request_payload["to_email"],
            }
        ],
        "channel_timeout": request_payload["channel_timeout"],
        "code_length": request_payload["code_length"],
    }

    response = requests.post(
        "https://api.nexmo.com/v2/verify",
        headers={
            "Authorization": f"Bearer {jwt_token.decode()}",
            "Content-Type": "application/json",
        },
        json=payload,
    )

    return response

Using Pydantic:


def with_pydantic(request_payload):

    client = Vonage(
        Auth(
            application_id=settings.vonage_application_id,
            private_key=settings.vonage_private_key_path,
        )
    )

    verify_request = VerifyRequest(
        brand=request_payload["brand"],
        workflow=[EmailChannel(to=request_payload["to_email"])],
        channel_timeout=request_payload["channel_timeout"],
        code_length=request_payload["code_length"],
    )

    client.verify.start_verification(verify_request)

    last_response = client.http_client.last_response

    return last_response

The code then uses unittest to test the functions with test_data that violates the API parameters:

   test_data = {
        "brand": 12345,
        "to_email": 678910,
        "channel_timeout": "sixty",
        "code_length": "five",
    }

Run the tests with the following command:

python -m unittest -v

Running the tests should result in two different outcomes: an error and a failure.

The test for the function that uses Pydantic should return this error:

pydantic_core._pydantic_core.ValidationError: 1 validation error for EmailChannel
to
  Input should be a valid string [type=string_type, input_value=678910, input_type=int]
    For further information visit https://errors.pydantic.dev/2.13/v/string_type

What’s important to note here is that the test did not fail – instead it errored out because Pydantic caught an incorrect data type before the request was made. Moreover, the error message itself provides useful information for debugging instead of a general type error message. Not only do we know that the data type provided did not meet the model requirements, we also know what the expected type is as well as the type that was passed in:

Input should be a valid string [type=string_type, input_value=678910, input_type=int]

The test for the function without Pydantic returns a failure:

AssertionError: 422 != 202 : Test without Pydantic failed with: 422. Expected: 202

This means that the request was made and, as the API is defined, returned a 422 for invalid parameters.

In this limited test scenario, one bad API call is negligible – on a broader scale, this can be an expensive mistake. Using Pydantic to validate a request model before making the API call helps minimize wasted API calls, enables more graceful error handling, and facilitates developers.

In Summary

Pydantic offers a powerful, performant solution for data validation in Python, helping developers move beyond the potential pitfalls of duck-typing. By defining schema, constraints, and validation rules with Pydantic models, you can ensure data integrity and catch errors before API requests are ever sent. This saves you from costly invalid API calls and makes error handling more graceful.

As demonstrated with the Vonage Python SDK's integration with the Verify API, Pydantic makes it straightforward to work with complex, nested request models while keeping your code readable and maintainable. With version 4 of the SDK, API responses are deserialized into fully documented Pydantic models, giving you more consistency, better tooling support, and a cleaner developer experience overall.

The Vonage Dev Discussion: Everyone loves Pydantic

Liz Acosta — Thu, 30 Jul 2026 18:03:50 +0000

We’re back with another Vonage Dev Discussion!

If you’re a Python developer, chances are you’ve heard of Pydantic.

Pydantic is a data validation library for Python. Since its release in 2017, Pydantic has quickly become one of the most popular dependencies in software, reaching 10 billion downloads in 2026 🤯

But why is Pydantic so popular? We could name a few reasons – one of them being that it helped improve our Python SDK when we did a rewrite of it a couple of years ago.

But what do you think? 🤔

Why do you use Pydantic? What are some good use cases for it? How would you explain Pydantic to a beginner?

(By the way, if you’re totally new to Pydantic, we've got this gentle introduction to help you out!)

Let us know your thoughts about Pydantic in the comments below! 🐍👇

Send Personalized SMS Messages from a Spreadsheet Using Claude Cowork and Vonage

Michael Crump — Tue, 14 Jul 2026 19:25:48 +0000

AI assistants are no longer just answering questions - they're taking action. Claude Cowork is a great example of this shift: it can access your local environment, read and write files, and automate tasks that would otherwise eat up your time. Pair it with the Vonage Tooling MCP Server, and you can send real SMS messages to real people, all from a plain-English prompt.

In this tutorial, we'll walk through exactly how to do that. We'll use Claude Cowork to read customer feedback from a local spreadsheet, generate personalized responses using AI, and automatically send each one as an SMS via Vonage.

🎬 Watch the full video walkthrough here: Send a Text in Claude Cowork

What You'll Build

Imagine you run a restaurant. After each visit, customers text you their feedback, and you save their name, phone number, feedback, and a status column (Pending / Sent) in a spreadsheet called restaurant_feedback.xlsx.

Using Claude Cowork, you'll create a task that:

Reads the spreadsheet and finds all rows with a Pending status
Uses AI to determine the sentiment of each message and generate a personalized response
Sends each response as an SMS using the Vonage Tooling MCP Server
Updates the status column to Sent

Prerequisites

Before you get started, make sure you have:

Claude Desktop (latest version)
Node.js installed
A Vonage Developer account (free to sign up)

Step 1: Install the Vonage Tooling MCP Server

Open Claude Desktop, click the Claude menu in your computer's menu bar, then go to Settings → Developer → Edit Config.

This opens (or creates) a file called claude_desktop_config.json:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Paste in the following configuration:

{
  "mcpServers": {
    "vonage-mcp-server-api-bindings": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@vonage/vonage-mcp-server-api-bindings"
      ],
      "env": {
        "VONAGE_APPLICATION_ID": "<YOUR_VONAGE_APPLICATION_ID>",
        "VONAGE_PRIVATE_KEY64": "<YOUR_VONAGE_PRIVATE_KEY64>",
        "VONAGE_API_KEY": "<YOUR_VONAGE_API_KEY>",
        "VONAGE_API_SECRET": "<YOUR_VONAGE_API_SECRET>",
        "VONAGE_VIRTUAL_NUMBER": "<YOUR_VONAGE_VIRTUAL_NUMBER>",
        "VONAGE_WHATSAPP_NUMBER": "<YOUR_VONAGE_WHATSAPP_NUMBER>",
        "RCS_SENDER_ID": "<YOUR_RCS_SENDER_ID>"
      }
    }
  }
}

Step 2: Get Your Vonage Credentials

API Key & Secret
From your homepage, click API Secret Management to copy your API key and secret.

Application ID & Private Key

Go to Build → Applications → Create a new application
Give it a name and click Generate public and private key - the private key will download automatically
Under Capabilities, toggle on Messages
Click Generate new application to get your Application ID

Before pasting the private key into the config file, you'll need to base64 encode it. Use the encoder linked in the Vonage MCP Server readme or run:

base64 -i private.key

Virtual Number
Go to Build → Phone Numbers to find or purchase a virtual number. Link it to your application, and if you're in the US, make sure it's 10DLC compliant.

Once your config is saved, restart Claude Desktop. To confirm the server is connected, open a new chat and ask:

"Do you have access to Vonage's tooling server?"

Claude should confirm and list its available capabilities.

Step 3: Set Up Your Spreadsheet

For this demo, create a file called restaurant_feedback.xlsx in a folder called operations. It should have columns for:

Name	Phone	Feedback	Response	Status
Jane	+1...	"Great food!"		Pending
Bob	+1...	"Service was slow."		Pending

The Status column is what Claude will use to know which messages need to be addressed.

Step 4: Create a `claude.md` Instructions File

To avoid re-prompting Claude every time, create a file called claude.md in your operations folder. This is a plain-text markdown file where you store persistent instructions for Claude Cowork.

Here's an example of what to put in it:

## Restaurant Feedback Automation

When prompted with `generate_responses`:
- Read `restaurant_feedback.xlsx`
- Find all rows where Status = "Pending"
- Analyze the sentiment of each feedback message
- If positive: set Response to "We're glad you had a positive experience!"
- If negative: set Response to "We're sorry you had a negative experience!"
- Save the responses back to the spreadsheet

When prompted with `send_responses`:
- Read `restaurant_feedback.xlsx`
- For each row where Status = "Pending" and a Response exists:
  - Send the Response as an SMS to the customer's Phone number using the Vonage Tooling MCP Server
  - Update the Status to "Sent"

💡 Tip: You can ask Claude itself to help you write your claude.md file!

Step 5: Run It in Claude Cowork

Switch to Cowork mode in Claude Desktop. Create a new task and click "Work in a project" in the bottom-left corner of the prompt box. Select your operations folder.

Now run:

generate_responses

Claude will scan the spreadsheet, find the Pending rows, analyze sentiment, and write personalized responses back to the file.

When you're ready to send, run:

send_responses

Claude will use the Vonage Tooling MCP Server to send each SMS and update the status to Sent. Open your spreadsheet to confirm - the status column should now show Sent for each row.

What's Next?

This is just the beginning of what you can do with the Vonage Tooling MCP Server. Beyond SMS, you can:

Send WhatsApp or RCS messages by populating the corresponding fields in your config
Trigger automated voice calls instead of (or in addition to) texts
Track delivery status by saving read/delivered receipts back to your spreadsheet
Build multi-channel workflows that escalate from SMS to voice if a message goes unread

Resources

Have questions or something cool you built with this? Drop a comment below or connect with us on the Vonage Community Slack. We'd love to see what you create!

The Vonage Dev Discussion: How AI is transforming software development

Liz Acosta — Thu, 21 May 2026 19:25:53 +0000

Welcome back to the Vonage Dev Discussion! Recently, members of the Vonage Developer Relations team met up in New York to create content, make plans, and hang out. We even got the chance to record at a super cool studio in the Big Apple!

We took the opportunity to chat about something that’s been on everybody’s mind: artificial intelligence. We talked about how AI is impacting developer relations and tech in general.

We have a second part coming out soon, but in the meantime, we want to know: What’s one thing that AI helps you with? Where do you still prefer to do the work yourself?

We’d love to hear your thoughts in the comments below 🤖👇

The Vonage Dev Discussion: Defining what an API is

Liz Acosta — Wed, 13 May 2026 20:49:48 +0000

This week we kicked off the first in a series of office hours. Our office hours are a judgment-free space for developers to come and ask questions about using Vonage – and get an answer live from an actual human!

Being able to ask questions without fear of judgment is so important for beginner engineers and being able to answer those questions is equally important for senior engineers. Have you ever noticed how explaining something makes you really think about what you actually know or don’t know? It's a really good feedback loop!

So here’s a chance to test your knowledge: How would you explain what an API is to someone? What are some examples of APIs you use?

And if you’re new to APIs, here’s a walkthrough of how to use one from our office hours:

And don’t worry! If you run into any issues, we can help you out in our next office hours. Check out the office hours schedule and make sure to subscribe to our YouTube channel for future streams and videos ♥️🤓

Let's keep the API conversation going in the comments below! 💻 👇

The Vonage Dev Discussion: Making mistakes

Liz Acosta — Fri, 24 Apr 2026 20:01:26 +0000

Nobody is perfect! Even the most seasoned developers have made mistakes – it’s all just part of the learning process.

One mistake that is so common in software development is accidentally pushing secrets to a public repository 🙈🙉🙊

Fortunately, there are lots of different guardrails you can put in place to help prevent the exposure of sensitive information like API keys, and we’ve covered a few of them in these posts about environment variables.

But we’re curious: What are some mistakes you’ve made as a developer? What did you learn from those mistakes?

Share your wisdom in the comments below! 🙏👇

The Vonage Dev Discussion: Builder pattern

Liz Acosta — Tue, 07 Apr 2026 16:48:06 +0000

Have you ever heard of the builder pattern? 🧰🏘️

In software development, the builder pattern is a creational design pattern that lets you construct complex objects step by step. It is especially helpful when you have complex classes of objects that can be extended in many different ways.

In this video, our developer advocates Guillaume Faas and Jeremy Foster discuss the builder pattern and how it is implemented in the Vonage .NET SDK.

The builder pattern sparks debate in the dev community. Some swear by it, others see it as over-engineering. We want to know: What's your take?

Do you use the builder pattern?

How do you use it in your own work?

How would you explain it to someone?

Share your experience and knowledge of the builder pattern in the comments below!

⚒️👇

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.

DEV Community: Vonage Developers

Seeking Validation: Data Validation in Python with Pydantic and Vonage Verify

Introduction

What is Duck-typing in Python?

What Are Type Annotations?

Seeking Validation

What is Pydantic?

Core Validation Features of Pydantic

Field Configuration

Serialization

What is a Real-World Use Case of Pydantic?

How the Vonage Python SDK Uses Pydantic Models

What is the Vonage Verify API?

Demonstration: How Does the Verify API Use Pydantic?

Verification By Email

Verification Without Validation: Testing Without Pydantic

In Summary

Further Reading and References

The Vonage Dev Discussion: Everyone loves Pydantic

Send Personalized SMS Messages from a Spreadsheet Using Claude Cowork and Vonage

What You'll Build

Prerequisites

Step 1: Install the Vonage Tooling MCP Server

Step 2: Get Your Vonage Credentials

Step 3: Set Up Your Spreadsheet

Step 4: Create a claude.md Instructions File

Step 5: Run It in Claude Cowork

What's Next?

Resources

The Vonage Dev Discussion: How AI is transforming software development

The Vonage Dev Discussion: Defining what an API is

The Vonage Dev Discussion: Making mistakes

The Vonage Dev Discussion: Builder pattern

The Vonage Dev Discussion: Open source

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

The Vonage Dev Discussion: Music

🎁 Holiday Update: MCP Tooling Server + LinkedIn Page

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

Step 4: Create a `claude.md` Instructions File