Document extraction

Your hardest documents run on Opus.
Hal does it for 40% less.

Hal is an Opus-class model, tuned and served on Radium. It beat Opus 5.5 on our 80-task structured benchmark, and there's no tokens-per-minute limit to slow a long job down.

Start with $25 in free credit. No card required.

Get your API key
Drop‑in for
Anthropic SDK
OpenAI SDK
GitHub Copilot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Anthropic SDK
OpenAI SDK
GitHub Copilot
Claude Code CLI
LangGraph
Vercel AI SDK
LlamaIndex
VS Code
Lite LLM
Our Models

One model for each kind of document

Hal for the documents cheaper models get wrong, Clarke for routine extraction, and Tycho for classification and routing at volume.

Hard documents
JSON schema
Tool Calling

Hal 1.0

Maximum Capability

Comparable to Anthropic
Opus 5.5 or OpenAI GPT-6 Astra

Extraction
Summaries
Chat

Clarke 1.0

Balanced Performance

Comparable to Anthropic
Sonnet 5.5 or OpenAI GPT-6 Sol

Classification
Extraction

Tycho 1.0

High-Efficiency Scale

Comparable to Anthropic Haiku
5.5 or OpenAI GPT-6 Luna

Designed for the work you already run these models for.

Tycho 1.0

Classify

Sort incoming documents by type and route them

Keep As-is

Parse

Turn files into text, as you do today

Keep As-is

Schema

Your JSON schema and field rules

Hal 1.0

Extract

Read the document and fill every field

Model Comparison

Scored against frontier models on real product tasks

Radium Hal 1.0
50
77
 / 
80
 correct
Anthropic Opus 5.5
50
75
 / 
80
 correct
Tasks in category
Runs per task
Scored by
80
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
17
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
15
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema
Radium Hal 1.0
50
20
 / 
20
 correct
Anthropic Opus 5.5
50
20
 / 
20
 correct
Tasks in category
Runs per task
Scored by
20
1
Exact-match JSON schema

Independent Radium benchmark, not endorsed by Anthropic. Claude and Opus are Anthropic PBC trademarks, used for identification only. Results are a single run, provided “as is,” and not a guarantee of future performance. See the full benchmark report

The number that matters

Control the cost per extracted document

Every new account gets $25 in credit. No card required.

Get your API key
Dense cluster of white dots scattered against a dark background, resembling stars or particles.
Extraction specs

Built for documents that have to come out right

Every field in your schema, from the documents cheaper models miss.

Per document

$0.011

A 3,000-token document with a 300-token answer on Hal at list price. The same document on Opus 5.5 costs $0.018.

Tokens per minute

No limit

1,000 requests a minute with a burst of 33, set per organization from day one. A long job never backs off for a token cap.

Structured outputs

JSON schema

JSON mode, JSON schema and tool calling, so every document comes back in the shape your pipeline expects.

What changes

Three values change

Change the base URL, the API key and the model name. Your SDK, schemas, prompts and evals carry on as they are.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud/v1",
)

response = client.chat.completions.create(
    model="hal-1.0",
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(response.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud/v1",
});

const response: OpenAI.Chat.ChatCompletion =
  await client.chat.completions.create({
    model: "hal-1.0",
    messages: [{ role: "user", content: "Hello, Radium!" }],
  });

console.log(response.choices[0].message.content);
curl https://api.radium.cloud/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "model": "hal-1.0",
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'
package main

import (
	"context"
	"fmt"

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

func main() {
	cfg := openai.DefaultConfig("YOUR_API_KEY")
	cfg.BaseURL = "https://api.radium.cloud/v1"
	client := openai.NewClientWithConfig(cfg)

	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: "hal-1.0",
			Messages: []openai.ChatCompletionMessage{
				{Role: openai.ChatMessageRoleUser, Content: "Hello, Radium!"},
			},
		},
	)
	if err != nil {
		panic(err)
	}

	fmt.Println(resp.Choices[0].Message.Content)
}
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;

