Web search

Which models search

GET /v1/models reports it per model in capabilities:

Claude: the web_search tool

Pass Anthropic's server tool with max_uses. max_uses is required here because it caps how many searches one request can run, which is what lets the request's cost be reserved up front.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://api.inferencebureau.com", apiKey: process.env.IB_API_KEY });

const msg = await client.messages.create({
  model: "anthropic/claude-sonnet-5",
  max_tokens: 1024,
  tools: [{ type: "web_search_20250305", name: "web_search", max_uses: 3 }],
  messages: [{ role: "user", content: "What changed in the latest Next.js release?" }],
});

// The model decides whether to search; check that it did.
const searched = msg.usage.server_tool_use?.web_search_requests ?? 0;

The response is Anthropic's, unchanged. web_search_tool_result blocks list each result's url and title, text blocks carry citations, and usage.server_tool_use.web_search_requests counts the searches that ran. allowed_domains, blocked_domains, and user_location pass through. A pause_turn stop reason passes through as well: send the response content back as an assistant turn to continue, as with the Anthropic API. Each continuation is its own request with its own hold.

OpenAI: the Responses web_search tool

Pass OpenAI's hosted web_search tool to POST /v1/responses with max_tool_calls. The tool has no max_uses, so max_tool_calls is required: it is what bounds the searches one request can run.

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://api.inferencebureau.com/v1", apiKey: process.env.IB_API_KEY });

const res = await client.responses.create({
  model: "openai/gpt-5.4-mini",
  tools: [{ type: "web_search" }],
  max_tool_calls: 3,
  input: "What changed in the latest Next.js release?",
});

// The model decides whether to search; web_search_call items show what ran.
const searched = res.output.filter((o) => o.type === "web_search_call").length;

The response is OpenAI's, unchanged: web_search_call output items show each search (and each page the model opened), and output_text annotations carry url_citations. filters, user_location and search_context_size pass through. web_search_preview is not supported; use web_search.

Routing and verification

Search is verified per provider and per tool version with a real billed search. A request that includes the web_search tool is sent only to providers that passed that version, and it never runs without the tool. Amazon Bedrock, for example, rejects Claude's search tool, so search requests are never routed to Bedrock. If none of the providers your key may use supports the version you sent, the request fails with policy_denied (reason no_web_search) and nothing is charged.

Time limits

Requests with the web_search tool may run for up to 10 minutes, compared with 4 minutes for other requests. Non-streamed search requests wait for the whole response. A stream is still ended if nothing arrives for 30 seconds. Providers send progress events during a search, so this only triggers when a provider stalls. For long searches, especially with web_search_20260209, prefer stream: true.

How long a search takes is up to the provider. Measured against the provider directly with a five-search research prompt: Opus 4.8 took 33 seconds with web_search_20250305 and almost 9 minutes with web_search_20260209, and Sonnet 4.6 took 2 minutes with web_search_20260209. Set your own client timeouts with that range in mind.

Billing and the hold

• Per search. Each search the provider runs is billed at web_search_per_call from GET /v1/pricing, plus the platform fee, like tokens.
• Result tokens. Search results are added to the model's input. After each search, the model reads the prompt and every earlier result again, so input tokens grow faster than the number of searches.
• The hold. Before dispatch, the request's cost is reserved from your balance: max_uses searches (Claude) or max_tool_calls + 1 (OpenAI), each with another read of your prompt plus about 40,000 tokens of results and re-reading (web_search_20250305), 50,000 (web_search_20260209) or 20,000 (OpenAI's web_search). After the request, you're charged what actually ran, never more than the hold, and the rest is released, usually within seconds.

The hold grows in line with max_uses. Holds per request, platform fee included, for a short prompt and max_tokens: 4096:

OpenAI models on /v1/responses, for a short prompt and max_output_tokens: 4096:

Actual charges are usually far lower. On Opus 4.8 with web_search_20260209 and max_uses: 5, a five-search research prompt billed about $0.82 against a hold of about $1.50. With 10 requests in flight, keep at least ten holds' worth of balance available, or requests are refused with insufficient_balance. GET /v1/balance shows reserved and available, and auto reload tops up before you run out.

Perplexity Sonar

perplexity/sonar searches before every answer, with no tool to pass, and is reserved as one search per request:

curl https://api.inferencebureau.com/v1/chat/completions \
  -H "Authorization: Bearer $IB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model": "perplexity/sonar", "messages": [{ "role": "user", "content": "What changed in the latest Next.js release?" }] }'

Not supported yet

These requests are refused with unsupported_parameter instead of running searches that can't be priced in advance:

• web_search_options and OpenRouter's plugins on chat completions.
• OpenAI's other hosted tools on the Responses API: web_search_preview, file_search, code_interpreter, computer use, image_generation, remote mcp and hosted shell.
• Gemini's Google Search grounding.
• Other Anthropic server tools: web fetch, code execution as a standalone tool, and MCP connectors (mcp_servers). Client tools such as custom tools, bash, and text_editor work as usual.