Build with the Memcode Router.

Ask your Memcode administrator for a router key. It starts withsm-openai-, sm-gemini-, or sm-anthropic-, followed by 32 lowercase hexadecimal characters, and is shown only once when it is created. The provider in the prefix determines which models the key can call. Keep it in an environment variable on your server. Never ship it in frontend JavaScript.

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MEMCODE_API_KEY,
  baseURL: "https://api.memcode.in/v1",
});

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: "Explain vector databases in one paragraph.",
  max_output_tokens: 256,
});

console.log(response.output_text);

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["MEMCODE_API_KEY"],
    base_url="https://api.memcode.in/v1",
)

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain vector databases in one paragraph.",
    max_output_tokens=256,
)

print(response.output_text)

cURL

curl https://api.memcode.in/v1/responses \
  -H "Authorization: Bearer $MEMCODE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "input": "Explain vector databases in one paragraph.",
    "max_output_tokens": 256
  }'

Send the router key as a Bearer token on every API request. The key identifies its owner, budget, status, and rate-limit bucket.

Authorization: Bearer $MEMCODE_API_KEY

• Keys are case-sensitive and cannot be recovered later.
• Do not put a key in a URL, query string, browser bundle, or log.
• Revoked keys cannot generate, but can still read their final balance.
• Do not use the upstream OpenAI key; use only your Memcode router key.

The router intentionally implements a small, documented subset of the OpenAI API. It is not a transparent proxy for every OpenAI feature.

The Responses API is OpenAI-only: Gemini and Anthropic keys can use POST /v1/chat/completions only. Unknown routes and wrong methods return a structured404 unknown_endpoint response.

Use POST /v1/responses for new integrations. The router accepts string input or a non-empty array of text messages, Codex agent messages, encrypted reasoning history, and client tool call/output items.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.MEMCODE_API_KEY,
  baseURL: "https://api.memcode.in/v1",
});

const response = await client.responses.create({
  model: "gpt-5.6-terra",
  input: "Explain vector databases in one paragraph.",
  max_output_tokens: 256,
});

console.log(response.output_text);

Existing text-only Chat Completions clients can usePOST /v1/chat/completions. Messages must be non-empty and text-only.

const completion = await client.chat.completions.create({
  model: "gpt-5.6-luna",
  messages: [
    { role: "system", content: "Be concise." },
    { role: "user", content: "What is retrieval-augmented generation?" },
  ],
  max_completion_tokens: 256,
});

console.log(completion.choices[0].message.content);

• Use max_completion_tokens from 1 to 16,384.
• Legacy max_tokens is normalized unless it conflicts with max_completion_tokens.
• n may be 1 to 8. Budget reservation scales with output cap × n.
• Function tools are supported; hosted provider tools are not.

Set stream: true. The router forwards OpenAI's SSE stream while inspecting the final usage event so it can settle the reservation.

const stream = await client.responses.create({
  model: "gpt-5.6-terra",
  input: "Count from one to five.",
  max_output_tokens: 64,
  stream: true,
});

for await (const event of stream) {
  if (event.type === "response.output_text.delta") {
    process.stdout.write(event.delta);
  }
}

Only the exact IDs below are accepted. The selected ID is forwarded unchanged, with no rewrites or silent fallbacks. A key's provider — visible in its sm-<provider>- prefix — determines which models it can call, and Gemini and Anthropic models are available on /v1/chat/completions only.

Use the dashboard's Check Balance page or call the endpoint directly. This request does not call OpenAI or reserve budget, but it does consume request rate-limit capacity.

curl https://api.memcode.in/user/balance \
  -H "Authorization: Bearer $MEMCODE_API_KEY"

{
  "budgetLimit": 10,
  "balanceUsed": 1.25,
  "balanceReserved": 0.05,
  "remaining": 8.7,
  "isActive": true
}

Before contacting OpenAI, the router estimates a conservative maximum cost and atomically reserves it in PostgreSQL. A request is admitted only while:

balance_used + balance_reserved ≤ budget_limit

1. The output cap, number of choices, body size, and configured rates determine the reservation.
2. Concurrent requests reserve under a row lock, so they cannot collectively pass the key budget.
3. Valid token usage settles the actual charge and releases the unused portion.
4. Missing usage, ambiguous upstream delivery, timeout, or stream interruption charges the full reservation.

Not supported

• Images, audio, files, and non-text modalities.
• Built-in/provider tools, web search, or web_search_options.
• Background responses, hosted prompts, or conversations.
• previous_response_id, prediction, or non-default service tiers.
• x-goog-* headers and browser calls from any Origin other than https://router.memcode.in. Server-side calls without an Origin header are accepted.

Fields outside this documented subset are not a compatibility promise. OpenAI may accept or reject forwarded fields.

Requests pass through pre-authentication and authenticated token buckets. Limits are configurable, so clients should react to response headers instead of hard-coding current values.

Useful headers

• x-ratelimit-remaining-requests
• x-ratelimit-remaining-global-requests
• x-ratelimit-reset-requests-ms
• retry-after on retryable limiter responses
• x-router-request-id on every response

Errors use an OpenAI-style envelope with a stable router code.

{
  "error": {
    "message": "The requested model is not supported or priced by this gateway.",
    "type": "invalid_request_error",
    "param": "model",
    "code": "unsupported_model"
  }
}

Include x-router-request-id when asking the operator for help. Upstream error bodies are sanitized and are not passed through verbatim.

• Keep router keys only in server-side secrets.
• Set a small explicit output-token cap.
• Use HTTPS and never disable TLS verification.
• Honor 429 Retry-After and use bounded backoff.
• Log x-router-request-id, never the API key.
• Check balance before large or parallel jobs.
• Do not assume retries are idempotent.
• Rotate a key immediately if it is exposed.

For SDK installation and general OpenAI API concepts, see the official OpenAI quickstart. Memcode's supported subset and budget rules on this page take precedence for this gateway.