One company key, every tool

1. Mint a key

Company admins create keys under Profile → API Keys. The raw key is shown once — copy it into your environment, never into source control.

2. Call the REST API

The endpoint is OpenAI-compatible: only the base URL and the key change.

# pip install openai
from openai import OpenAI

client = OpenAI(api_key="sk-...", base_url="https://api.aiqlick.com/llm/v1")

response = client.chat.completions.create(
    model="<model-alias>",
    messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)

3. Connect Claude Code and MCP apps

Point any Streamable-HTTP MCP client at the same origin plus /mcp. The key authenticates and bills exactly like the REST API.

# The key stays in your shell env, never in the repo
export AIQLICK_API_KEY="sk-..."

claude mcp add --transport http aiqlick https://api.aiqlick.com/llm/v1/mcp \
  --header "Authorization: Bearer $AIQLICK_API_KEY"

# Verify inside Claude Code: /mcp should list aiqlick with chat + list_models.
# Then ask it to call chat with model "<model-alias>".

4. Test it

Probe the handshake, list the tools, then make the first chat call — same key, three curl commands.

5. Billing and rotation

Every call lands in API consumption on the same settings page. Rotation mints a sibling and leaves the old key live — deploy the new one, watch the old key go quiet, then revoke it.

Reference: endpoints

Endpoints across inference, parsing, recruitment data, and usage tracking on the same base URL. Bodies are forwarded as received, so provider-specific fields keep working without a client update.

Key scopes & permissions

Granular permissions control what each key can access. Configure scopes when minting a key in company settings.

Model Context Protocol (MCP) tools

When connected via MCP streamable HTTP, the server registers the following tools according to your key's scopes:

Streaming

Set "stream": true and the response arrives chunk by chunk. The server always merges stream_options.include_usage into streaming requests — without the usage block a call cannot be billed, so a stream that ends without one is recorded as a failure and not charged.

Errors

Every failure uses the OpenAI error envelope: {"error": {"message", "type", "code"}}. Match on code, not on words.

Rate limits

600 requests per minute per client IP, plus per-key RPM and TPM limits enforced at the gateway. The IP bucket is shared by customers behind the same egress address, which is why the IP limit sits far above any single-tenant rate.

Client libraries

Thin wrappers over the official OpenAI SDK — same calls, with the base URL and model aliases built in. You never need them; the official SDK works directly.

# pip install aiqlick
from aiqlick import AIQLick, Models

client = AIQLick(api_key="sk-...")  # or set AIQLICK_API_KEY

reply = client.chat.completions.create(
    model=Models.CHAT_DEFAULT,
    messages=[{"role": "user", "content": "hello"}],
)
print(reply.choices[0].message.content)

# npm install @aiqlick/inference openai
import { AIQLick, Models } from "@aiqlick/inference";

const client = new AIQLick({ apiKey: process.env.AIQLICK_API_KEY });

const reply = await client.chat.completions.create({
  model: Models.CHAT_DEFAULT,
  messages: [{ role: "user", content: "hello" }],
});
console.log(reply.choices[0]?.message?.content);

Model aliases

Call aliases, never provider ids — the mapping can change without you changing code. A key scoped to a subset can only call that subset; list_models (REST: GET /models) shows exactly what your key may use.

• aiqlick/chat-premium
• aiqlick/chat-default
• aiqlick/chat-cheap
• aiqlick/extract-default
• aiqlick/extract-fast
• aiqlick/embed-default

Troubleshooting