Anthropic Computer Use + Skills API + Files API 2026: Pricing, Browser Use Tool, and 1 TB Storage

On August 20, 2026 Anthropic moved three agent-building blocks to general availability on the Claude Platform — Computer use, the Skills API, and the Files API — and added a new browser use tool inside computer use. Together they describe a single loop: an agent that sees an application, applies your team’s expertise from a skill, retrieves your documents by ID, and writes finished files back. This is also the first time Computer use is HIPAA-eligible under a BAA, which is a real change for healthcare and insurance workflows.

For API consumers the interesting questions are how much does each request cost, what new surface area do you actually have to integrate, and how does it compare to OpenAI’s computer use preview. We pulled pricing and endpoint specs straight from Anthropic’s GA announcement, the Computer use docs, the Skills API reference, and the live anthropic.com/pricing page to answer all three.

Pricing: per-token base + ~4,500-token toolset overhead

Computer use follows Anthropic’s standard tool-use pricing: you pay the model’s input/output rate plus the screenshot/image rate for visual results. On top of that, declaring the new toolset adds a fixed input-token overhead:

• ~4,500 input tokens to declare computer_toolset_20260801 with default members (covers tool definitions + the tool-use system prompt).
• ~4,520 on Claude Fable 5, Mythos 5, Opus 5, and Opus 4.8; ~4,590 on Claude Sonnet 5.
• Disabling zoom with configs removes ~410 of those tokens.
• Screenshot and zoom images returned in tool results are billed as image input (see Vision pricing on each model page).

The base model prices that matter (verified live on anthropic.com/pricing, 2026-08-25):

Model	Input	Output	Cache write	Cache read
Haiku 4.5	$1 / MTok	$5 / MTok	$1.25 / MTok	$0.10 / MTok
Sonnet 5	$2 / MTok	$10 / MTok	$2.50 / MTok	$0.20 / MTok
Opus 5	$5 / MTok	$25 / MTok	$6.25 / MTok	$0.50 / MTok
Fable 5	$10 / MTok	$50 / MTok	$12.50 / MTok	$1 / MTok

Worked example. One Claude Opus 5 turn with computer_toolset_20260801, default members, a 1,024×768 PNG screenshot, and a 1,000-token assistant message:

• Toolset overhead: ~4,520 input tokens → $0.0226
• Screenshot (image input on Opus 5): see Vision pricing; an 800×600 screenshot lands in the same per-image band as a single high-res image
• 1,000 output tokens → $0.025
• Total per turn ≈ $0.05–$0.08 on Opus 5; on Sonnet 5, ~$0.02–$0.04; on Haiku 4.5, ~$0.01–$0.02

The exact image input count is reported in the response usage block, and you can pre-flight it with the count_tokens endpoint.

Computer use: multi-action turns, browser use tool, HIPAA

Computer use at GA lets Claude take several actions per turn instead of one action per model call. The same Anthropic blog post describes a healthcare-customer result (Davide Locatelli, Research Engineer): our longest claims workflow went from 32 minutes to 13, cost per task fell about 30% across every workflow we tested, and completion hit 100%, with no changes to our prompts. The multi-action turn is most of the win — fewer round-trips to the API, fewer cached system-prompt re-charges.

The new browser use tool is a member of the same toolset, not a separate tool name. It reads the DOM structure of the page alongside the screenshot, so the agent targets the search input with id="q" rather than pixel (412, 187). That makes web workflows more reliable than screenshots alone, especially on SPAs that move elements around.

HIPAA. Computer use is now eligible for HIPAA-regulated workloads under Anthropic’s Business Associate Agreement. If you handle PHI through a claims or prior-auth agent, this removes the largest compliance blocker that previously forced customers to keep Claude out of the loop entirely.

Skills API: upload-and-version your team’s playbooks

A skill is a folder of instructions, scripts, and templates that Claude loads only when a task calls for it. The Skills API lets you upload and version your own skills and attach them to any request; skills run inside Claude’s code execution sandbox, so there is nothing to host. The endpoints we pulled from the Skills API reference:

POST   /v1/skills                       # Create skill
GET    /v1/skills                       # List skills
GET    /v1/skills/{skill_id}            # Get one
DELETE /v1/skills/{skill_id}            # Delete
POST   /v1/skills/{skill_id}/versions   # Publish a new version
GET    /v1/skills/{skill_id}/versions   # List versions
GET    /v1/skills/{skill_id}/versions/{version}
DELETE /v1/skills/{skill_id}/versions/{version}

The SkillSource.type field is one of custom (your workspace, private), anthropic (Anthropic-published, shared, read-only), anthropic_example (Anthropic samples), or plugin (resolved from an installed plugin). Box’s Matthew Midson described the canonical use case in the GA blog: for a bank, a skill captures the firm’s credit methodology and approved memo format; Box Agent applies it to the financial statements and deal documents already in Box and produces a source-grounded credit memo for analyst review.

Files API: 5x rate limits, 1 TB per org, automatic expiration

The Files API is now production storage for the documents an agent reads and writes. You upload a PDF or spreadsheet once, reference it by ID in later requests instead of re-sending it, and download the files the agent creates. Three concrete upgrades at GA:

• 5x higher rate limits on the Files endpoints.
• 1 TB of storage per organization — enough to host a corporate knowledge base without aggressive eviction.
• Automatic file expiration — configurable, so you don’t leak old evidence into new runs.

