Developer portal & API metering

Open your API. Keep the meter running.

Publish OpenAPI docs, guides and a changelog. Let developers sign up, get keys, pick a usage plan and test calls. Tolldeck enforces rate limits and quotas, meters every request and sends the month-end invoice.

Metering modes
2
Snippet languages
4
Node process
1
Reference docs with the try-it console
Next.js 16MongoDBOpenAPI 3.0 / 3.1HMAC edge APIREST + webhooks

Docs, keys, plans

Everything a developer needs before the first call

OpenAPI docs, guides, changelog

Import OpenAPI 3.0 or 3.1 (Swagger 2.0 best effort). Operations, schemas and examples render in a three-column reference with breaking-change badges and sunset banners.

Apps and keys

Developers create apps, get sandbox and live keys shown once, rotate with a grace period and see their own usage and errors.

Plans, quotas, overage

An entry tier at no charge, paid tiers, hard or soft caps, per-second rate limits, operation weights and overage billed per block.

Analytics

Requests and units by product, app and operation, error rates, p50 and p95 latency, revenue and the top developers.

Partner and private portals

Public, partner (approval required) or private products. IP allow-lists per app, enforced at the gateway.

Your own domain

Serve the portal on developers.your-company.example with your logo, accent colour and legal pages.

Try-it console

Pick an operation, see the call

In the real portal the console sends the call through your gateway with the developer's sandbox key only. Production keys are never used from the browser console. Try the four outcomes on the right: a normal read, a heavy operation that costs five units, a write and a rate-limited call.

# request
GET /gw/forecast/forecast?city=Lisbon&days=3
X-Api-Key: td_test_••••9aQ2
# response · 38 ms · 1 unit
HTTP 200
RateLimit-Remaining: 9
X-Request-Id: req_8f2a41
{
  "city": "Lisbon",
  "days": [
    {
      "d": "2026-11-12",
      "hi": 17,
      "lo": 11,
      "sky": "clouds"
    },
    {
      "d": "2026-11-13",
      "hi": 18,
      "lo": 12,
      "sky": "rain"
    },
    {
      "d": "2026-11-14",
      "hi": 16,
      "lo": 10,
      "sky": "clear"
    }
  ]
}

Plans, quotas and overage

Slide the usage, watch the invoice

Each product gets its own usage plans: included units, a rate limit, a hard or soft cap and an overage price per block. Month-end invoices are base fee plus overage blocks plus tax per line, with credits applied first. Usage that comes back as an upstream error is not billed unless you choose to.

  • Operation weights: a history call can cost five units
  • Mid-period plan changes prorate by day
  • Warnings at 80 % and 100 % by email
  • Failed card: past due, then suspended after your grace days

Starter tier: 100,000 units included, then $5.00 per 10,000.

Base fee
$29.00
Overage (3 blocks)
$15.00
Tax 20% (per line)
$8.80
Invoice total
$52.80

Two metering modes

Proxy it, or just verify and report

Gateway: Tolldeck checks the key, rate limit and quota and proxies to your upstream, with SSRF protection on every hop. Best for moderate traffic.

Verify-and-report: your own gateway calls a signed verify endpoint per request (cache it for a minute) and posts usage batches. Same dashboards, same invoices, high volume stays on your infrastructure.

Toll Lanes

Tideboard
34%
Fernhill Maps
62%
Quillbeam
91%
Marlowe Labs
100%
Northpier
18%
GATEWAY MODEDeveloper appTolldeck gatewayYour upstream APIkey, rate limit, quota, meterVERIFY-AND-REPORT MODEDeveloper appYour own gatewayYour upstream APITolldeck edge APIverify per request, usage batches every 30 s

Partner portals

Sign-up can be open, by invitation or approved by you. Partner products stay hidden until a company is approved, and an app can be limited to its own IP addresses.

Analytics for both sides

You see revenue, top developers, error rates and latency. Developers see their own usage against quota and recent errors.

Versions and sunsets

Publish v2, deprecate v1 with a sunset date: portal banners appear and Deprecation and Sunset headers are added to gateway responses.

SDK snippets

Verify-and-report in your stack

Each edge product page generates these with its own product id filled in: an Express middleware, a Laravel middleware, NGINX auth_request with a small Node sidecar and a FastAPI dependency. Every verify call carries a nonce, so the replay guard never rejects an honest retry.

// Express middleware: verify the key with Tolldeck, report usage in batches.
import crypto from 'node:crypto';

const BASE = 'https://portal.skyrill.example';
const PRODUCT = 'prd_skyrill_forecast';
const SECRET = process.env.TOLLDECK_EDGE_SECRET; // shown once when you create or rotate it

const sign = (raw) => {
  const t = Math.floor(Date.now() / 1000);
  return `t=${t},v1=${crypto.createHmac('sha256', SECRET).update(`${t}.${raw}`).digest('hex')}`;
};
const call = async (path, body) => {
  const raw = JSON.stringify(body);
  const res = await fetch(`${BASE}/api/v1/edge/${path}`, { method: 'POST', body: raw, headers: { 'content-type': 'application/json', 'x-tolldeck-product': PRODUCT, 'x-tolldeck-signature': sign(raw) } });
  return res.json();
};

const cache = new Map(); // key -> { until, decision }
const queue = [];

export async function tolldeck(req, res, next) {
  const key = req.get('x-api-key') || '';
  const hit = cache.get(key);
  let d = hit && hit.until > Date.now() ? hit.decision : null;
  if (!d) {
    d = await call('verify', { key, operation: `${req.method} ${req.route?.path || req.path}`, ip: req.ip, nonce: crypto.randomUUID() });
    if (d.valid) cache.set(key, { until: Date.now() + 60_000, decision: d });
  }
  if (!d.valid) return res.status(d.code === 'rate_limited' ? 429 : 401).json({ error: { code: d.code } });
  const started = Date.now();
  res.on('finish', () => queue.push({ key, operation: `${req.method} ${req.route?.path || req.path}`, status: res.statusCode, at: new Date().toISOString(), latency_ms: Date.now() - started }));
  next();
}

setInterval(async () => {
  const items = queue.splice(0, 5000);
  if (items.length) await call('usage', { batch_id: crypto.randomUUID(), items }).catch(() => queue.unshift(...items));
}, 30_000);

Plans for provider workspaces

The operator sells plans, providers sell APIs

These are the demo plans an operator offers to provider workspaces. Set your own in the config; billing runs through a simulated gateway until you connect one.

Starter

For one API and a small developer community

$29/mo

  • 3 API products
  • 500 developers
  • 1M gateway requests / mo
  • OpenAPI docs + guides
  • Usage plans and keys
Start a 14-day trial

Growth

Popular

For API companies with paid tiers

$99/mo

  • 15 API products
  • 10,000 developers
  • 20M requests / mo
  • Usage invoices
  • Partner portals
  • Custom domain
Get started

Business

For platform teams at scale

$299/mo

  • Unlimited products
  • Unlimited developers
  • Unlimited requests
  • Priority support
Get started

Questions

Open the lane.

Create a workspace, import a spec and have a portal with docs, keys and plans in an afternoon.