Now with GraphQL & Real-time Subscriptions

PostgreSQL API
in Milliseconds

High-performance REST & GraphQL API server for PostgreSQL, written in Rust. Native AWS Lambda support with ~50ms cold starts. Drop-in PostgREST replacement, and it speaks Hasura’s GraphQL dialect. Both measured against the servers they replace.

Get Started View on GitHub

Terminal

# Start in seconds with Docker
$ docker run -p 3000:3000 \
    -e DATABASE_URL="postgres://..." \
    postrust/postrust

# Your API is ready!
$ curl localhost:3000/users
[{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]

MIT Licensed

~50ms Lambda Cold Start

REST + GraphQL

Everything you need to build APIs

Postrust provides a complete solution for exposing your PostgreSQL database as a secure, high-performance API. No boilerplate, no ORM, just your schema.

Blazing Fast

Written in Rust for maximum performance. Sub-millisecond response times and minimal memory footprint.

Serverless-First

Native support for AWS Lambda. Single binary with ~50ms cold starts. No container overhead.

GraphQL Built-in

Full GraphQL API alongside REST. Queries, mutations, filtering, and nested relationships out of the box.

Realtime Subscriptions

Live updates via GraphQL subscriptions. Subscribe to any query or view changes with PostgreSQL LISTEN/NOTIFY.

pgvector Integration

Native vector similarity search. Build AI-powered apps with embeddings, semantic search, and RAG pipelines.

Custom Routes in Rust

Define custom endpoints in pure Rust. Full access to Axum handlers, middleware, and the database pool.

Secure by Design

PostgreSQL Row-Level Security (RLS) enforcement. JWT authentication with customizable role claims.

PostgREST Compatible

Same query syntax and filtering operators. An opt-in compatibility mode serves canonical PostgREST paths and response shapes for drop-in migrations.

Admin UI Included

Built-in Swagger UI, Scalar API docs, and GraphQL Playground. OpenAPI 3.0 spec auto-generated.

Single Binary

~5MB binary with no runtime dependencies. Deploy anywhere - Docker, Lambda, bare metal.

Developer Experience

Intuitive API, powerful results

Whether you prefer REST or GraphQL, Postrust provides a clean, consistent API that's easy to use and powerful enough for production.

Query with Filters

# Get active users with pagination
curl "localhost:3000/users?status=eq.active&limit=10&offset=0"

# Response
[
  {"id": 1, "name": "Alice", "email": "alice@example.com"},
  {"id": 2, "name": "Bob", "email": "bob@example.com"}
]

Nested Resources

# Get orders with customer and items
curl "localhost:3000/orders?select=*,customer(name,email),items(product(name,price))"

# Response
[{
  "id": 1,
  "total": 99.99,
  "customer": {"name": "Alice", "email": "alice@example.com"},
  "items": [{"product": {"name": "Widget", "price": 49.99}}]
}]

Query with Relations

query {
  users(filter: {status: {eq: "active"}}, limit: 10) {
    id
    name
    email
    orders {
      id
      total
      items {
        product { name price }
      }
    }
  }
}

Mutations

mutation {
  insertUsers(objects: [
    {name: "Charlie", email: "charlie@example.com"}
  ]) {
    id
    name
    createdAt
  }
}

Create & Update

# Insert a new product
curl -X POST "localhost:3000/products" \
  -H "Content-Type: application/json" \
  -d '{"name": "Widget", "price": 29.99, "stock": 100}'

# Update with filters (PATCH)
curl -X PATCH "localhost:3000/products?id=eq.1" \
  -H "Content-Type: application/json" \
  -d '{"price": 24.99}'

Upsert & Delete

# Upsert (insert or update on conflict)
curl -X POST "localhost:3000/products" \
  -H "Prefer: resolution=merge-duplicates" \
  -d '{"sku": "WDG-001", "name": "Widget Pro", "price": 39.99}'

# Delete with filters
curl -X DELETE "localhost:3000/products?status=eq.discontinued"

JWT Authentication

# Include JWT in Authorization header
curl -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIs..." \
  "localhost:3000/users"

# JWT payload for PostgreSQL RLS
{
  "role": "authenticated",
  "sub": "user_123",
  "email": "alice@example.com"
}

Row-Level Security

-- PostgreSQL RLS Policy
CREATE POLICY user_isolation ON orders
  FOR ALL
  USING (user_id = current_setting('request.jwt.claims')::json->>'sub');

-- Users can only see their own orders
-- Postrust enforces this automatically

Aggregations

# Count orders by status
curl "localhost:3000/orders?select=status,count()&group=status"

# Sum and average
curl "localhost:3000/order_items?select=product_id,sum(quantity),avg(price)"

# Response
[
  {"status": "pending", "count": 42},
  {"status": "shipped", "count": 156}
]

Stored Procedures (RPC)

# Call a PostgreSQL function
curl -X POST "localhost:3000/rpc/calculate_shipping" \
  -H "Content-Type: application/json" \
  -d '{"order_id": 123, "destination": "US"}'

# Response
{"shipping_cost": 12.99, "estimated_days": 3}

GraphQL Subscriptions

subscription {
  orders(filter: {status: {eq: "pending"}}) {
    id
    total
    status
    customer { name email }
  }
}

# Receive live updates when orders change
{"data": {"orders": {"id": 42, "status": "shipped", ...}}}

Subscribe to Any View

# Subscribe to a PostgreSQL view for live dashboards
subscription {
  salesDashboard {
    totalRevenue
    orderCount
    topProducts { name salesCount }
  }
}

# Updates stream in real-time as underlying data changes

Semantic Search

# Find similar documents using embeddings
curl "localhost:3000/documents?select=id,title,content&embedding=lt.0.5&order=embedding.asc"

# Or via GraphQL with vector distance
query {
  documents(
    filter: {embedding: {near: {vector: [0.1, 0.2, ...], distance: 0.5}}}
    order: {embedding: ASC}
    limit: 10
  ) {
    id title content similarity
  }
}

RAG Pipeline

-- PostgreSQL: Create embeddings table
CREATE TABLE documents (
  id SERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(1536)  -- OpenAI ada-002 dimensions
);
CREATE INDEX ON documents USING ivfflat (embedding vector_cosine_ops);

# Query similar content for LLM context
curl "localhost:3000/rpc/search_similar" \
  -d '{"query_embedding": [0.1, 0.2, ...], "limit": 5}'

Rust Handler Definition

// crates/postrust-server/src/custom.rs
use axum::{extract::State, Json, routing::post};

pub fn custom_router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/webhooks/stripe", post(handle_stripe))
        .route("/ai/embed", post(generate_embedding))
}

