Everything you need to build.

Quickstart

Create an API key in the dashboard, then point your client at the Fabriq base URL.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.fabriq.network/v1",
    api_key="fbq_live_...",
)

resp = client.chat.completions.create(
    model="llama-3.2-3b",
    messages=[{"role": "user", "content": "Say hello in one line."}],
)
print(resp.choices[0].message.content)

Or with curl:

curl https://api.fabriq.network/v1/chat/completions \
  -H "Authorization: Bearer fbq_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.2-3b",
    "messages": [{"role": "user", "content": "Hello"}]
  }'

Authentication

Every request carries an API key as a bearer token. Keys are created in the dashboard and shown once at creation, so store them somewhere safe. Use a live key in production and a test key while you build. Revoke a key any time and it stops working immediately.

Authorization: Bearer fbq_live_xxxxxxxxxxxxxxxx

Chat completions

POST /v1/chat/completions takes the same shape you already know. Set "stream": true for server-sent events, and pass tools and image content on models that support them.

{
  "id": "chatcmpl_...",
  "object": "chat.completion",
  "model": "llama-3.2-3b",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Hello." },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 9, "completion_tokens": 2, "total_tokens": 11 }
}

Models

Pass the model id in the model field. The catalog grows as the network does.

Run a node

A node runs the Fabriq engine on Apple Silicon or a GPU host. It loads models, shards large ones across peers, and registers with the network. You earn credit for the compute your node serves.

# Apple Silicon or Linux
curl -fsSL https://get.fabriq.network | sh
fabriq run

Running the engine needs real hardware and is rolling out to operators. Want in early? See the litepaper for how the network fits together.

Pricing

Pricing is usage-based. You pay per token for the model you actually call, metered from real requests. There are no seats and no idle clusters to rent, so the meter only runs when you do. Node operators earn credit for the compute they serve, on the same ledger.

Per-model rates are published as models come online.

Architecture

Three parts: the engine on each node, the gateway that authenticates and routes requests, and the control plane that holds accounts, keys, usage, and node state. The full design is in the litepaper.