Quickstart

Make your first request through condense in a couple of minutes, then pick where to go next.

Point your SDK's base URL at a condense provider route, send your condense key in X-Condense-Auth-Token, and keep passing your provider key. The request and response shapes are unchanged.

Send your first request

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",                                # your upstream OpenAI key
    base_url="https://api.condense.chat/openai/v1",
    default_headers={"X-Condense-Auth-Token": "ak_..."},
)

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "hi"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-...",                              // your upstream OpenAI key
  baseURL: "https://api.condense.chat/openai/v1",
  defaultHeaders: { "X-Condense-Auth-Token": "ak_..." },
});

const resp = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "hi" }],
});
console.log(resp.choices[0].message.content);

package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go"
    "github.com/openai/openai-go/option"
)

func main() {
    client := openai.NewClient(
        option.WithAPIKey("sk-..."), // your upstream OpenAI key
        option.WithBaseURL("https://api.condense.chat/openai/v1"),
        option.WithHeader("X-Condense-Auth-Token", "ak_..."),
    )

    resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
        Model:    openai.F("gpt-4o-mini"),
        Messages: openai.F([]openai.ChatCompletionMessageParamUnion{openai.UserMessage("hi")}),
    })
    fmt.Println(resp.Choices[0].Message.Content)
}

// raw HTTP with reqwest — cleanest way to send the condense header
use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = Client::new()
        .post("https://api.condense.chat/openai/v1/chat/completions")
        .header("X-Condense-Auth-Token", "ak_...")
        .header("Authorization", "Bearer sk-...")
        .json(&json!({
            "model": "gpt-4o-mini",
            "messages": [{"role": "user", "content": "hi"}]
        }))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

curl https://api.condense.chat/openai/v1/chat/completions \
  -H "X-Condense-Auth-Token: ak_..." \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'

The Anthropic route works the same, point base_url at /anthropic and send your sk-ant-… key.

Start building

Route your coding agent

Run Claude Code, Codex, or OpenCode through condense with the dense CLI.

Call the API directly

Point your OpenAI or Anthropic SDK's base URL at a condense provider route.

Compress a transcript

Send messages to /v1/compress and get them back compacted.

Choose a model

Helene 1 for general use, Adeline 1 for long agent traces.

proxy vs. rewrite

Forward to the upstream, or just get the rewritten request body back.

Tune per request

Headers for mode, min-tokens, session pinning, and upstream overrides.