async fn handle_stripe(
    State(state): State<Arc<AppState>>,
    body: String,
) -> impl IntoResponse {
    // Full access to database pool, config, JWT
    let result = sqlx::query("UPDATE subscriptions...")
        .execute(&state.pool).await;
    Json(json!({ "received": true }))
}

Custom Middleware

// Add rate limiting, logging, or custom auth
use axum::middleware;

pub fn custom_router() -> Router<Arc<AppState>> {
    Router::new()
        .route("/api/expensive", post(expensive_operation))
        .layer(middleware::from_fn(rate_limit))
        .layer(middleware::from_fn(custom_auth))
}

async fn rate_limit<B>(req: Request<B>, next: Next<B>) -> Response {
    // Check rate limits, return 429 if exceeded
    next.run(req).await
}

View full API reference

SaaS Starter Kit

Launch your SaaS in days, not months

A production-ready starter kit built on Postrust with authentication, team management, billing, and everything you need to ship fast.

View on GitHub Documentation

Built with:Next.jsPostrustPostgreSQLTailwind CSS

Authentication

Magic link and OAuth with Google & GitHub

Team Management

Create teams, invite members, manage roles

Billing

Stripe & LemonSqueezy subscription management

API Keys

Generate and manage programmatic access

Row Level Security

PostgreSQL RLS policies built-in

Audit Logs

Track all team actions for compliance

Deployment

Deploy anywhere in minutes

From Docker to serverless, Postrust runs wherever you need it. Single binary with zero runtime dependencies.

Docker

Container-based deployment for any environment

$ docker run -p 3000:3000 -e DATABASE_URL=... postrust/postrust

AWS Lambda

Serverless deployment with native adapter

$ cargo lambda build --release -p postrust-lambda

Kubernetes

Production-ready with health checks and scaling

$ helm install postrust ./charts/postrust

Fly.io

Global edge deployment in minutes

$ fly launch

Railway

Git-based deployment, builds the Dockerfile

$ railway init && railway up

Binary

Single binary for bare metal servers

$ cargo build --release -p postrust-server

View deployment guides

Open Source & MIT Licensed

Ready to build faster APIs?

Get started with Postrust in minutes. Join developers building high-performance PostgreSQL APIs with Rust.

Get Started for Free Star on GitHub

Report Issues Follow @postrustorg Contributing

PostgreSQL APIin Milliseconds