Pydantic: Zod for Python

This is the second post of my TypeScript-to-Python journey. This time I learnt about Pydantic, a runtime validation library for Python. It is like Zod, but for Python.

For context, I am a full-stack developer from India, expanding into AI engineering. Almost all the GenAI roles I am seeing require Python. My plan is very simple: learn what is needed to build, rather than going through yet another course.

This week's topic is: how do you trust the JSON an LLM returns? In TypeScript we have Zod or similar runtime validation libraries. We define the schema and call .parse.

Similarly, in Python we have Pydantic. The thing which surprised me was the mapping of the mental model. It is nearly one-to-one:

// TypeScript + Zod
import { z } from "zod";

const ContactInfo = z.object({
  name: z.string(),
  email: z.string(),
  planInterest: z.string(),
  demoRequested: z.boolean(),
});

type ContactInfo = z.infer<typeof ContactInfo>;

const contact = ContactInfo.parse(untrustedJson);

# Python + Pydantic
from pydantic import BaseModel

class ContactInfo(BaseModel):
    name: str
    email: str
    plan_interest: str
    demo_requested: bool

contact = ContactInfo.model_validate(untrusted_json)

Notice: Pydantic needs no separate z.infer step as the class is both the schema and the type. BaseModel is imported from pydantic.

One other surprising thing for me was to know that Python does not enforce types at runtime. I knew Python is a dynamically typed language, but I also knew that it has type hints and assumed that it enforces types at runtime. I am happy to know that I was wrong.

I also got to know that AI models support something called structured output, where we can pass a JSON schema to the model and it will return valid JSON matching your schema. For example, Anthropic supports structured output via the output_format property:

from pydantic import BaseModel
from anthropic import Anthropic


class ContactInfo(BaseModel):
    name: str
    email: str
    plan_interest: str
    demo_requested: bool


client = Anthropic()

response = client.messages.parse(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Extract the key information from this email: John Smith (john.smith@example.com) is interested in our Enterprise plan and wants to schedule a demo for next Tuesday at 2pm.",
        }
    ],
    output_format=ContactInfo,
)

print(response.parsed_output)

Main takeaway: if you have used Zod or a similar library, you already understand 70 to 80% of Pydantic. The mental model transfers as is, only some syntax and features change.

Thanks for reading. :) See you in the next lesson.

🖖🏼 References

• Pydantic documentation
• Zod documentation
• Anthropic structured outputs