API DOCUMENTATION CENTER

Provider documentation: models, APIs and integrations.

Access GPT, Claude, Gemini, DeepSeek and Qwen models through one key and compatible endpoints.

View models Sign in

Sections11

Procedures54

Formats8

LanguageEN

RECOMMENDED JOURNEY

From an API key to the first request.

Follow these sections to connect your tools and monitor usage.

01CreateCreate a key and choose a model.

02ConnectConfigure OpenAI, Anthropic or Codex.

03MonitorReview logs, pricing and limits.

SERVICE ARCHITECTURE

One gateway, multiple official formats.

ACLIDE routes requests through configured providers while presenting models, costs and limits consistently.

API key

Bearer authentication and immediate revocation.

Catalog

Models and capabilities in one place.

Formats

OpenAI Responses and Anthropic Messages.

Routing

Automatic selection of an available route.

Logs

Tokens, status and cost for each request.

Billing

Credits, prices and plan limits.

Security

Upstream provider keys remain server-side. Never include an API key or sensitive prompt in a support ticket or screenshot.

Check an API key

This check only calls GET /v1/models. The key is never stored and is cleared after the test.

01 / GUIDE

Connect an application

Create a key and send your first request to the available models.

Create a key
Choose an endpoint
Verify a response

Step by step

01
Create an API key
In the dashboard, open API keys, enter a clear name and copy the secret once.
The secret starts with aclide_sk_. It is not shown again after you close the creation screen.
02
Verify the key
Use the verifier above or call GET /v1/models. A 200 response confirms that the key, account and plan are active.
cURL
```
curl https://aclide.com/v1/models \
  -H \"Authorization: Bearer $ACLIDE_API_KEY\"
```
03
Choose a model
Copy an identifier marked as available in /v1/models. The catalog depends on your plan.
04
Install the server SDK
For a Node.js website, install the official OpenAI SDK in your backend. Never call ACLIDE directly from browser code.
Shell
```
npm install openai
```
05
Create the ACLIDE client
Store ACLIDE_API_KEY in your host's secret settings and configure the OpenAI-compatible base URL.
TypeScript (server)
```
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.ACLIDE_API_KEY,
  baseURL: "https://aclide.com/v1",
});
```

Call Responses from a server route

Your frontend calls your own /api/chat route; only that server route contacts ACLIDE.

TypeScript (server)

const response = await client.responses.create({
  model: "CATALOG_MODEL",
  input: message,
});

return Response.json({ text: response.output_text });

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

02 / GUIDE

API keys and security

Manage, rotate and revoke secrets without exposing your credentials.

Restrict access
Revoke a key
Protect secrets

Step by step

01
Name each key
Use one name per project so its activity is easy to identify in logs.
02
Revoke immediately
Open API keys and select Revoke. Every new request using that key is then rejected.
03
Keep keys server-side
Keys must never appear in client code, screenshots or logs.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

03 / GUIDE

Model catalog

Explore the available GPT, Claude, Gemini, DeepSeek, Qwen and other model families.

Compare models
Review capabilities
Choose the right plan

Step by step

01
Open the catalog
The Models page lists the identifier, family, capabilities and exact price of every model.
02
Filter by capability
Filter models by reasoning, vision, tools or speed.
03
Use the exact identifier
Copy the displayed public model ID into your requests.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

04 / GUIDE

OpenAI format

Connect Responses, Cursor, ChatBox and compatible OpenAI SDKs.

Configure the SDK
Enable streaming
Handle errors

Step by step

01
Set the base URL
Use https://aclide.com/v1 with the OpenAI SDK and your ACLIDE_API_KEY.
02
List available models
Call client.models.list() first and use an identifier allowed for your account.
03
Use Responses
Call client.responses.create with model and input. ACLIDE does not expose Chat Completions.
04
Handle status codes
401 means an invalid or revoked key; 403 an inactive plan; 429 a temporary limit; and 5xx a retryable outage.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

05 / GUIDE

Anthropic format

Use the native Messages API with Claude Code, Cline and Anthropic SDKs.

Configure Messages
Use tools
Enable vision

Step by step

01
Set the credentials
Use ANTHROPIC_AUTH_TOKEN for your ACLIDE key and ANTHROPIC_BASE_URL=https://aclide.com.
02
Use Messages
Call POST https://aclide.com/v1/messages with the Authorization header generated by the Anthropic client.
03
Choose a Claude model
Select a Claude model visible in GET /v1/models and allowed by your plan.
04
Test before streaming
Send one request without streaming, then enable stream: true after receiving valid JSON.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

