SQLModel is a Python library for interacting with SQL databases using Python code. It is designed to be intuitive, easy to use, highly compatible, and robust. SQLModel is based on Python type annotations, and powered by Pydantic and SQLAlchemy.

How does SQLModel combine Pydantic and SQLAlchemy?

SQLModel is designed by the creator of FastAPI and combines Pydantic validation with SQLAlchemy ORM. Each SQLModel class is simultaneously a Pydantic model (for data validation and serialization) and a SQLAlchemy model (for database operations), eliminating the need to maintain separate models.

Can I use SQLModel with FastAPI?

Yes, SQLModel integrates seamlessly with FastAPI. Since SQLModel classes are also Pydantic models, you can use them directly as request/response types in FastAPI path operations, making it ideal for building APIs with database persistence.

Is my SQL data sent to a server?

No, all processing happens entirely in your browser. Your SQL schema never leaves your device.

SQL to SQLModel Generator Online

Include table=TrueInclude Pydantic validationUse Optional for nullable

SQL Input (CREATE TABLE)

SQLModel Output

What is SQL to SQLModel Generator?

SQLModel was created by Sebastián Ramírez, the author of FastAPI, to solve a persistent problem in Python web development: maintaining separate classes for database persistence and API validation. A SQLModel class annotated with table=True is simultaneously a SQLAlchemy model that can create and query database rows, and a Pydantic model that validates incoming request data and serializes responses. This converter reads your SQL CREATE TABLE definitions and produces SQLModel classes with precise Python type annotations, Field() calls for primary keys and foreign keys, sa_column overrides for types that need SQLAlchemy-specific column configuration, and optional separate Create and Read schemas that omit auto-generated fields like id from API input. The generated code integrates directly with both FastAPI endpoints and SQLAlchemy sessions without any adapter layer.

How to Use

Paste your CREATE TABLE statements into the input area
Select your Python version — 3.9+ uses Optional[X] syntax while 3.10+ supports the X | None union syntax
Toggle the table=True checkbox to include SQLAlchemy table mapping, and the Pydantic validation checkbox to generate Create/Read schemas
Choose whether nullable columns should use Optional[T] or T | None notation
Click Generate SQLModel and copy the output into your Python project

Why Use This Tool?

Produces SQLModel classes that work as both Pydantic validators and SQLAlchemy ORM models, eliminating duplicate class definitions

Maps SQL types to Python types with full fidelity: INTEGER becomes int, TIMESTAMP becomes datetime, DECIMAL becomes Decimal, UUID becomes uuid.UUID, and JSON becomes dict

Generates sa_column overrides for types that need SQLAlchemy-specific configuration like String(255), Numeric(10, 2), and JSON()

Optional Create and Read schemas strip auto-increment fields and provide clean API request/response types for FastAPI

Handles foreign key references with foreign_key parameter in Field(), enabling SQLModel relationship navigation

Tips & Best Practices

A SQLModel class with table=True creates an actual database table. Without table=True, it is a pure Pydantic schema for validation only
Use the Pydantic validation option to generate separate Create and Read models — this is the recommended pattern for FastAPI applications where you want to exclude the id field from creation payloads
Python 3.10+ union syntax (X | None) is cleaner but requires your deployment environment to support it. Stick with Optional[X] if you need Python 3.9 compatibility
Install SQLModel with pip install sqlmodel — it includes both Pydantic and SQLAlchemy as dependencies

Frequently Asked Questions

How are SQL types mapped to Python types in SQLModel?

INTEGER, BIGINT, and SERIAL map to int, VARCHAR and TEXT map to str, BOOLEAN maps to bool, TIMESTAMP and DATETIME map to datetime, DATE maps to date, FLOAT and REAL map to float, DECIMAL and NUMERIC map to Decimal, UUID maps to uuid.UUID, JSON and JSONB map to dict, and BLOB maps to bytes. Nullable columns use Optional[T] or T | None depending on your Python version selection.

When should I avoid SQLModel and use plain SQLAlchemy or Pydantic separately?

SQLModel is ideal for FastAPI projects that need both validation and persistence in one class. If you are building a data pipeline that only needs SQLAlchemy, or a pure API that only needs Pydantic validation without a database, using them separately gives you more control. SQLModel also lags behind SQLAlchemy and Pydantic in adopting their latest features, so cutting-edge needs may require direct usage.

What does the Pydantic validation option generate?

It creates two additional classes per table: a ClassNameCreate model that omits auto-increment primary key fields (since the database generates them), and a ClassNameRead model that includes all fields with nullable columns marked as Optional. These classes are pure Pydantic models (no table=True) suitable for FastAPI request body and response model typing.

How does sa_column work in the generated code?

For SQL types that need SQLAlchemy-specific configuration — such as String(255) with a length parameter, Numeric(10, 2) with precision and scale, JSON() for JSON columns, or Uuid() for UUID columns — the converter generates sa_column=Column(...) overrides. This tells SQLModel to use the exact SQLAlchemy column definition instead of inferring it from the Python type annotation.

Is my SQL schema transmitted to any server during conversion?

No. The entire conversion process runs in your browser using a client-side parser. Your database schema is never sent over the network or stored on any external server.

Can I use the generated models with Alembic migrations?

Yes. SQLModel classes with table=True are fully compatible with Alembic's autogenerate feature. Run alembic revision --autogenerate after adding the generated models to your application, and Alembic will detect the new tables and columns automatically.

Real-world Examples

FastAPI application with user authentication

A FastAPI project needs User and Session models that serve as both database tables and API schemas. The developer generates SQLModel classes with Create/Read variants, then uses them directly in endpoint signatures.

E-commerce product catalog with decimal pricing

A product catalog stores prices as DECIMAL for financial precision. The converter generates SQLModel classes with sa_column overrides for Numeric columns and String lengths.

SQL to SQLModel Generator