export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

export async function rotateRefreshToken(session: Session) {

const next = await issueToken(session.userId, { family: session.family });

await revoke(session.tokenHash, { reason: 'rotated' });

return next;

}

router.post('/auth/refresh', async (req, res) => {

const session = await sessions.find(req.cookies.refresh);

if (!session || session.expiresAt < Date.now()) return res.sendStatus(401);

const token = await rotateRefreshToken(session);

res.cookie('refresh', token.raw, { httpOnly: true, sameSite: 'lax' });

res.json({ accessToken: signAccess(session.userId) });

});

CREATE TABLE sessions (

id uuid PRIMARY KEY DEFAULT gen_random_uuid(),

user_id uuid NOT NULL REFERENCES users(id),

token_hash text NOT NULL UNIQUE,

expires_at timestamptz NOT NULL

);

## Authentication

Refresh tokens rotate on every use. A reused token revokes the whole family.

def embed_chunks(chunks: list[Chunk]) -> list[Vector]:

return [client.embed(c.text) for c in chunks]

type Diagram = { kind: 'erd' | 'service_map'; mermaid: string }

const diagram = await generateDiagram(repo, 'service_map');

The AI documentation operating system

Documentation that updates itself.

Connect a repository. DocPilot writes the README, setup guide, architecture diagrams and API reference — then keeps every page in sync with each commit and pull request.

Start free View live demo

Free for one repository · No credit card required

docpilot · acme/apilive

~/acme/api

$ ▍

Features

Not another docs website builder.

DocPilot sits inside the development workflow — reading commits, pull requests and code structure — so documentation is a by-product of shipping, not a chore after it.

AI repository documentation

Connect GitHub and get a README, setup guide, folder explanations, architecture overview and API docs. No prompts needed.

Pull request intelligence

Every PR gets a summary, an impact report and the documentation it affects updated automatically.

Living architecture diagrams

System architecture, service map, database ERD, API flow and dependency graph — regenerated whenever code changes.

AI codebase chat

Ask “where is authentication implemented?” and get files, functions, an explanation and related docs, with citations.

Knowledge graph

See how classes, functions, APIs and services connect. Click a node to open its documentation.

API documentation generator

OpenAPI, examples, SDK snippets and authentication guides, kept in sync with your handlers.

AI migration guides

When an interface changes, DocPilot writes the v1 → v2 migration guide from the diff.

How it works

From clone to continuously documented

Step 1
Connect a repository
Install the DocPilot GitHub App on the repositories you choose. Private repos stay private; we only read what you allow.
Step 2
DocPilot reads and writes
The codebase is indexed, understood module by module, and documented: README, setup, architecture, folders, API reference and diagrams.
Step 3
Every change keeps it current
Pushes and pull requests mark affected pages stale and regenerate them. Reviewers approve; nothing publishes behind your back.

Integrations

Meets your team where it works

GitHub is supported today through a GitHub App. The rest of the toolchain is on the roadmap in the order below.

GitHubAvailable
GitLabPlanned
BitbucketPlanned
JiraPlanned
SlackPlanned
NotionPlanned
LinearPlanned
ConfluencePlanned
VercelPlanned
NetlifyPlanned

Enterprise

Built on enterprise foundations

Role-based access
Owner, admin, editor, reviewer and viewer roles per workspace.
Audit logs
Every sign-in, change and AI run is recorded with actor and time.
Encrypted secrets
Provider tokens are encrypted at rest with AES-256-GCM.
SSO & SOC 2
On the roadmap for Business and Enterprise plans.

Pricing

Simple plans, usage-based AI

Every plan includes a monthly AI credit allowance. Need more? Credits are metered, never surprising.

MonthlyYearly 2 months free

Free

Forever free

1 repository
2 members
100 AI credits / month
Public docs

Start free

Pro

$29/ month

Billed monthly

5 repositories
5 members
2,000 AI credits / month
PR intelligence
Custom domain

Start with Pro

Team

$120/ month

Billed monthly

25 repositories
25 members
15,000 AI credits / month
Knowledge graph
Review workflow
Integrations

Start with Team

Business

$349/ month

Billed monthly

100 repositories
100 members
60,000 AI credits / month
SSO
Audit logs
Priority support

Start with Business

Enterprise

Custom

Annual contract

Unlimited
Dedicated infrastructure
White-label portal
Custom SLAs

Talk to us

Your codebase is always documented.

Set up in minutes. The first repository is free, and nothing publishes without a reviewer's approval.

Start free See pricing

Documentation that updates itself.

Not another docs website builder.

AI repository documentation

Pull request intelligence

Living architecture diagrams

AI codebase chat

Knowledge graph

API documentation generator

AI migration guides

From clone to continuously documented

Connect a repository

DocPilot reads and writes

Every change keeps it current

Meets your team where it works

Built on enterprise foundations

Simple plans, usage-based AI

Free

Pro

Team

Business

Enterprise

Your codebase is always documented.