Claude Code Web: CCAR-F Domain 3 Exam Guide

Claude Code's web-facing capabilities sit at the intersection of Domain 3 (Claude Code Configuration & Workflows, 20% of the exam) and Domain 2 (Tool Design & MCP Integration, 18%). Together those two domains account for 38% of your CCAR-F score, making a solid grasp of claude code web patterns one of the highest-leverage areas to study before your sitting.

This guide walks through how Claude Code operates in web-connected contexts, how configuration governs its behaviour, and how the exam tests your judgment on these patterns. We draw on the Claude Code Configuration & Workflows concept library and the official CCAR-F exam guide throughout.

What does "claude code web" actually mean for the CCAR-F exam?

"Claude code web" refers to the set of patterns in which Claude Code interacts with web resources, web APIs, or browser-based tooling, either directly through built-in tools or via MCP servers that expose HTTP endpoints. The exam does not test browser automation in isolation; it tests whether you can configure, scope, and govern those interactions correctly inside a production workflow.

Domain 3 carries 20% of the 60-item exam. Per Anthropic's exam guide, every item is scenario-based and tests practical judgment, not recall. That means you will not be asked to recite a flag name; you will be asked what happens when a misconfigured web tool silently succeeds or when a hook intercepts an outbound request at the wrong pipeline stage.

How does Claude Code's configuration hierarchy govern web access?

The three-level configuration hierarchy controls which tools, MCP servers, and network permissions are available at any given scope. The three levels are:

Web-facing MCP servers are almost always declared at project level so the whole team shares the same endpoint configuration. Credentials, however, belong in local overrides or environment variables, never in version-controlled files. The version control implications concept covers exactly this split: what to commit and what to exclude.

The exam regularly presents scenarios where a developer commits an API key inside a project-level settings file. The correct answer is always to move secrets to environment variables and reference them via ${ENV_VAR} expansion, a pattern covered in MCP environment variable expansion.

How do MCP servers expose web resources to Claude Code?

MCP (Model Context Protocol) servers act as the bridge between Claude Code and external web services. An MCP server registered in the project configuration exposes tools and, optionally, resources. When a web API needs to be callable from inside a Claude Code session, the standard pattern is:

1. Implement or adopt an MCP server that wraps the HTTP client logic.
2. Register the server in .claude/settings.json under mcpServers.
3. Write tool descriptions that tell Claude precisely when to call each endpoint.
4. Set tool_choice constraints where you want deterministic routing rather than model-driven selection.

{
  "mcpServers": {
    "web-search": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-web-search"],
      "env": {
        "SEARCH_API_KEY": "${SEARCH_API_KEY}"
      }
    }
  }
}

Notice the ${SEARCH_API_KEY} reference. The key lives in the developer's shell environment, not in the committed file. This is the pattern the exam rewards.

Poor tool descriptions are the single most common root cause of web-tool misrouting in exam scenarios. The tool descriptions as selection mechanism concept explains why the model treats the description as a routing signal, not mere documentation.

What web-specific tool design patterns appear on the exam?

Tool splitting for web endpoints

A single generic "call web API" tool is an anti-pattern. The exam tests whether you can identify when a broad tool should be split into narrower, purpose-specific tools. For example, a tool called web_request that accepts arbitrary URLs is far harder for the model to route correctly than separate search_web, fetch_documentation, and submit_form tools.

The tool splitting for specificity concept gives the decision rule: split when two use cases have different preconditions, different error modes, or different downstream handling.

Error handling for HTTP failures

Web calls fail in ways that local tool calls do not: timeouts, rate limits, 4xx auth errors, 5xx server errors. The exam distinguishes between:

• Access failure: the tool could not reach the resource (network error, 401, 403).
• Valid empty result: the resource was reached and returned nothing (200 with empty body, 404 on a search).

These are not the same thing and must not be handled the same way. An access failure should set isError: true in the MCP response and surface structured error metadata. A valid empty result should return a success response with an empty payload so the model can reason about absence rather than assume failure. See access failure vs valid empty result for the full pattern.

