Dedalus API

One API.
Every model.

A unified, model-agnostic gateway that routes to OpenAI, Anthropic, Google, and more. Add MCP tools from our marketplace with a single parameter.

Read the docs Get an API key

main.py

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

https://api.dedaluslabs.ai

How the API works

Your app talks to one endpoint. We handle authentication, provider routing, MCP tool execution, and streaming -- all behind a single OpenAI-compatible interface.

{ }

Your AppPython / TypeScript

Dedalus API

AuthAPI Keys & RBAC

RouterModel selection

MCPTool execution

StreamSSE responses

AI Providers

MCP Servers

Slack

GitHub

Notion

Linear

Request flow

Every major provider, one interface

Switch between models with a single parameter. No SDK changes, no provider-specific code. The same request format works everywhere.

OpenAI

GPT-5, o3, DALL-E, Whisper

Anthropic

Opus 4.6, Sonnet, Haiku

Google

Gemini 3.0 Flash, Pro

xAI

Grok 4, Grok 4 Mini

DeepSeek

Chat, Coder, Reasoner

Mistral

Large, Medium

Plus Groq, Fireworks, and more. New providers added regularly.

Everything you need in one gateway

Drop-in OpenAI compatibility plus the features you actually need for production agents.

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Dedalus Auth

Your secrets never leave your machine

DAuth is our managed authorization system. Remote MCP servers use your local credentials without ever seeing them -- credentials are isolated in a sealed execution boundary.

Zero secret leakage

Credentials are encrypted client-side and decrypted only inside a sealed execution boundary. Your code never sees raw secrets.

Sender-constrained tokens

Demonstrating Proof-of-Possession (DPoP) binds tokens cryptographically to the client. A stolen token is useless without the private key.

Networkless execution

Credential decryption and API calls happen entirely within an isolated enclave. Raw secrets never traverse the network.

Learn more about DAuth

Lifecycle of a request

Every API call follows the same five-stage pipeline. Click a stage to see what happens under the hood.

Authenticate

Validate API key, check org status, load tier limits and rate quotas.

Route

Select the target provider, map model parameters, apply BYOK overrides if present.

Execute tools

Resolve MCP slugs, establish server connections, run tool calls server-side.

Stream

SSE stream incremental deltas back to the client as they are generated.

Respond

Meter token usage, emit rate-limit headers, return the final structured response.

Hover or click a stage to see details

Start in minutes

Drop-in compatible with the OpenAI SDK. Switch your base URL and you're done.

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5",
    "messages": [
      {"role": "user", "content": "Search for the latest AI news"}
    ],
    "mcps": ["tsion/exa"],
    "stream": true
  }'

# Bring Your Own Key -- use your provider credentials
# while still leveraging MCP tools and streaming

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "X-Provider: anthropic" \
  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
  -H "X-Provider-Model: anthropic/claude-opus-4-6" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is the weather in Tokyo?"}
    ],
    "mcps": ["tsion/exa"]
  }'

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Endpoints at a glance

Chat completions, embeddings, image generation, audio, OCR, and more. Every endpoint follows the same auth and streaming patterns.

Core

POST/v1/chat/completionsChat with any model, stream responses, call MCP tools

GET/v1/modelsList all available models across providers

POST/v1/embeddingsGenerate vector embeddings with OpenAI or Google

Media

POST/v1/images/generationsGenerate images with DALL-E and GPT Image

POST/v1/audio/speechText-to-speech, transcription, and translation

POST/v1/ocrExtract text from images and documents

Management

POST/v1/private/keysCreate, rotate, and manage API keys

GET/v1/private/subscription/statusCheck subscription tier, rate limits, and usage

Ship your first request in 30 seconds

Get an API key, pick a model, attach MCP tools. That's it.

Get started Read the docs

Dedalus API

One API.
Every model.

A unified, model-agnostic gateway that routes to OpenAI, Anthropic, Google, and more. Add MCP tools from our marketplace with a single parameter.

Read the docs Get an API key

main.py

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

https://api.dedaluslabs.ai

How the API works

Your app talks to one endpoint. We handle authentication, provider routing, MCP tool execution, and streaming -- all behind a single OpenAI-compatible interface.

{ }

Your AppPython / TypeScript

Dedalus API

AuthAPI Keys & RBAC

RouterModel selection

MCPTool execution

StreamSSE responses

AI Providers

MCP Servers

Slack

GitHub

Notion

Linear

Request flow

Every major provider, one interface

