Private alpha · invite only

TCDN-AI: an OpenAI-compatible API built for a peer-to-peer network of idle GPUs

One endpoint, the OpenAI request shape you already use. Requests are built to run on machines that people and small operators connect to the network, in the countries they are in, instead of a single provider’s datacenter. Pricing is in USD per million tokens; the console shows the shilling equivalent of each credit pack, and M-Pesa is the local channel — coming, not enabled on our payment account yet.

The endpoint is enabled for invited accounts. Alpha access is granted by hand and there is no self-serve signup for the API yet.

01What is true today

  • Private alpha, invite only. The endpoint is enabled for invited accounts only: access is granted by hand and there is no self-serve way to get an account or a key.
  • A small model set, still being brought up. The first model is planned to be llama-3.1-8b-instruct; no worker on this deployment serves it yet, so read it as the target rather than a live choice. The console's models page is the live list once there is one. Llama 3.1 is licensed under the Meta Llama 3.1 Community License.
  • Standard privacy tier only. The confidential tier is not available, so every job runs on the standard tier, where the host that runs it sees the prompt in plaintext.
  • An OpenAI-compatible surface: /v1/chat/completions, /v1/models, streaming responses and the OpenAI error shape. The official OpenAI SDKs work unchanged.
  • No availability promise. Hosts join and leave the network, so the alpha comes with no SLA and no uptime figure — there is no measured number to quote, so none is quoted.

02How it works in three steps

  1. Step 1

    Your request goes to the gateway

    You call the OpenAI-compatible endpoint with your key, exactly as you would call any provider. The gateway checks the key, your credit balance and the model, then prices the job before it runs.

  2. Step 2

    One host runs the model, not one datacenter

    The model file is split into shards and delivered peer-to-peer, so a host fetches only the pieces it needs from its peers. A host that has the model loaded takes the whole request: the coordinator sends it a short-lived signed ticket bound to that one job, the host verifies the ticket, runs the request and returns a receipt for the tokens it produced.

  3. Step 3

    You get the tokens, hosts get paid

    The response streams back to you while the job is in flight. Token counts are checked at the gateway, the job is settled on your account from the host’s receipt and capped at what the gateway measured, and the host’s share of that same job is credited to its account.

Read the full architecture — components, the seven-step job lifecycle, settlement and the gaps this build does not close.

03How to use it

  1. Request access

    Email support@torrentcdn.store from the address you want the account under. We reply with an invite when there is room on the network.

  2. Get an API key and buy credits

    In the console, create a key on the API keys page — it is shown once and only its prefix is stored after that. Then add credits on the billing page. Credits are prepaid and drawn down per request.

  3. Point your tool at the base URL

    Use https://www.torrentcdn.store/v1 as the base URL and your key as the bearer token. Anything that speaks the OpenAI protocol — the SDKs, curl, or an editor extension — works without a shim.

OpenAI Python

from openai import OpenAI

client = OpenAI(
    base_url="https://www.torrentcdn.store/v1",
    api_key="YOUR_API_KEY",
)

response = client.chat.completions.create(
    model="llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Explain P2P delivery in one sentence."}],
    max_tokens=128,
)
print(response.choices[0].message.content)

OpenAI JS

import OpenAI from 'openai'

const client = new OpenAI({
  baseURL: 'https://www.torrentcdn.store/v1',
  apiKey: 'YOUR_API_KEY',
})

const response = await client.chat.completions.create({
  model: 'llama-3.1-8b-instruct',
  messages: [{ role: 'user', content: 'Explain P2P delivery in one sentence.' }],
  max_tokens: 128,
})
console.log(response.choices[0].message.content)

curl

curl https://www.torrentcdn.store/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3.1-8b-instruct",
    "messages": [{"role": "user", "content": "Explain P2P delivery in one sentence."}],
    "max_tokens": 128
  }'

Editor and agent settings

Each tool below takes the same base URL and key, and the model id is the same string everywhere. The settings were checked against each tool’s own documentation, not run from inside the editor: treat them as untested until you try one with an invited account.

Cursor

// Cursor → Settings → Models → API Keys
// 1. Paste your key into "OpenAI API Key" and save.
// 2. Turn on "Override OpenAI Base URL" and enter:
//      https://www.torrentcdn.store/v1
// 3. Add the model id as a custom model: llama-3.1-8b-instruct
// 4. Pick that model in a new chat.
// The override is global while it is on: every OpenAI-family request,
// including Cursor's own models, goes to the URL you entered.

Cline

// Cline → Settings (gear icon) → API Provider
// 1. API Provider: "OpenAI Compatible"
// 2. Base URL: https://www.torrentcdn.store/v1
//    (include /v1 — Cline appends only /models to what you type)
// 3. API Key: YOUR_API_KEY
// 4. Model ID: llama-3.1-8b-instruct
// 5. Save, then send a short prompt to check the connection.

Continue

# Continue — config.yaml
name: tcdn
version: 1.0.0
schema: v1
models:
  - name: TCDN-AI llama-3.1-8b-instruct
    provider: openai
    model: llama-3.1-8b-instruct
    apiBase: https://www.torrentcdn.store/v1
    apiKey: YOUR_API_KEY
    roles: [chat, edit, apply]

OpenCode

// opencode.json ($XDG_CONFIG_HOME/opencode/opencode.json or ./opencode.json)
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "tcdn": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "TCDN-AI",
      "options": { "baseURL": "https://www.torrentcdn.store/v1", "apiKey": "YOUR_API_KEY" },
      "models": { "llama-3.1-8b-instruct": { "name": "llama-3.1-8b-instruct" } }
    }
  }
}

04Questions

Are my prompts stored?
No. The gateway records token counts, price, model, timing, host and job status — not the prompt or the output text. A host holds a job in memory while it runs and returns a receipt for the tokens; the console has nothing to show you because it keeps nothing.
How is it priced?
Per million input tokens and per million output tokens, per model. The console’s models page lists the current prices for each model, including any launch pricing and when it ends. Nothing here compares to another provider’s prices — the models page is the price list.
How do I pay?
Credit packs are bought in the console. Credit is denominated in USD, and each pack is priced in Kenyan shillings with the dollar equivalent shown. Cards work today. M-Pesa is coming: it is not enabled on our payment account yet, so it cannot be selected. During the alpha, purchases on this deployment run in test mode — checkout says which mode your account is in, and nothing is charged in test mode.
Who runs the models?
The design is people and small operators running the model on their own GPUs in their own locations, which is why the network could reach beyond one datacenter’s regions. Host onboarding is not open yet and the host agent is still in development — the section below is where that starts.
Can I send sensitive data?
Not in the alpha. Requests travel over TLS and a host only receives a job after verifying a short-lived ticket for it, but the prompt is processed in plaintext by the host that runs it, and the confidential tier is not available. Treat the alpha as suitable for non-sensitive work only.
What happens when a host disappears mid-job?
The request fails while it is in flight. The credit held for it is released when the job expires without a receipt, so you are not charged for tokens the gateway never received. Retrying is up to you: if the response had already started streaming it ends there, and the API does not silently re-run a request your client already treats as failed.

05Have a GPU?

Want to earn with your GPU? Hosts coming soon

The host agent is in development. When it ships, a host will run the model on its own hardware and be credited a share of every job it completes, booked in the same ledger the customer pays into. There is no withdrawal route for host earnings yet, and no public process to join — onboarding is not open. Ask to be told when it is.

TCDN-AI — an OpenAI-compatible API built for a peer-to-peer GPU network | TorrentCDN