Stop Trusting Your Data: Let Python Type Hints Do the Validation Work

You know the drill. Your API returns a JSON payload, you unpack it into a dictionary, and suddenly user["age"] is a string when you swore it was an integer. Or worse, a field shows up as None and crashes your code three layers deep. Manually writing validation logic for every input feels like punishment—tedious, repetitive, and easy to get wrong. What if your type hints could do the heavy lifting for you? That's exactly what Pydantic does, and it's been doing it well for years.

Pydantic is a data validation library that turns your Python type annotations into runtime checks. You define a class, annotate its fields, and Pydantic handles the rest—coercing, validating, and erroring out on bad data before it ever reaches your business logic. It's fast, it's extensible, and it plays nice with the tools you already use.

What It Does

Pydantic is built on a simple premise: you already write type hints in Python, so why not use them for more than static analysis? The library lets you define data models as plain Python classes with annotated fields. When you instantiate one of those models with data, Pydantic validates every field against its declared type and converts values to the correct type where possible.

The core class is BaseModel. You inherit from it, declare your fields, and you're done. Under the hood, Pydantic generates validators from your annotations, so you get runtime checks without writing a single custom validation function for common cases. It supports Python 3.10 and up, and it's distributed through both pip and conda-forge.

The current version, Pydantic V2, is a ground-up rewrite of the original library. It's faster and adds new features, though it does introduce some breaking changes from V1. If you're still on V1, you can incrementally upgrade—Pydantic V2 ships with the latest V1 version built in, so you can use from pydantic import v1 as pydantic_v1 to migrate piece by piece.

Why It's Cool

The appeal here isn't just that Pydantic validates data—it's how it does it.

• Your type hints become the source of truth. You're not maintaining a separate schema file or writing boilerplate validators. The class definition is the contract. Change the annotation, and the validation changes with it.

• It's aggressively practical about coercion. Look at the example from the README. You pass in id as the string "123", and Pydantic happily converts it to an integer. Friends come in as a mix of integers, strings, and bytes—[1, '2', b'3']—and come out as clean integers. This isn't sloppy; it's the library doing the conversion work so you don't have to.

• It's built for real-world data. The example model includes an Optional[datetime] field that defaults to None. Feed it a string like '2017-06-01 12:22', and Pydantic parses it into an actual datetime object. That's the kind of messy, real-world input that comes out of APIs and forms, and Pydantic normalizes it for you.

• It respects your tooling. Pydantic models are plain Python classes, so your linter, IDE autocomplete, and type checker all work as expected. You're not learning a DSL or fighting your editor's static analysis.

• There's a migration path if you're on V1. The built-in V1 compatibility layer is a thoughtful touch. You don't have to rewrite everything at once—you can move your codebase over incrementally.

The library is also mature enough that the team has built a separate product, Pydantic Logfire, for monitoring applications. That's less a feature of the library itself and more a signal that the project is actively maintained and backed by people who care about the ecosystem.

How to Try It

Getting started takes about two minutes. First, install it:

pip install -U pydantic

Or if you're using conda:

conda install pydantic -c conda-forge

Then define your first model. Here's the full example from the README, which shows off the core behavior:

from datetime import datetime
from typing import Optional
from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str = 'John Doe'
    signup_ts: Optional[datetime] = None
    friends: list[int] = []

external_data = {'id': '123', 'signup_ts': '2017-06-01 12:22', 'friends': [1, '2', b'3']}
user = User(**external_data)
print(user)
#> User id=123 name='John Doe' signup_ts=datetime.datetime(2017, 6, 1, 12, 22) friends=[1, 2, 3]
print(user.id)
#> 123

Notice how id came in as a string and came out as an integer, and how the friends list got normalized. That's the library doing its job.

For more details, check out the full documentation, or head straight to the repository on GitHub to explore the source, report issues, or contribute.

Final Thoughts

Pydantic is one of those libraries that quietly becomes indispensable once you start using it. It's not flashy, but it solves a genuinely annoying problem—validating and cleaning untrusted input—with a design that feels obvious in hindsight. If you work with APIs, configuration files, or any external data source in Python, this will save you time and debugging headaches. And if you're on V1, the upgrade path makes it easy to move forward without a painful rewrite. Give it a spin on your next project; you'll probably wonder how you managed without it.

Follow @githubprojects for more developer tools and open source projects.