| Mode | loading... |
| Storage | loading... |
| API keys | loading... |
| Request records | loading... |
| Total tokens | loading... |
| Key | loading... |
| State | loading... |
Verified benchmark captures are not yet available for this model.
Verified benchmark captures are not yet available for this model.
Verified benchmark captures are not yet available for this model.
List models — GET /models
// Fetch all discoverable models with live pricing and limits
const res = await fetch('https://aurelo.tech/models', {
headers: { 'Authorization': `Bearer ${process.env.AURELO_API_KEY}` }
});
const { data } = await res.json();
// Inspect a model
const m2 = data.find(m => m.id === 'gpt-5.5');
console.log(m2.max_input_tokens); // 1000000
console.log(m2.pricing.input_usd_per_million_tokens); // 4
console.log(m2.pricing.large_context_threshold_tokens); // 250000
console.log(m2.cache.live_time_seconds); // 1800
// Fetch a single model by id
const single = await fetch('https://aurelo.tech/v1/models/gpt-5.5', {
headers: { 'Authorization': `Bearer ${process.env.AURELO_API_KEY}` }
}).then(r => r.json());| Field | Type | Description |
|---|---|---|
id | string | Model identifier to use in requests (e.g. gpt-5.5) |
description | string | Human-readable model description |
pricing.input_usd_per_million_tokens | number | Input cost in USD per 1M tokens up to 250k input tokens |
pricing.output_usd_per_million_tokens | number | Output cost in USD per 1M tokens up to 250k input tokens |
pricing.large_context_input_usd_per_million_tokens | number | Input cost in USD per 1M tokens when request input is above 250k tokens |
pricing.large_context_output_usd_per_million_tokens | number | Output cost in USD per 1M tokens when request input is above 250k tokens |
pricing.large_context_threshold_tokens | number | Automatic pricing threshold: 250000 |
pricing.cache_read_usd_per_million_tokens | number | Always 0 — cached reads are free |
cache.live_time_seconds | number | Cache TTL in seconds: 1800 |
reasoning.parameter | string | Gemini request field: generation_config.thinking_level. |
reasoning.options | string[] | Available Gemini thinking levels: low, medium, and high. |
reasoning.default | string | Gemini thinking level used when omitted: high. |
reasoning.modes | string[] | Available execution modes for gpt-5.6-luna: standard and pro |
reasoning.mode_default | string | Execution mode used when omitted: standard |
max_input_tokens | number | Maximum input context for this model |
max_output_tokens | number | Maximum output tokens the model will generate |
Each listed model ID is the exact routed model name accepted by the stateless Responses endpoint. The gateway preserves the request model, supported tools, response events, and standard token-usage shape while applying its documented security filters.
GET /v1/models lists gemini-3.1-pro-preview, gemini-3.7-flash, and gemini-3.8-flash. Use GET /models for the detailed catalog, including gpt-5.5 and gpt-5.6-luna, pricing, limits, and thinking settings. GET /v1/models/:id returns a single model. These endpoints require an API key in the Authorization header.
Authentication
await fetch('https://aurelo.tech/v1/responses', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.AURELO_API_KEY}`
},
body: JSON.stringify({ /* request body */ })
});Generate API keys in the API Keys view in the sidebar. Pass your key as a Bearer token in the Authorization header on every request to https://aurelo.tech. Store your key in an environment variable or secrets manager — never commit it to source control. Revoke a key immediately if it is ever exposed.
Quick start
await fetch('https://aurelo.tech/v1/responses', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.AURELO_API_KEY}`
},
body: JSON.stringify({
model: 'gpt-5.5',
instructions: 'You are a precise coding assistant.',
input: [{
role: 'user',
content: [{ type: 'input_text', text: 'Review this component.' }]
}],
temperature: 0.4,
max_output_tokens: 4096,
text: { verbosity: 'medium' },
reasoning: { summary: 'auto' }
})
});Minimum working request. Requests may set temperature, max_output_tokens up to 128,000 for GPT models or 65,536 for Gemini models, text.verbosity, reasoning.summary, and supported reasoning.mode values. Public response objects reflect the selected max_output_tokens, report the service_tier returned for the actual request, and report store: false. When you send instructions or a system/developer input turn, the public response may reflect that client-supplied text in response.instructions; gateway instructions are never included. The role field marks who authored a turn. Streaming is used unless stream: false is sent explicitly.
Reasoning
{
"model": "gemini-3.1-pro-preview",
"service_tier": "standard",
"generation_config": {
"thinking_level": "high"
},
"input": [{
"role": "user",
"content": [{ "type": "input_text", "text": "Trace and fix this concurrency bug." }]
}]
}| Field | Models | Values | Use |
|---|---|---|---|
generation_config.thinking_level | Gemini models | low / medium / high | Controls thinking depth. high is used when omitted. |
reasoning.mode | gpt-5.6-luna | standard / pro | Selects the execution mode. standard is used when omitted. |
reasoning.summary | All models | auto / concise / detailed | Controls the streamed reasoning summary. |
gpt-5.6-luna accepts reasoning.mode; omit it for standard, or set pro. Gemini models use generation_config.thinking_level with low, medium, or high; the default is high. Gemini requests use service_tier: standard by default. Invalid or unsupported values return 400 with invalid_request.
File input
{
"model": "gpt-5.5",
"input": [{
"role": "user",
"content": [
{ "type": "input_text", "text": "Review this PDF." },
{ "type": "input_file", "file_data": "data:application/pdf;base64,..." }
]
}]
}Use input_file with file_data as a data URI (base64) alongside input_text to send documents, PDFs, or code files. Each model supports up to 1mil input tokens and automatically applies large-context pricing above 250k input tokens.
Zero data retention
Aurelo uses zero data retention for model processing. Prompts, files, images, tool results, and generated outputs sent through the model execution path are not retained for model training.
Aurelo still keeps the operational records required to run the gateway: authentication state, request status, timestamps, usage, billing, prompt-cache accounting, and dashboard history.
Response continuation and cache
Every successful response includes a gateway-generated resp_... ID. To continue it, send that value as top-level previous_response_id with only the new input.
- For streaming requests, the same response ID appears in
response.created.response.idandresponse.completed.response.id. - For non-streaming requests, read the top-level
idfield. - The gateway privately retrieves the referenced response, rebuilds its full context, appends the new input, and sends that reconstructed context for processing.
previous_response_idis not forwarded upstream and provider-generated response IDs are not exposed.- Each successful continuation returns a new response ID that remains usable for
30 minutesfrom that response's completion. - Cached prompt tokens are shown as cached usage and billed at
$0.00 / 1M tokens. - Treat the response ID as a private bearer reference while it is valid.
{
"model": "gemini-3.7-flash",
"previous_response_id": "resp_0123456789abcdef0123456789abcdef",
"input": "Now turn that plan into an implementation checklist."
}Photo and image input
{
"model": "gpt-5.5",
"input": [{
"role": "user",
"content": [
{ "type": "input_text", "text": "Describe this photo." },
{ "type": "input_image", "image_url": "https://example.com/photo.jpg" }
]
}]
}
{ "type": "input_image", "image_url": "data:image/jpeg;base64,..." }Use an image/* MIME type such as image/jpeg, image/png, or image/webp. Include a text instruction with every image.
Response object shape
{
"id": "resp_...",
"object": "response",
"status": "completed",
"model": "gpt-5.5",
"service_tier": "default",
"store": false,
"output": [{
"type": "message",
"role": "assistant",
"content": [
{ "type": "output_text", "text": "Here is the plan..." }
]
}],
"usage": {
"input_tokens": 1200,
"input_tokens_details": {
"cached_tokens": 900,
"cache_write_tokens": 0
},
"output_tokens": 240,
"output_tokens_details": { "reasoning_tokens": 48 },
"total_tokens": 1440
}
}Completed response objects and output items use this shape. For simple text replies, read output message items and then read their content parts with type: 'output_text'; use each part's text field (there may be multiple output items or tool calls).
Final token usage is returned on response.completed.response.usage using the standard Responses shape. Provider identifiers and internal usage payloads are not exposed. Public responses report the service_tier returned for the actual request, report store: false, and keep input_tokens_details.cache_write_tokens at 0.
Streaming events
| Event | Meaning |
|---|---|
response.created | Generation started. |
response.output_text.delta | New text chunk in delta. |
response.output_text.done | Current text output completed. |
response.output_item.done | A complete output item is available. |
response.reasoning_summary_text.done | A sanitized reasoning summary is complete. |
response.function_call_arguments.done | A client function tool call is ready to execute. |
response.mcp_call_arguments.done | An external MCP tool call is ready; gateway-registered tools are emitted as normal function calls. |
response.completed | The full response is complete; final token usage is in response.usage. |
response.incomplete | The stream ended after partial output; available output and usage are included. |
These events apply to the default streaming mode. With stream: false, the gateway performs the same streamed processing internally and returns one response object containing output and final standard usage.
Stream consumer
const res = await fetch('https://aurelo.tech/v1/responses', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.AURELO_API_KEY}`
},
body: JSON.stringify({
model: 'gpt-5.5',
input: [{ role: 'user', content: [{ type: 'input_text', text: 'Draft release notes.' }] }]
})
});
const reader = res.body.getReader();
const decoder = new TextDecoder();
let text = '';
let buffer = '';
while (true) {
const { done, value } = await reader.read();
if (done) break;
buffer += decoder.decode(value);
const blocks = buffer.split('\n\n');
buffer = blocks.pop() || '';
for (const block of blocks) {
const dataLine = block.split('\n').find(line => line.startsWith('data: '));
if (!dataLine) continue;
const event = JSON.parse(dataLine.slice(6));
if (event.type === 'response.output_text.delta') text += event.delta || '';
if (event.type === 'response.completed' || event.type === 'response.incomplete') console.log('done', text);
if (event.object === 'error') throw new Error(event.error?.message || event.message || 'Aurelo response failed');
}
}Send a follow-up with context
{
"model": "gpt-5.5",
"instructions": "Answer as a senior engineer. Be direct and specific.",
"input": [
{ "role": "user", "content": [{ "type": "input_text", "text": "We need usage-based billing." }] },
{ "role": "assistant", "content": [{ "type": "output_text", "text": "Define events, metering, and invoice rules." }] },
{ "role": "user", "content": [{ "type": "input_text", "text": "Now write the implementation checklist." }] }
]
}Send only the prior turns and context that matter for the next answer. The model stays stateless while still receiving the exact conversation context you choose. If the model outputs a tool call, your app executes it locally, appends the result to the context, and creates a new response.
Timeouts & retry
// Simple exponential back-off retry helper
async function withRetry(fn, retries = 3, delay = 500) {
for (let i = 0; i < retries; i++) {
try { return await fn(); }
catch (e) {
const retryable = e.status === 429 || e.status >= 500;
if (i === retries - 1 || !retryable) throw e;
await new Promise(r => setTimeout(r, delay * 2 ** i));
}
}
}
// Usage - fetch() only throws on network failure, so check response.ok
// and attach a .status yourself for the retry helper to branch on.
const result = await withRetry(async () => {
const response = await fetch('https://aurelo.tech/v1/responses', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.AURELO_API_KEY}`
},
body: JSON.stringify({
model: 'gpt-5.5',
input: [{ role: 'user', content: [{ type: 'input_text', text: 'Hello.' }] }]
})
});
if (!response.ok) {
const error = new Error(`Request failed with status ${response.status}`);
error.status = response.status;
throw error;
}
return response;
});Treat 429 and 5xx errors as transient and safe to retry with back-off. Treat other 4xx errors as permanent — retrying them will not help. Use a generous request timeout on the fetch/http layer because successful responses are streamed.
Error format
{
"ok": false,
"object": "error",
"error": "The model requested does not exist.",
"code": "model_not_found",
"message": "Use one of the listed public model ids."
}HTTP validation, authentication, rate-limit, and routing errors return ok: false and object: "error". Successful completions use object: "response". Branch on code (or HTTP status), not on the presence of output.
All error responses share this shape. Use code for branching, message for developer-facing detail, and error for the short summary.
HTTP / curl
curl https://aurelo.tech/v1/responses \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $AURELO_API_KEY" \
-d '{
"model": "gpt-5.5",
"instructions": "You are a precise coding assistant.",
"input": [{
"role": "user",
"content": [{"type": "input_text", "text": "Write a migration plan."}]
}]
}'Raw HTTP supported: POST /v1/responses accepts raw HTTP requests without client metadata. Start with ordinary input; for a follow-up, send the prior gateway response ID in previous_response_id and include only the new input.
Pass your API key in the Authorization header as Bearer <key>. Streaming is the default: consume the text/event-stream response body and read final token usage and the reusable response ID from response.completed.response. To receive one JSON response instead, send "stream": false.
Common errors
| Code | Fix |
|---|---|
model_not_found | Use one of the listed public model ids. |
model_input_limit_exceeded | Reduce input below the model context limit. |
invalid_request | Use input with supported content parts on /v1/responses. |
unauthorized | Check the AURELO_API_KEY used in your Authorization header. |
Model pricing
| Model | Input ≤250k | Output ≤250k | Input >250k | Output >250k | Cached input | Max input | Max output |
|---|---|---|---|---|---|---|---|
| Loading live model pricing... | |||||||
All prices are USD per million tokens. The higher tier applies automatically when total request input is above 250k tokens. Cached prompt tokens remain free and do not reset the context cache.
Billing and cache rules
- Cached prompt tokens are billed at
$0.00 / 1M tokens. - Continuation TTL means time-to-live: each successful response ID remains usable for
30 minutesfrom that response's completion. - After TTL expiry, the response ID can no longer retrieve its saved context.
- This is a cache lifetime, not hidden model memory.
- Usage reflects processed input, generated output, and cache behavior.
- Start a new response with complete context, or continue a saved response by sending its ID as
previous_response_id.