Switch between models with a single parameter. No SDK changes, no provider-specific code. The same request format works everywhere.

OpenAI

GPT-5, o3, DALL-E, Whisper

Anthropic

Opus 4.6, Sonnet, Haiku

Google

Gemini 3.0 Flash, Pro

xAI

Grok 4, Grok 4 Mini

DeepSeek

Chat, Coder, Reasoner

Mistral

Large, Medium

Plus Groq, Fireworks, and more. New providers added regularly.

Everything you need in one gateway

Drop-in OpenAI compatibility plus the features you actually need for production agents.

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Dedalus Auth

Your secrets never leave your machine

DAuth is our managed authorization system. Remote MCP servers use your local credentials without ever seeing them -- credentials are isolated in a sealed execution boundary.

Zero secret leakage

Credentials are encrypted client-side and decrypted only inside a sealed execution boundary. Your code never sees raw secrets.

Sender-constrained tokens

Demonstrating Proof-of-Possession (DPoP) binds tokens cryptographically to the client. A stolen token is useless without the private key.

Networkless execution

Credential decryption and API calls happen entirely within an isolated enclave. Raw secrets never traverse the network.

Learn more about DAuth

Lifecycle of a request

Every API call follows the same five-stage pipeline. Click a stage to see what happens under the hood.

Authenticate

Validate API key, check org status, load tier limits and rate quotas.

Route

Select the target provider, map model parameters, apply BYOK overrides if present.

Execute tools

Resolve MCP slugs, establish server connections, run tool calls server-side.

Stream

SSE stream incremental deltas back to the client as they are generated.

Respond

Meter token usage, emit rate-limit headers, return the final structured response.

Hover or click a stage to see details

Start in minutes

Drop-in compatible with the OpenAI SDK. Switch your base URL and you're done.

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5",
    "messages": [
      {"role": "user", "content": "Search for the latest AI news"}
    ],
    "mcps": ["tsion/exa"],
    "stream": true
  }'

# Bring Your Own Key -- use your provider credentials
# while still leveraging MCP tools and streaming

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "X-Provider: anthropic" \
  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
  -H "X-Provider-Model: anthropic/claude-opus-4-6" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is the weather in Tokyo?"}
    ],
    "mcps": ["tsion/exa"]
  }'

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Endpoints at a glance

Chat completions, embeddings, image generation, audio, OCR, and more. Every endpoint follows the same auth and streaming patterns.

Core

POST/v1/chat/completionsChat with any model, stream responses, call MCP tools

GET/v1/modelsList all available models across providers

POST/v1/embeddingsGenerate vector embeddings with OpenAI or Google

Media

POST/v1/images/generationsGenerate images with DALL-E and GPT Image

POST/v1/audio/speechText-to-speech, transcription, and translation

POST/v1/ocrExtract text from images and documents

Management

POST/v1/private/keysCreate, rotate, and manage API keys

GET/v1/private/subscription/statusCheck subscription tier, rate limits, and usage

Ship your first request in 30 seconds

Get an API key, pick a model, attach MCP tools. That's it.

Get started Read the docs

Dedalus API

One API.
Every model.

A unified, model-agnostic gateway that routes to OpenAI, Anthropic, Google, and more. Add MCP tools from our marketplace with a single parameter.

Read the docs Get an API key

main.py

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

https://api.dedaluslabs.ai

How the API works

Your app talks to one endpoint. We handle authentication, provider routing, MCP tool execution, and streaming -- all behind a single OpenAI-compatible interface.

{ }

Your AppPython / TypeScript

Dedalus API

AuthAPI Keys & RBAC

RouterModel selection

MCPTool execution

StreamSSE responses

AI Providers

MCP Servers

Slack

GitHub

Notion

Linear

Request flow

Every major provider, one interface

Switch between models with a single parameter. No SDK changes, no provider-specific code. The same request format works everywhere.

OpenAI

GPT-5, o3, DALL-E, Whisper

Anthropic

Opus 4.6, Sonnet, Haiku

Google

Gemini 3.0 Flash, Pro

xAI

Grok 4, Grok 4 Mini

DeepSeek

Chat, Coder, Reasoner

Mistral

Large, Medium

Plus Groq, Fireworks, and more. New providers added regularly.

Everything you need in one gateway

Drop-in OpenAI compatibility plus the features you actually need for production agents.

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Dedalus Auth

Your secrets never leave your machine