06 / GUIDE

Codex CLI

Configure the official Codex package with ACLIDE's Responses-compatible provider.

Install Codex
Configure config.toml
Launch Codex

Step by step

01
Install Codex on Windows
Install the official @openai/codex package with npm, then reopen PowerShell.
PowerShell
```
npm install -g @openai/codex
codex --version
```

Prepare the .codex directory

Create the user directory and back up any existing configuration files.

PowerShell

New-Item -ItemType Directory -Force ~/.codex | Out-Null
Copy-Item ~/.codex/auth.json ~/.codex/auth.json.backup -ErrorAction SilentlyContinue
Copy-Item ~/.codex/config.toml ~/.codex/config.toml.backup -ErrorAction SilentlyContinue

03
Choose an included GPT model
In Dashboard > Models, filter included models and copy a GPT identifier. Codex uses the Responses API.
04
Create auth.json
Create auth.json in ~/.codex. Replace YOUR_ACLIDE_KEY with the key created in the dashboard and never commit this file.
~/.codex/auth.json
```
{
  "OPENAI_API_KEY": "YOUR_ACLIDE_KEY"
}
```

Create config.toml

Create config.toml in the same directory. This configuration uses ACLIDE's Responses endpoint.

~/.codex/config.toml

model_provider = "aclide"
model = "gpt-5.6-sol"
model_reasoning_effort = "high"
disable_response_storage = true
preferred_auth_method = "apikey"

[model_providers.aclide]
name = "ACLIDE"
base_url = "https://aclide.com/v1"
wire_api = "responses"
requires_openai_auth = true
request_max_retries = 4
stream_max_retries = 5

06
Run a real ACLIDE test
Run this command in a project directory. The exact response validates the key, model, Responses and streaming.
PowerShell / Terminal
```
codex exec --skip-git-repo-check "Reply exactly: ACLIDE CODEX OK"
```
07
Start Codex
Launch the interactive interface in any repository. Requests are sent through https://aclide.com/v1/responses.
PowerShell / Terminal
```
codex
```
08
Fix common errors
Reopen the terminal when the command is missing. For 401, fix auth.json; for 404, choose a model marked Included.
PowerShell
```
npm update -g @openai/codex
codex --version
```

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

07 / GUIDE

OpenCode

Install OpenCode and declare ACLIDE as a custom Responses provider.

Install OpenCode
Create opencode.json
Choose a model

Step by step

01
Install OpenCode
Install the CLI and verify that the command is available.
PowerShell / Terminal
```
npm install -g opencode-ai
opencode --version
```
02
Load the ACLIDE key
Keep the key outside the JSON file. OpenCode reads ACLIDE_API_KEY when it starts.
PowerShell
```
$env:ACLIDE_API_KEY = "YOUR_ACLIDE_KEY"
```

List allowed models

Copy the exact identifier of a model available on your plan.

PowerShell

$headers = @{ Authorization = "Bearer $env:ACLIDE_API_KEY" }
(Invoke-RestMethod https://aclide.com/v1/models -Headers $headers).data |
  Where-Object available | Select-Object id

Create opencode.json

Add this file to the project. The @ai-sdk/openai package uses ACLIDE's Responses API.

opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "model": "aclide/AVAILABLE_MODEL",
  "provider": {
    "aclide": {
      "npm": "@ai-sdk/openai",
      "name": "ACLIDE",
      "options": {
        "baseURL": "https://aclide.com/v1",
        "apiKey": "{env:ACLIDE_API_KEY}"
      },
      "models": {
        "AVAILABLE_MODEL": { "name": "ACLIDE - primary model" }
      }
    }
  }
}

05
Verify the model
Start OpenCode, open the model list and select ACLIDE. The configured ID must match the catalog.
OpenCode
```
opencode
# In OpenCode: /models
```
06
Test and diagnose
Send a short prompt. For 401 check the key; for 404 correct the model ID; if ACLIDE is missing, validate the JSON.
PowerShell
```
opencode auth list
```

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

08 / GUIDE

Claude Code

Connect Claude Code to ACLIDE's compatible Messages endpoint.

Choose a client
Set the base URL
Validate streaming

Step by step

01
Install Claude Code on Windows
Install the official CLI with npm. Claude Code requires Git for Windows or WSL.
PowerShell
```
npm install -g @anthropic-ai/claude-code
claude --version
claude doctor
```

Prepare the configuration directory

Create ~/.claude and back up the existing settings file.

PowerShell

