Pydantic Introduction: Runtime Data Validation in Python

Python’s flexibility is one of its greatest strengths — but it can also be one of its biggest liabilities when you’re building production applications. Because Python is dynamically typed, variables can hold any value at any time, and the language won’t complain. The moment your code starts consuming data from the outside world — an HTTP request, a database record, a third-party API, an environment variable — you lose all guarantees about what shape that data is in. Pydantic bridges that gap by letting you declare the structure and types of your data as Python classes, then validating incoming data against those declarations at runtime, immediately and loudly, before bad data can propagate silently through your application.

The problem with Python’s dynamic typing

Python lets you reassign a variable to any type at any point:

age = 25
age = "twenty-five"
age = [25, None, "unknown"]

No errors. Python doesn’t care. For quick scripts this is fine, but the moment you’re processing external data you have a problem. Consider a simple API handler:

def create_user(data: dict):
    user_id = data["id"]
    email   = data["email"]
    age     = data["age"]

    # Works only if age is actually an int
    birth_year = 2025 - age

You expect:

{"id": 1, "email": "[email protected]", "age": 25}

But the caller sends:

{"id": 1, "email": null, "age": "unknown"}

Your code crashes — or worse, silently produces garbage data that reaches your database.

Without validation, data bugs often hide until production. By the time you notice, corrupted data may already be persisted.

Where bad data comes from

You’re constantly working with untrusted or weakly typed data sources:

API responses — external services return whatever they want
User input — form fields and query parameters are always strings
Configuration — environment variables are always strings, even PORT=8000
Database records — nullable columns, schema migrations, and legacy data can leave fields missing or malformed

What Pydantic does

Pydantic lets you describe the shape of your data as a class, then validates incoming data against that description at runtime. If validation fails, you get a precise error message immediately — at the boundary where data enters your system, not three call-stack layers later.

from pydantic import BaseModel

class User(BaseModel):
    id: int
    email: str
    age: int

# Valid data — works fine
user = User(id=1, email="[email protected]", age=25)
print(user.age)   # 25
print(type(user.age))  # <class 'int'>

# Invalid data — fails immediately
user = User(id=1, email=None, age="unknown")

The second instantiation raises a clear error:

2 validation errors for User
email
  Input should be a valid string [type=string_type]
age
  Input should be a valid integer, unable to parse string as an integer [type=int_parsing]

The problem is caught at the source, not in production.

Pydantic also performs type coercion for compatible types — for example, the string "25" is automatically converted to the integer 25. You’ll learn exactly when this happens in the next page.

Why Pydantic matters for AI and FastAPI

Pydantic is the backbone of the modern Python ecosystem:

FastAPI

FastAPI uses Pydantic models to validate every incoming request body and outgoing response. Define a model, and FastAPI handles the rest — including auto-generated API docs.

AI frameworks

LangChain, OpenAI’s Python SDK, and most AI orchestration tools use Pydantic to define structured outputs from language models. When an agent calls a tool or returns a result, Pydantic ensures the data is what you expect.

Configuration management

pydantic-settings extends Pydantic to load and validate environment variables, .env files, and secrets — replacing fragile os.getenv() calls with a typed, validated settings class.

Agentic coding

When you define clear Pydantic models, AI coding assistants understand your data structures far better. Well-defined models act as guardrails that guide both humans and AI toward correct usage.

If you’re planning to work with FastAPI, LangChain, SQLModel, or any modern Python framework, you’ll encounter Pydantic constantly. Investing time here pays dividends across everything you build.

A quick preview

Here’s the pattern you’ll be writing throughout this course:

from pydantic import BaseModel, Field

class User(BaseModel):
    id: int
    name: str
    email: str
    age: int = Field(ge=0, le=120)

user = User(id=1, name="Alice", email="[email protected]", age=25)
print(user.model_dump())
# {'id': 1, 'name': 'Alice', 'email': '[email protected]', 'age': 25}

You declare a model, Pydantic enforces it, and you work with clean, typed data from that point on.

Installation

Install Pydantic using pip or uv:

pip install pydantic

uv add pydantic

Verify the installation:

import pydantic
print(pydantic.__version__)  # e.g. 2.7.1

Which version of Pydantic does this course use?

This course uses Pydantic v2, the current major release. Pydantic v2 was rewritten in Rust and is significantly faster than v1. If you encounter older tutorials using .dict() instead of .model_dump(), they are using Pydantic v1. The core concepts are the same, but the method names differ.

Learn more

What’s next?

Now that you understand the problem Pydantic solves, it’s time to write your first model.

Your First Model

Learn how to create a Pydantic BaseModel subclass, define fields, and instantiate validated data objects.

Basics

Advanced

Pydantic

Pydantic Introduction: Runtime Data Validation in Python

The problem with Python’s dynamic typing

Where bad data comes from

What Pydantic does

Why Pydantic matters for AI and FastAPI

A quick preview

Installation

Learn more

What’s next?

Your First Model

​The problem with Python’s dynamic typing

​Where bad data comes from

​What Pydantic does

​Why Pydantic matters for AI and FastAPI

​A quick preview

​Installation

​Learn more

​What’s next?

Your First Model

The problem with Python’s dynamic typing

Where bad data comes from

What Pydantic does

Why Pydantic matters for AI and FastAPI

A quick preview

Installation

Learn more

What’s next?