OpenAIClient client = OpenAIOkHttpClient.builder()
    .apiKey("YOUR_API_KEY")
    .baseUrl("https://api.radium.cloud/v1")
    .build();

ChatCompletion completion = client.chat().completions().create(
    ChatCompletionCreateParams.builder()
        .model("hal-1.0")
        .addUserMessage("Hello, Radium!")
        .build());

System.out.println(
    completion.choices().get(0).message().content().orElseThrow());
using OpenAI;
using OpenAI.Chat;

var client = new OpenAIClient(
    new ApiKeyCredential("YOUR_API_KEY"),
    new OpenAIClientOptions
    {
        Endpoint = new Uri("https://api.radium.cloud/v1"),
    });

var chatClient = client.GetChatClient("hal-1.0");
var response = await chatClient.CompleteChatAsync(
    new UserChatMessage("Hello, Radium!"));

Console.WriteLine(response.Value.Content[0].Text);
import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.radium.cloud",
)

message = client.messages.create(
    model="hal-1.0",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Radium!"}
    ],
)

print(message.content[0].text)
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: "YOUR_API_KEY",
  baseURL: "https://api.radium.cloud",
});

const message: Anthropic.Message = await client.messages.create({
  model: "hal-1.0",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Radium!" }],
});

console.log(message.content[0].text);
curl https://api.radium.cloud/v1/messages \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "hal-1.0",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "Hello, Radium!"}]
  }'

What changes

The base URL in your client

The model string

The invoice

What stays the same

Your OCR and parser

The Anthropic or OpenAI SDK

Tool and function calls

Parallel tool calls

Streaming, including tool deltas

Structured output

Retry and error handling

Evals, tracing and observability

Cost

What the difference looks like monthly

Same tasks, different rate, two bills to compare.

Monthly spend on frontier extraction traffic

Share moved
Estimated monthly savings
$0
0% lower
than current bill

Hal 1.0 against Opus 5.5 list pricing as of October 2026, for a document with 3,000 input and 300 output tokens.

See the working
Pricing Breakdown

Six cost layers sit inside a frontier token. Two sit inside ours

The same arithmetic holds whether the call comes from an agent loop or an extraction job.

Frontier Token
Radium Token

The switch is three values, and so is the way back

Get your API key
FAQ
Does Radium replace our OCR or document parser?

No. Parsing and OCR stay where they are. Radium takes the text once it's extracted and fills your schema.

Why Hal and not a cheaper model?

Use the cheapest model that gets every field right. For clean, repetitive documents that's often Tycho or Clarke. Hal is for the documents where cheaper models miss fields, which is where most teams reach for Opus.

Will extraction accuracy change if we switch from Opus?

Test it. On our 80-task structured benchmark, scored by exact-match JSON schema, Hal scored 96.25% to Opus 5.5's 93.75%. It's our test, so run your own documents against both endpoints before you move.

Do JSON schema and tool calling work?

Yes. JSON mode, JSON schema and tool calling work on all three models, through the OpenAI and Anthropic SDKs you already use.

What are the rate limits on a long job?

1,000 requests per minute with a burst of 33, and no tokens-per-minute limit, set per organization from day one. Above 1,000 requests a minute you can still get a 429, so keep a retry with backoff for those.

Is there a Batch API?

No. Radium serves synchronous requests, and each result comes back as its call finishes. If a job can wait 24 hours, a provider's batch discount may cost less. Radium is for the jobs that can't wait.

Does prompt caching help?

Yes. Your instructions and schema repeat on every document, and only the document changes. Prompt caching is supported and priced separately from the rest of the input.

How do we test this without touching production?

Run a few hundred of your hardest documents through both endpoints and compare field accuracy and cost per document before anything downstream changes.

Is our data used for training?

No. Radium doesn't train on customer data, and Radium is SOC 2 compliant.

Can we switch back?

Change the three values back. Your parser, your schema and your pipeline never pointed anywhere else.