Browse docs
Start Here

What You Just Bought

The one idea behind the whole boilerplate, a map of everything inside, and what you can build with it.

Updated Aug 2026
On this page

You bought a full product foundation, not a code snippet. This page gives you the one idea that makes everything click, then a map of what's inside.

The one idea

You write ONE Python class. The framework mounts it on three surfaces at the same time:

from pydantic import BaseModel, Field
from apps.core.ctx import Ctx
from apps.core.registry import Endpoint, endpoint


@endpoint(slug="hello", description="Greet someone by name.")
class Hello(Endpoint):
    class Input(BaseModel):
        name: str = Field(default="world", max_length=200)

    class Output(BaseModel):
        greeting: str

    async def run(self, inp: Input, ctx: Ctx) -> Output:
        return self.Output(greeting=f"Hi, {inp.name}")

That single class is now three things at once. Here are the first two, both answering the class above, on the machine this page was written on:

Two terminal calls to the same hello class: a curl POST and Claude calling it over MCP, both returning the identical greeting
Same class, same answer, two different callers. You wrote neither the REST route nor the MCP tool.
  1. A REST API endpoint at POST /api/v1/hello. Typed JSON in, typed JSON out.
  2. An MCP tool named hello that Claude, ChatGPT, or Cursor can call.
  3. A documentation page at /docs/hello/, generated from the same class:
The generated documentation page for the hello endpoint, with an Input table, code samples and a Try-it panel
The third surface. The Input table, the four SDK tabs and the Try-it panel all come from the class; nobody wrote this page.

You never write the API plumbing, the MCP wiring, or the docs page. You write the class. That's the whole model.

What's already built around your class

  • Auth: magic-link login (no passwords), API keys, and OAuth 2.1 so users can connect from Claude with one click.
  • Billing: Stripe subscriptions and credit packs. Put credits_cost=1 on your endpoint and the framework charges per call, refunds on errors, and enforces per-plan rate limits. Works without Stripe too, credits alone.
  • User dashboard: your customers manage their API keys, see their usage, and top up credits at /dashboard/.
  • Admin console: you manage users, plans, credits, call logs, errors, and background jobs at your own private admin URL.
  • Operations: request logging, error tracking, scheduled tasks, async jobs, webhooks, health checks. The parts you only miss when they're not there.

The numbers, measured on the current code: 740 files, 1,088 passing tests, 20 Django apps, 30 reference docs in the repo.

What you can build

Anything shaped like "input in, result out, charge for it":

  • a QR code generator (you'll build exactly this in Your First Project)
  • a text summarizer or translator wrapping an LLM
  • a web scraper or metadata extractor sold as an API
  • a PDF, image, or audio processing service
  • internal tools your team's AI agents can call over MCP

The proof it works

ToolerBox.com runs its paid API + MCP layer on this exact boilerplate, in production, with real customers. This is not a demo codebase.

How the docs are organized

Follow the groups in order the first time: Start Here (you are here), Setup (get it running), Your First Project (build a real endpoint in three short parts), Make It Yours, and Ship. After that, the 30 technical reference docs live in the repo's docs/ folder for when you need depth.

Stop wiring plumbing. Start selling endpoints.

Django and FastMCP boilerplate for Claude Code: one Python class becomes a REST endpoint, an MCP tool and live docs, with billing, credits and OAuth wired. The stack behind ToolerBox.

Get it for $79 →