TypoKit

Why TypoKit?

Define your API contract once as a TypeScript type. TypoKit’s Rust-powered build pipeline compiles it into route handlers, request validators, typed clients, and contract tests — with zero runtime overhead. Ship production-ready APIs in minutes, not days.

Schema-First Types

Define your entire API surface as TypeScript interfaces. Routes, params, bodies, and responses are all derived from a single source of truth — no drift, no duplication.

Rust Build Pipeline

A compiled Rust transform parses your schemas and generates optimized route tables, validators, and serializers. Incremental builds keep feedback loops fast.

Pluggable Server Adapters

Run on Express, Fastify, Hono, or Node’s native HTTP — swap adapters with a one-line config change. Your handler code stays the same.

Auto-Generated Tests

Contract tests are generated alongside your routes. Every endpoint is verified against its schema automatically — catch regressions before they ship.

AI-Native Debugging

Built-in observability and a debug plugin give AI agents structured context about your API. Traces, metrics, and error diagnostics are machine-readable by default.

Type-Safe Client SDK

Generate a fully typed client from your API schema. Works with React Query, SWR, or vanilla fetch — with autocomplete for every route and parameter.

Cross-Language Codegen

Generate a complete Rust/Axum server from your TypeScript types. The same schema that drives your Node.js API can produce a high-performance Rust backend — no manual translation required.

See It in Action

Define a type. Get everything else for free.

Schema Definition

types.ts

export interface UserRoutes {
  "GET /users": {
    response: { id: string; name: string; email: string }[];
  };
  "GET /users/:id": {
    params: { id: string };
    response: { id: string; name: string; email: string };
  };
  "POST /users": {
    body: { name: string; email: string };
    response: { id: string; name: string; email: string };
  };
}

Generated Handler

handlers.ts

import { defineHandlers } from "@typokit/core";
import type { UserRoutes } from "./types";

export default defineHandlers<UserRoutes>({
  "GET /users": async (ctx) => {
    // ctx.response is typed as { id, name, email }[]
    return ctx.db.users.findMany();
  },
  "GET /users/:id": async (ctx) => {
    // ctx.params.id is typed as string
    return ctx.db.users.findById(ctx.params.id);
  },
  "POST /users": async (ctx) => {
    // ctx.body is typed as { name, email }
    return ctx.db.users.create(ctx.body);
  },
});

Type-Safe Client

client.ts

import { createClient } from "@typokit/client";
import type { UserRoutes } from "./types";

const api = createClient<UserRoutes>({
  baseUrl: "https://api.example.com",
});

// Fully typed — autocomplete for route, params, and response
const users = await api.get("/users");
const user = await api.get("/users/:id", { params: { id: "123" } });
const created = await api.post("/users", { body: { name: "Ada", email: "ada@example.com" } });

Who Is This For?

Framework Users

Teams building Node.js APIs who want type safety without boilerplate. If you’re tired of keeping your routes, validators, and client SDKs in sync — TypoKit does it for you.

AI Agent Developers

Build APIs that AI agents can discover, understand, and interact with. TypoKit generates machine-readable docs, structured error responses, and OpenTelemetry traces by default.

Start Building

Quickstart Create your first TypoKit API in under 5 minutes.

Core Concepts Understand schemas, routing, middleware, and more.

API Reference Browse the full generated API documentation.

Architecture Explore how the build pipeline and compiled router work.