New-Item -ItemType Directory -Force ~/.claude | Out-Null
Copy-Item ~/.claude/settings.json ~/.claude/settings.json.backup -ErrorAction SilentlyContinue

03
Choose included models
In Dashboard > Models, filter included Claude models and copy their public identifiers.

Create settings.json

Create ~/.claude/settings.json. Claude Code uses ACLIDE's Anthropic Messages endpoint, not the Codex Responses configuration.

~/.claude/settings.json

{
  "env": {
    "ANTHROPIC_API_KEY": "YOUR_ACLIDE_KEY",
    "ANTHROPIC_BASE_URL": "https://aclide.com",
    "ANTHROPIC_MODEL": "claude-sonnet-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5-20251001",
    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-haiku-4-5-20251001",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
    "CLAUDE_CODE_SUBPROCESS_ENV_SCRUB": "1"
  },
  "model": "sonnet",
  "effortLevel": "high"
}

05
Close an existing Anthropic session
If Claude Code still uses a connected Anthropic subscription, sign out once and restart it.
Claude Code
```
claude auth logout
```
06
Run a real test
Non-interactive mode must return the requested text exactly. This validates Messages, the key, model and streaming.
PowerShell / Terminal
```
claude -p "Reply exactly: ACLIDE CLAUDE OK"
```
07
Start Claude Code
Launch Claude Code normally in the project. A 401 means the key is invalid; a model error means it is not included in the plan.
PowerShell / Terminal
```
claude
```

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

09 / GUIDE

Logs and usage

Track requests, costs, models and limits from the dashboard.

Read a log
Understand a cost
Diagnose an error

Step by step

01
Filter requests
Filter by key, model, status, period and API format.
02
Compare tokens and prices
Each row shows token counts, the route multiplier and billed cost.
03
Analyze a failure
Use the HTTP status and request ID without sharing the prompt.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

10 / GUIDE

Pricing, credits and limits

Understand monthly, quarterly and annual plans, credits and multipliers.

Compare plans
Review limits
Track credits

Step by step

01
Choose a billing period
The monthly, quarterly and annual selector displays the price and discount.
02
Understand routing costs
Each model card displays its exact input, cache and output pricing.
03
Monitor the balance
The dashboard shows remaining credits, renewal and alerts.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

11 / GUIDE

API troubleshooting

Quickly resolve authentication, quota, model and network errors.

Identify the status code
Check the configuration
Contact support

Step by step

01
Read the HTTP status
401 invalid key, 402 insufficient balance, 404 unknown endpoint or model, 429 limit, 503 temporary outage.
02
Retry a minimal request
Remove tools and conversation history, then test a basic model.
03
Share a safe diagnostic
Provide the request ID, time and HTTP status, never the key or sensitive content.

Tips

Keep keys server-side and use the official model catalog.

Checks

The configuration is valid
No secret is exposed

QUICK HELP

Essential answers.

Answers to the most common API questions.

Where do I create an API key?

Open API keys in the dashboard and select Create a key.

How do I protect secrets?

Keep them server-side, revoke exposed keys and never place them in Git or browser code.

READY TO START

Connect your first tool.

Create a key, choose a model and send a test request.

View models Open dashboard

Provider documentation: models, APIs and integrations.

From an API key to the first request.

API key

Catalog

Formats

Routing

Logs

Billing

Step by step

Create an API key

Verify the key

Choose a model

Install the server SDK

Create the ACLIDE client

Call Responses from a server route

Step by step

Name each key

Revoke immediately

Keep keys server-side

Step by step

Open the catalog

Filter by capability

Use the exact identifier

Step by step

Set the base URL

List available models

Use Responses

Handle status codes

Step by step

Set the credentials

Use Messages

Choose a Claude model

Test before streaming

Step by step

Install Codex on Windows

Prepare the .codex directory

Choose an included GPT model

Create auth.json

Create config.toml

Run a real ACLIDE test

Start Codex

Fix common errors

Step by step

Install OpenCode

Load the ACLIDE key

List allowed models

Create opencode.json

Verify the model

Test and diagnose

Step by step

Install Claude Code on Windows

Prepare the configuration directory

Choose included models

Create settings.json

Close an existing Anthropic session

Run a real test

Start Claude Code

Step by step

Filter requests

Compare tokens and prices

Analyze a failure

Step by step

Choose a billing period

Understand routing costs

Monitor the balance

Step by step

Read the HTTP status

Retry a minimal request

Share a safe diagnostic

Essential answers.

Connect your first tool.