For long-running agents the win is not paying the input-token tax twice. A 50 MB PDF referenced by ID in ten subsequent turns is one upload cost, not ten.

Code example: a Computer use + Files API loop

Here is a minimal Python loop that uploads a screenshot, lets Claude act on it with multi-action turns, and downloads the file the agent writes back. This is the canonical “claims agent” shape from Anthropic’s GA blog, simplified.

import anthropic
from pathlib import Path

client = anthropic.Anthropic()

# 1. Upload the intake document once
intake = client.files.create(
    file=("intake.pdf", Path("intake.pdf").read_bytes(), "application/pdf"),
    purpose="file",
)
file_id = intake.id  # reference by ID, not bytes, on every later turn

# 2. Multi-action computer use turn (computer_toolset_20260801)
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    tools=[{"type": "computer_toolset_20260801"}],
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Process the intake and save the confirmation."},
                {"type": "file", "file_id": file_id},  # Files API reference
            ],
        }
    ],
)

# 3. Walk every tool_use block (multi-action turn returns a batch)
for block in response.content:
    if block.type == "tool_use" and block.name.startswith("computer"):
        print(block.input)  # {"action": "left_click", "coordinate": [412, 187]}

# 4. Download the file Claude wrote back
for fid in response.usage.get("output_files", []):
    file_bytes = client.files.download(fid)
    Path(fid + ".pdf").write_bytes(file_bytes)

The same call shape works with Haiku 4.5 for cheap high-volume automation (sub-cent per turn for simple web forms) or with Fable 5 for the hardest long-running agent loops where the 4,500-token toolset overhead is dwarfed by the actual tool calls.

Speed: why multi-action turns matter more than the toolset overhead

The Locatelli quote — 32 minutes to 13 minutes on the same workflow — is the right way to think about performance. Computer use latency is dominated by the number of round-trips and the size of each screenshot; the per-turn toolset overhead is a flat tax. By collapsing several clicks/keystrokes into one model call, multi-action turns reduce the round-trip count by 3–5x on typical workflows. On Haiku 4.5 the tax is small (~$0.0045 per turn at $1/M input); on Opus 5 it’s still small relative to the time savings (~$0.0226 per turn).

For browser use, the DOM-aware targeting means fewer retry on misclick turns — a common silent cost in screenshot-only loops. In Box’s described workflow, the skill itself is what keeps the agent on-task; the Files API keeps the cost per turn flat as documents accumulate.

Availability beyond the Claude Platform

Skills API and Files API are also available through Microsoft Foundry; the updated Computer use and browser use tools are coming soon to Google Cloud Vertex AI. Existing beta integrations keep working during migration, so an Anthropic-direct integration that you cut over to Vertex AI later will not require a code rewrite. This is the same multi-cloud pattern Anthropic has used for Claude generally since Opus 4.7.

Limitations worth knowing

• Prompt injection is still the #1 risk. Anthropic’s docs explicitly call out: instructions on webpages or contained in images might override your instructions or cause Claude to make mistakes. Treat any computer-use or browser-use agent touching untrusted pages the same way you treat a junior analyst clicking through spam — isolate sensitive data, scope the action set, log everything.
• The 4,500-token overhead is per turn. On Haiku 4.5 it is a meaningful fraction of a short request. Disable zoom (saves ~410 tokens) when you don’t need it, and prefer the smallest toolset that does the job.
• Files API expiration is automatic, not optional. Configure it deliberately; long-lived evidence files should be re-uploaded or pinned, or your agent will see them vanish.
• Vertex AI is "coming soon," not GA. If your stack requires Google Cloud from day one, plan a temporary Anthropic-direct path.

Who should integrate this week

• Healthcare and insurance workflows that need HIPAA coverage: the BAA eligibility removes the biggest blocker.
• Banking and financial-services agents that depend on firm-specific methodology: the Skills API is the right shape for a credit memo, KYC, or compliance-check workflow.
• Web-form automation at scale: browser use + Haiku 4.5 turns sub-dollar screenshots into sub-cent actions.
• Document-heavy agent loops: Files API 1 TB + 5x rate limits removes the re-upload tax that punished long-running agents under the previous limits.

Verdict

Anthropic’s August 20 GA is not a single product launch — it is a tightly-integrated trio. Computer use (now with browser use) handles the see and act loop; the Skills API handles the apply expertise loop; the Files API handles the carry evidence loop. Pricing stays at the model base rate plus a transparent ~4,500-token toolset overhead, and HIPAA eligibility is the kind of compliance change that quietly unlocks the next wave of enterprise pilots.

If you already run Claude for chat or code, the marginal effort to add computer use is small. If you run OpenAI’s computer-use-preview, the comparison worth making is cost per turn on a real workflow — Sonnet 5 at $2/$10 with multi-action turns usually beats a dedicated screenshot model once you factor in retry rate. Either way, the Files API alone is worth integrating: 5x rate limits and 1 TB of storage is a real upgrade, not a marketing line.

Pricing verified against anthropic.com/pricing and the Computer use docs on 2026-08-25. Skills API endpoints verified from docs.anthropic.com/en/api/skills. GA announcement and customer quotes from claude.com/blog/computer-use-skills-api-files-api.