DAuth is our managed authorization system. Remote MCP servers use your local credentials without ever seeing them -- credentials are isolated in a sealed execution boundary.

Zero secret leakage

Credentials are encrypted client-side and decrypted only inside a sealed execution boundary. Your code never sees raw secrets.

Sender-constrained tokens

Demonstrating Proof-of-Possession (DPoP) binds tokens cryptographically to the client. A stolen token is useless without the private key.

Networkless execution

Credential decryption and API calls happen entirely within an isolated enclave. Raw secrets never traverse the network.

Learn more about DAuth

Lifecycle of a request

Every API call follows the same five-stage pipeline. Click a stage to see what happens under the hood.

Authenticate

Validate API key, check org status, load tier limits and rate quotas.

Route

Select the target provider, map model parameters, apply BYOK overrides if present.

Execute tools

Resolve MCP slugs, establish server connections, run tool calls server-side.

Stream

SSE stream incremental deltas back to the client as they are generated.

Respond

Meter token usage, emit rate-limit headers, return the final structured response.

Hover or click a stage to see details

Start in minutes

Drop-in compatible with the OpenAI SDK. Switch your base URL and you're done.

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5",
    "messages": [
      {"role": "user", "content": "Search for the latest AI news"}
    ],
    "mcps": ["tsion/exa"],
    "stream": true
  }'

# Bring Your Own Key -- use your provider credentials
# while still leveraging MCP tools and streaming

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "X-Provider: anthropic" \
  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
  -H "X-Provider-Model: anthropic/claude-opus-4-6" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is the weather in Tokyo?"}
    ],
    "mcps": ["tsion/exa"]
  }'

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Endpoints at a glance

Chat completions, embeddings, image generation, audio, OCR, and more. Every endpoint follows the same auth and streaming patterns.

Core

POST/v1/chat/completionsChat with any model, stream responses, call MCP tools

GET/v1/modelsList all available models across providers

POST/v1/embeddingsGenerate vector embeddings with OpenAI or Google

Media

POST/v1/images/generationsGenerate images with DALL-E and GPT Image

POST/v1/audio/speechText-to-speech, transcription, and translation

POST/v1/ocrExtract text from images and documents

Management

POST/v1/private/keysCreate, rotate, and manage API keys

GET/v1/private/subscription/statusCheck subscription tier, rate limits, and usage

Ship your first request in 30 seconds

Get an API key, pick a model, attach MCP tools. That's it.

Get started Read the docs

Dedalus API

One API.
Every model.

A unified, model-agnostic gateway that routes to OpenAI, Anthropic, Google, and more. Add MCP tools from our marketplace with a single parameter.

Read the docs Get an API key

main.py

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

import asyncio
from dotenv import load_dotenv
from dedalus_labs import AsyncDedalus, DedalusRunner

load_dotenv()

async def main():
    client = AsyncDedalus()
    runner = DedalusRunner(client)
    response = await runner.run(
        input="Weather in SF this week?",
        model="anthropic/claude-opus-4-6",
        mcp_servers=["windsornguyen/open-meteo"],
    )
    print(response.final_output)

if __name__ == "__main__":
    asyncio.run(main())

https://api.dedaluslabs.ai

How the API works

Your app talks to one endpoint. We handle authentication, provider routing, MCP tool execution, and streaming -- all behind a single OpenAI-compatible interface.

{ }

Your AppPython / TypeScript

Dedalus API

AuthAPI Keys & RBAC

RouterModel selection

MCPTool execution

StreamSSE responses

AI Providers

MCP Servers

Slack

GitHub

Notion

Linear

Request flow

Every major provider, one interface

Switch between models with a single parameter. No SDK changes, no provider-specific code. The same request format works everywhere.

OpenAI

GPT-5, o3, DALL-E, Whisper

Anthropic

Opus 4.6, Sonnet, Haiku

Google

Gemini 3.0 Flash, Pro

xAI

Grok 4, Grok 4 Mini

DeepSeek

Chat, Coder, Reasoner

Mistral

Large, Medium

Plus Groq, Fireworks, and more. New providers added regularly.

Everything you need in one gateway

Drop-in OpenAI compatibility plus the features you actually need for production agents.

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Dedalus Auth

Your secrets never leave your machine

DAuth is our managed authorization system. Remote MCP servers use your local credentials without ever seeing them -- credentials are isolated in a sealed execution boundary.

Zero secret leakage

Credentials are encrypted client-side and decrypted only inside a sealed execution boundary. Your code never sees raw secrets.