// Access failure: isError true, structured metadata
{
  "isError": true,
  "content": [
    {
      "type": "text",
      "text": "HTTP 403 Forbidden: insufficient scope for /api/v2/reports"
    }
  ]
}

// Valid empty result: isError false, empty payload
{
  "isError": false,
  "content": [
    {
      "type": "text",
      "text": "Search returned 0 results for query: 'Q3 partner revenue'"
    }
  ]
}

Hook interception for outbound web calls

Claude Code hooks can intercept tool calls before they execute. For web-facing tools, a PreToolUse hook is the correct place to enforce URL allowlists, inject auth headers, or log outbound requests for compliance. A PostToolUse hook is the correct place to normalise response payloads before they re-enter the model's context.

The exam tests the hooks-vs-prompts decision: when should you enforce a web-access policy in a hook rather than in the system prompt? The answer follows the high-stakes enforcement decision rule: if the consequence of a policy violation is irreversible or externally visible (for example, an outbound POST to a production API), use a hook. Prompts are probabilistic; hooks are deterministic.

How does web access interact with agentic workflows?

In multi-agent architectures, web-facing tools often live on subagents rather than the coordinator. This matters because:

• The coordinator should not hold credentials it does not need.
• Subagent context isolation limits the blast radius of a compromised or misbehaving web tool.
• The coordinator can route to the appropriate web-capable subagent based on task type.

The subagent context isolation concept explains why passing only the minimum necessary context to a web-capable subagent is both a security and a reliability practice. The exam will present scenarios where a coordinator passes its full context window to a subagent; the correct answer is almost always to pass a structured, minimal handoff instead.

# Coordinator passes structured context, not raw history
subagent_payload = {
    "task": "fetch_partner_revenue_report",
    "parameters": {
        "partner_id": partner_id,
        "period": "2026-Q2"
    },
    "output_schema": RevenueReport.model_json_schema()
}

This pattern connects to structured context passing, which is tested in Domain 1 (Agentic Architecture & Orchestration, 27%) and reinforces the web-tool patterns in Domain 2.

What does the exam reward when web calls go wrong?

The CCAR-F exam consistently rewards three principles when a scenario involves a failing web integration:

1. Root-cause tracing over symptom patching. If a web tool is returning stale data, the correct answer traces back to whether the cache TTL is misconfigured, not whether to add a retry.
2. Proportionate fixes. If a single tool description is causing misrouting, rewrite the description; do not restructure the entire MCP server.
3. Deterministic solutions over probabilistic ones when stakes are high. If a web call triggers a financial transaction, enforce the constraint in a hook, not in a prompt.

These three principles appear across all five domains but are especially visible in web-tool scenarios because the failure modes are concrete and the consequences are externally visible.

How should you structure your study plan for web-related exam content?

Given the domain weights, a proportionate study allocation for web-related content looks like this:

Domains 2 and 3 are the most directly web-facing. Domain 1 governs how web-capable subagents fit into larger systems. Domains 4 and 5 govern what happens to web data once it enters the model's context.

Our concept library at /concepts maps 174 atomic concepts to these five domains and 30 task statements. The adaptive engine uses Bayesian Knowledge Tracing with a 0.90 mastery threshold, so it will keep routing you back to web-tool concepts until your model is confident you have genuinely mastered them, not just seen them once.

What is the fastest path to exam-ready on claude code web patterns?

Start with the three-level configuration hierarchy and version control implications, because those underpin every other web-tool scenario. Then work through MCP error handling (the isError flag pattern and the access-failure vs valid-empty-result distinction). Finally, study hook interception for outbound calls, because that is where the exam tests whether you understand the deterministic-vs-probabilistic enforcement principle.

If you are using our platform, the Claude Code Configuration & Workflows domain section and the Tool Design & MCP Integration domain section together cover the full surface area. Practice exams mirror the real format: 60 scenario-based items, scored 100 to 1000, with 720 as the passing bar.

The CCAR-F exam costs $125 per attempt and the credential is valid for 12 months from the award date. With Domain 3 and Domain 2 together representing 38% of the exam, web-tool configuration is not a niche topic. It is a core competency.