Anthropic API

Implements a stateless Messages API that accepts JSON-formatted conversation turns with role-based message routing (user/assistant). Maintains conversation history within a single request payload, supporting up to 200,000 tokens of context per request. Returns streamed or buffered text responses with configurable max_tokens output limits. Handles multi-turn dialogue without server-side session state, requiring clients to manage conversation history.

Implements a tool-calling system where Claude receives a JSON schema registry of available functions, generates structured tool_use blocks within responses, and can invoke multiple tools in parallel within a single turn. Supports 'strict' mode that enforces exact schema compliance, preventing hallucinated parameters. Tool results are fed back via user messages with tool_result blocks, creating a request-response loop. Integrates with prompt caching to avoid re-transmitting tool schemas on repeated calls.

Provides a 'code execution' tool that Claude can invoke to run Python code and receive output, enabling runtime verification of code correctness, testing of algorithms, and interactive problem-solving. Claude writes code, executes it, sees results, and iterates. Execution happens in a sandboxed environment with output captured and returned to Claude.

Provides a Files API endpoint for uploading documents (PDFs, text, images) that can be referenced in subsequent API calls. Files are stored server-side and can be used across multiple requests without re-uploading. Supports multipart form uploads and returns file IDs for reference. Integrates with vision and text processing to enable document analysis workflows.

Implements MCP as a standard for connecting external tools and data sources to Claude. MCP servers expose tools, resources, and prompts via a standardized protocol; Claude can invoke them through the tool-calling system. Anthropic provides MCP connectors for common services (databases, APIs, file systems) and supports custom MCP server implementations. Enables modular, reusable tool ecosystems without modifying Claude's core API.

Provides a stateful agent infrastructure where Claude maintains conversation state, event history, and tool execution context across multiple turns without client-side session management. Agents can be configured with system prompts, tools, and resource limits. Clients send messages and receive responses; the API handles state persistence, tool invocation, and event logging. Enables building complex, long-running agents without managing conversation history.

Provides an embeddings endpoint that converts text into fixed-size vector representations (embeddings) suitable for semantic search, clustering, and similarity comparison. Embeddings capture semantic meaning, enabling finding similar documents or concepts without keyword matching. Integrates with external vector databases (Pinecone, Weaviate, etc.) for storage and retrieval.

Supports streaming responses where Claude's output is returned incrementally as it's generated, rather than waiting for the complete response. Client receives chunks of text (or tool_use blocks) in real-time, enabling progressive display and reduced perceived latency. Streaming works with all API features (tool-calling, vision, structured outputs). Reduces time-to-first-token and enables cancellation of long-running requests.

Enables Claude to refuse requests (e.g., harmful content, policy violations) while streaming, returning refusal messages in real-time rather than after processing. Refusals are streamed like normal responses, providing transparency about why a request was declined. Integrates with streaming responses for consistent behavior.

Provides a token counting endpoint that calculates the number of tokens in a message without making an API call, enabling cost estimation before sending requests. Supports counting tokens for messages, tool schemas, and cached content. Enables clients to optimize prompts, estimate costs, and make decisions about request batching or caching.

Provides a 'computer use' tool that enables Claude to interact with desktop/web interfaces by receiving screenshots, analyzing them with vision capabilities, and generating mouse/keyboard actions (click, type, scroll). Claude sees the screen state, reasons about UI elements, and issues action commands that are executed by client code, creating a feedback loop. Integrates with vision model to understand complex UI layouts and extract information from visual elements.

Accepts images (JPEG, PNG, GIF, WebP) as base64-encoded content blocks within messages, enabling Claude to analyze visual content, extract text (OCR), identify objects, read charts/diagrams, and answer questions about images. Supports multiple images per message and mixed text-image conversations. Vision processing is integrated into the same Messages API, requiring no separate endpoint.

Enables Claude to generate responses constrained to a specified JSON schema, ensuring output is always valid, parseable JSON matching the provided structure. Client defines schema (e.g., object with specific fields and types), and Claude generates responses that conform exactly to that schema. Validation happens at generation time, preventing invalid outputs. Integrates with tool-calling for deterministic function parameter generation.

Caches large, frequently-repeated context blocks (documents, system prompts, tool schemas) at the API level, reducing token consumption and latency for subsequent requests using the same context. Uses content hashing to identify cacheable blocks, storing them server-side for 5 minutes. Subsequent requests with the same cached content pay only 10% of the token cost for cached blocks, plus a small cache-write cost on first use. Works transparently with all API features (tool-calling, vision, structured outputs).

Accepts batches of up to 10,000 API requests in JSONL format, processes them asynchronously with lower per-token costs (50% discount), and returns results in JSONL format. Requests are queued and processed during off-peak hours, with results available via polling or webhook. Enables cost-effective processing of non-time-sensitive workloads like data extraction, summarization, or content generation at scale.

Enables Claude to perform multi-step reasoning before generating responses, showing internal thought process in a separate 'thinking' block. Claude allocates computational budget to reasoning, working through problems step-by-step before answering. Useful for math, logic, code debugging, and complex analysis. Thinking blocks are visible to users, providing transparency into reasoning. Integrates with all other API features.

Beta feature that enables Claude to dynamically allocate computational effort based on problem complexity, spending more reasoning cycles on hard problems and less on easy ones. Unlike extended thinking (which uses fixed reasoning budget), adaptive thinking adjusts effort automatically. Useful for mixed-difficulty workloads where some requests need deep reasoning and others don't.

Provides 'web search' and 'web fetch' tools that Claude can invoke to search the internet and retrieve current information. Web search returns ranked results with snippets; web fetch retrieves full page content. Tools are invoked via the tool-calling system, with results fed back to Claude for synthesis. Enables Claude to answer questions about current events, recent data, or information not in training data.