Sender-constrained tokens

Demonstrating Proof-of-Possession (DPoP) binds tokens cryptographically to the client. A stolen token is useless without the private key.

Networkless execution

Credential decryption and API calls happen entirely within an isolated enclave. Raw secrets never traverse the network.

Learn more about DAuth

Lifecycle of a request

Every API call follows the same five-stage pipeline. Click a stage to see what happens under the hood.

Authenticate

Validate API key, check org status, load tier limits and rate quotas.

Route

Select the target provider, map model parameters, apply BYOK overrides if present.

Execute tools

Resolve MCP slugs, establish server connections, run tool calls server-side.

Stream

SSE stream incremental deltas back to the client as they are generated.

Respond

Meter token usage, emit rate-limit headers, return the final structured response.

Hover or click a stage to see details

Start in minutes

Drop-in compatible with the OpenAI SDK. Switch your base URL and you're done.

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

import Dedalus, { DedalusRunner } from 'dedalus-labs';

const client = new Dedalus();
const runner = new DedalusRunner(client);

const response = await runner.run({
  input: "Ship a release",
  model: ['gpt-5.2', 'claude-opus-4.5'],
  mcpServers: ['github', 'brave-search'],
  tools: ['search_files', 'find_image']
});

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5",
    "messages": [
      {"role": "user", "content": "Search for the latest AI news"}
    ],
    "mcps": ["tsion/exa"],
    "stream": true
  }'

# Bring Your Own Key -- use your provider credentials
# while still leveraging MCP tools and streaming

curl https://api.dedaluslabs.ai/v1/chat/completions \
  -H "Authorization: Bearer $DEDALUS_API_KEY" \
  -H "X-Provider: anthropic" \
  -H "X-Provider-Key: $ANTHROPIC_API_KEY" \
  -H "X-Provider-Model: anthropic/claude-opus-4-6" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "What is the weather in Tokyo?"}
    ],
    "mcps": ["tsion/exa"]
  }'

from dedalus_labs import Dedalus

client = Dedalus(api_key="your-api-key")

response = client.chat.completions.create(
    model="openai/gpt-5",
    messages=[
        {"role": "user", "content": "Search for the latest AI news"}
    ],
    mcp_servers=["tsion/exa"],
    stream=True,
)

for chunk in response:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Endpoints at a glance

Chat completions, embeddings, image generation, audio, OCR, and more. Every endpoint follows the same auth and streaming patterns.

Core

POST/v1/chat/completionsChat with any model, stream responses, call MCP tools

GET/v1/modelsList all available models across providers

POST/v1/embeddingsGenerate vector embeddings with OpenAI or Google

Media

POST/v1/images/generationsGenerate images with DALL-E and GPT Image

POST/v1/audio/speechText-to-speech, transcription, and translation

POST/v1/ocrExtract text from images and documents

Management

POST/v1/private/keysCreate, rotate, and manage API keys

GET/v1/private/subscription/statusCheck subscription tier, rate limits, and usage

Ship your first request in 30 seconds

Get an API key, pick a model, attach MCP tools. That's it.

Get started Read the docs

Command Palette

Command Palette

One API.Every model.

How the API works

AI Providers

MCP Servers

Every major provider, one interface

OpenAI

Anthropic

Google

xAI

DeepSeek

Mistral

Everything you need in one gateway

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Your secrets never leave your machine

Zero secret leakage

Sender-constrained tokens

Networkless execution

Lifecycle of a request

Start in minutes

Endpoints at a glance

Core

Media

Management

Ship your first request in 30 seconds

One API.Every model.

How the API works

AI Providers

MCP Servers

Every major provider, one interface

OpenAI

Anthropic

Google

xAI

DeepSeek

Mistral

Everything you need in one gateway

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

Vision & multimodal

Real-time streaming

Multi-model handoffs

Rate limiting & metering

Your secrets never leave your machine

Zero secret leakage

Sender-constrained tokens

Networkless execution

Lifecycle of a request

Start in minutes

Endpoints at a glance

Core

Media

Management

Ship your first request in 30 seconds

One API.Every model.

How the API works

AI Providers

MCP Servers

Every major provider, one interface

OpenAI

Anthropic

Google

xAI

DeepSeek

Mistral

Everything you need in one gateway

Multi-provider routing

Native MCP support

Bring Your Own Key

Structured outputs

One API.
Every model.

One API.
Every model.

One API.
Every model.

One API.
Every model.