Prefer Swagger UI? Click hereThe same API in the classic OpenAPI explorer.

Home Get started Concepts How-to guides Best practices Reference

// documentation

Ringside documentation

Ringside is an OpenAI-compatible API across 19 model providers, with a per-customer spend-metering layer your own product can bill on top of. Point an SDK at the base URL, attach a customer header and you are live. Read a concept to build the mental model, follow a guide to ship a feature, or jump to the endpoint reference.

Your first call

Full quickstart →

curl https://api.fightclub.pro/v1/chat/completions \
  -H "Authorization: Bearer $FC_API_KEY" \
  -H "FC-Customer: cus_42" \
  -H "Content-Type: application/json" \
  -d '{"model":"fc:openai/gpt-4o-mini","messages":[{"role":"user","content":"Hello"}]}'

Create a key in the dashboard, export it as FC_API_KEY, and run the call above.

Get started6 pages

Understand what Ringside is, how a request flows through it, and make your first authenticated call.

What is Ringside

The problem it solves and the mental model.

How a request flows through the metering layer to providers.

The core primitives in one place.

From zero to a billed call in five minutes.

API keys, client tokens, scopes and trust boundaries.

Official SDKs, the dashboard, the playground.

Concepts15 pages

The ideas behind the API. Read these to build a correct mental model before wiring code.

The customer and spend model

Budgets, prepaid wallets, markup and margin.

Model references and resolution

fc:, match:, slot:, dyn: and region routing.

Metering and billing

How cost becomes a charge on your wallet.

Rate limiting and quotas

The four enforcement layers and their headers.

Idempotency and reliability

Safe retries, fallback cascades, delivery guarantees.

Reuse stable prefixes and cut input cost.

Retrieval-augmented generation

Vector stores, embeddings and file_search.

Knowledge-graph retrieval over your documents.

Brains: managed memory

Long-term agent memory that learns, ranks and forgets on a curve.

One searchable corpus, migrating an existing store, read-only recall.

Brain Packs and mounts

Share one base layer of knowledge under many private, per-tenant brains.

Sealed RAG and encryption

Encryption at rest, BYOK and the threat model.

Webhooks and events

The event taxonomy, signing and delivery.

Batch processing

Asynchronous bulk jobs at half price.

Assistants, threads and runs

The stateful agent execution model.

How-to guides12 pages

Task-oriented recipes. Each one starts from a goal and ends with working code.

Create and manage customers

Provision end-users and attribute spend.

Provision accounts for your customers

Create full isolated accounts via API, funded self / grant / voucher / linked.

Meter and bill with Stripe

Turn Ringside usage into Stripe invoices.

Embed a browser chatbot

Call Ringside from the frontend with client tokens.

Build RAG over documents

Ingest files and answer with citations.

Secure RAG for regulated data

BYOK sealed stores end to end.

Add model fallback

Cascade cheap-to-expensive with one array.

Enforce structured output

JSON that always parses, across providers.

Receive and verify webhooks

A signed, replay-safe receiver.

Migrate from OpenAI

Change three lines and keep your SDK.

Add agent memory with Brains

Create a brain, store knowledge, recall and learn automatically.

Share knowledge across tenants with Packs

Publish a base brain as a Pack and mount it under per-tenant brains.

Best practices5 pages

Production guidance distilled from how the platform is meant to be run.

Key handling, token scoping, BYOK, least privilege.

Error handling and resilience

A retry and fallback strategy that holds up.

Budgets, caching, model choice and batch.

Request ids, logs, usage and ops webhooks.

Going to production

A checklist before you flip live traffic on.

Reference9 pages

Lookup tables and exact values. The endpoint reference lives under its own section in the sidebar.

Every error code, status and how to handle it.

Limits and quotas

Every hard limit in one table.

Supported providers, models and ref syntax.

Every /v1/brains endpoint, parameter and response.

Brain Packs API

Publish, grant and mount Packs to share one base under many brains.

Provision, list, get and close accounts under your developer.

Regions and data residency

Where inference runs and how to pin it.

Terms used across the docs.

Changelog and versioning

API version policy and notable changes.

API reference14 endpoints

Every endpoint with full parameters, headers, response fields, error tables and related routes.

Chat Completions

/v1/chat/completions

/v1/moderations

/v1/customers/{id}/conversations

/v1/threads/{thread_id}/runs

/v1/customers/{id}/client_tokens

/v1/vector_stores