Building on the Claude Platform: API to Production

What's inside

1. Level 1: Orientation: The Platform and How to Verify ItFree
   Sets out that this course is independent of Anthropic, maps the main parts of the Claude Platform (Console, Messages API, SDKs, CLI, cloud platforms), and builds the habit of checking every name, limit and beta status against Anthropic's current pages.
2. Level 2: The Console, Organizations and WorkspacesFree
   How an organization is divided into workspaces in the Claude Console, and why the workspace is the unit for isolating environments, resources, spend and rate limits.
3. Level 3: API Keys and Authentication
   How requests are authenticated: the kinds of key and what each can reach, how a key maps to a workspace, and how to keep keys out of code from day one.
4. Level 4: SDKs and the ant CLI: Your First Call
   Installing the official Python and TypeScript SDKs and the ant command-line tool, and making a first successful request with each.
5. Level 5: Under the SDK: Raw HTTP, Headers and Versioning
   What the SDK actually sends: the endpoint, the required headers, the API version header, beta headers and the request ID you will need when debugging.
6. Level 6: Anatomy of a Messages Request and Response
   The shape of the Messages API: the required request fields and a response made of typed content blocks plus metadata, rather than a single string.
7. Level 7: Roles and the System Prompt
   How the user and assistant roles and the top-level system parameter divide responsibility, and what belongs in each.
8. Level 8: Multi-Turn State: The API Remembers Nothing
   The Messages API is stateless, so your application owns the conversation history and resends it on every turn.
9. Level 9: Stop Reasons: Why Generation Ended
   Every successful response says why it stopped, and production code branches on that value instead of assuming the answer is complete.
10. Level 10: max_tokens and Handling Truncated Output
    max_tokens is a hard cap on output, not a target length, and a response that hits it is cut off mid-thought and must be detected and dealt with.
11. Level 11: The Model Family, IDs and the Models API
    The current lineup and its tiers, how model IDs and legacy models work, and how to read capabilities programmatically instead of hard-coding them.
12. Level 12: Choosing a Model by Quality, Latency and Cost
    A practical method for picking a model: start from the task's requirements, compare tiers on price and speed, and let measurements decide.
13. Level 13: Tokens and the usage Object
    What a token is, why token counts differ between model generations, and how to read the usage block that every response returns.
14. Level 14: Context Windows and Budgeting Input and Output
    The context window is a shared budget for everything the model reads and writes, and long conversations need a deliberate plan to stay inside it.
15. Level 15: Counting Tokens Before You Send
    Using the token counting endpoint to measure a request up front, and understanding what it can and cannot count.
16. Level 16: Sampling and Non-Determinism
    Why the same request can return different answers, what the sampling parameters do, and how to design systems that tolerate variation.
17. Level 17: Streaming Responses
    Receiving output incrementally over server-sent events: the event sequence, the SDK helpers, and what changes in error handling.
18. Level 18: Vision: Sending Images
    How to pass images as content blocks, what they cost in tokens, and the limits and weaknesses you should design around.
19. Level 19: Working with PDFs
    Sending PDFs as document blocks so the model can use both the text and the visual content of each page, within the request limits.
20. Level 20: The Files API: Upload Once, Reference by ID
    Uploading files to workspace storage and referencing them by ID across requests, with the lifecycle, limits and isolation rules that come with it.
21. Level 21: Tool Use: Who Runs the Code
    Learn what a tool call is on the wire and how client tools (your code runs them) differ from server tools (Anthropic runs them), using one complete round trip.
22. Level 22: Writing Tool Schemas Claude Calls Correctly
    Design the name, description and input_schema of a tool so the model picks it at the right moment and fills its arguments correctly.
23. Level 23: The Tool Loop in Code
    Build the loop that keeps calling the Messages API until Claude stops asking for tools, with correct message history at every step.
24. Level 24: tool_choice and Parallel Tool Calls
    Control whether and how Claude calls tools with tool_choice, and handle responses that contain several tool calls at once.
25. Level 25: Tool Results and Tool Errors
    Shape what goes back to the model after a tool runs, including failures, so Claude can recover instead of inventing an answer.
26. Level 26: Strict Tool Use
    Use strict: true to guarantee tool names and inputs match your schema, and learn the schema limits that come with that guarantee.
27. Level 27: Server Tool Mechanics and pause_turn
    Understand the plumbing every server tool shares: server_tool_use blocks, the server-side loop, pause_turn, and turns that mix server and client tools.
28. Level 28: Web Search and Web Fetch
    Give Claude live web access with the web search and web fetch server tools, and control their reach, cost and data handling.
29. Level 29: Code Execution and Programmatic Tool Calling
    Run Python and bash in Anthropic's sandboxed container, and let code in that sandbox call your own tools through allowed_callers.
30. Level 30: Tool Search and the Advisor Tool
    Scale to large tool catalogues with the tool search tool and defer_loading, and meet the advisor tool, which was still in beta when this course was checked.
31. Level 31: The MCP Connector
    Connect the Messages API directly to remote MCP servers with the beta MCP connector, without writing an MCP client.
32. Level 32: Skills in the API
    Attach Anthropic-built and custom Agent Skills to a request through the container parameter, and manage custom skills with the Skills API.
33. Level 33: Structured Outputs with JSON Schema
    Constrain Claude's final answer to a JSON Schema with output_config.format, and use the SDK helpers that turn Pydantic or Zod models into typed results.
34. Level 34: Defensive Parsing: When the Schema Still Fails
    Write the code around structured outputs that survives refusals, truncation and semantically wrong but schema-valid data.
35. Level 35: Adaptive Thinking: Turning Reasoning On
    Learn how thinking works on current models, where Claude decides per request whether and how much to reason, and what that does to your response shape and bill.
36. Level 36: The Effort Parameter
    Use output_config.effort as the calibrated control for depth, latency and cost, and measure its effect before changing prompts.
37. Level 37: Thinking with Tools, History and Legacy Budgets
    Keep thinking correct across tool loops and multi-turn conversations, and recognise where the manual budget_tokens mode still applies.
38. Level 38: Prompt Caching Fundamentals
    Understand what prompt caching stores, how prefix matching works, what it costs to write and read, and how to confirm it is working.
39. Level 39: Cache Breakpoints and TTLs
    Place explicit cache breakpoints across tools, system and messages, and choose between the 5-minute and 1-hour lifetimes.
40. Level 40: Cache Invalidation and Hit-Rate Debugging
    Find out why a cache misses in production, covering the tools, system, messages hierarchy and the settings that quietly break a prefix.
41. Level 41: Citations: Answers That Point at Their Sources
    Turn on citations for document blocks so each claim in a response carries a pointer to the exact passage that supports it, and learn what that rules out.
42. Level 42: Retrieval in Outline: Chunking and Indexing
    Why you retrieve rather than stuff everything into a large context window, and how chunking and indexing choices decide what the model can ever see.
43. Level 43: Retrieval in Outline: Search and Grounded Answers
    Query the index, hand the results to Claude as citable search-result content, and make the model answer only from what was retrieved.
44. Level 44: Reading API Errors: Status Codes, Types, Request IDs
    Map every HTTP status and error type the API returns to a cause and a decision: fix the request, fix the account, or try again.
45. Level 45: Rate Limits: Tiers, Token Buckets and Headers
    How requests-per-minute, input-token and output-token limits are set per usage tier and model, how the token bucket refills, and how to read your remaining headroom.
46. Level 46: Retries and Backoff That Do Not Make Things Worse
    Build on the SDK's built-in retries with a deliberate policy that separates retryable faults from ones that will keep failing.
47. Level 47: Timeouts, Long Requests and Mid-Stream Failures
    Keep long generations alive and recover cleanly when a connection drops or an error arrives after the 200 has already been sent.
48. Level 48: Cost Modelling: From Token Prices to a Monthly Bill
    Build a spreadsheet-grade cost model in Python that prices a feature per request and per month before it ships.
49. Level 49: Usage Tracking and Spend Controls in Your App
    Record what every call actually consumed, attribute it to a feature and customer, and put hard ceilings in place before a runaway loop finds them for you.
50. Level 50: Evaluation I: Building a Test Set
    Turn 'it seems to work' into a versioned dataset of inputs and expected behaviour that reflects real traffic, edge cases and known failures.
51. Level 51: Evaluation II: Graders — Code, Model and Human
    Pick the cheapest grader that is reliable for each criterion, and prove a model-based grader agrees with people before trusting it.
52. Level 52: Evaluation III: Regression Runs and Release Gates
    Run the test set automatically on every prompt, model or parameter change and block the release when quality, latency or cost slips.
53. Level 53: Guardrails: Screening, Refusals and Fallbacks
    Layer input screening, output checks and refusal handling around the model so that one failed defence is not the whole defence.
54. Level 54: Prompt Injection: Direct and Indirect
    Defend separately against users attacking your prompt and against hostile instructions hidden in web pages, files, emails and tool results.
55. Level 55: Personal Data, Secrets and Key Management
    Keep personal data and credentials out of prompts, logs and repositories, and run API keys like the production secrets they are.
56. Level 56: Model Pinning and the Model Lifecycle
    Choose exactly which model ID production calls, and track active, legacy, deprecated and retired states so a retirement never arrives as an outage.
57. Level 57: Prompt Versioning and Safe Rollout
    Treat prompts, tool definitions and request parameters as versioned release artefacts that can be reviewed, rolled out gradually and rolled back.
58. Level 58: Migrating Between Model Releases
    Move a working application to a newer model by checking the breaking changes first, re-running evals, and re-tuning rather than swapping an ID and hoping.
59. Level 59: Claude on AWS: Bedrock and Claude Platform on AWS
    Tell apart the AWS routes to Claude — the partner-operated Bedrock endpoints and the Anthropic-operated Claude Platform on AWS — and what each changes in your code and feature set.
60. Level 60: Claude on Google Cloud
    Run the same Messages requests through Google Cloud's platform and account for the differences in request shape, model IDs, endpoints and supported features.
61. Level 61: The Admin API: Members, Workspaces and Keys in Code
    How to manage an organisation's members, invites, workspaces and API keys programmatically with Admin API credentials, which are separate from the workspace keys used for inference, and how to do it safely.
62. Level 62: The Usage and Cost API: Reconciling Real Spend
    How to pull the organisation's authoritative token usage and USD cost reports and reconcile them against the application's own per-request usage tracking.
63. Level 63: The Rate Limits API: Headroom Alerts and Config Audit
    How to read the organisation's and each workspace's configured rate limits programmatically and combine them with usage data to alert before throttling starts and to catch configuration drift.
64. Level 64: Final Challenge: From API Key to Production Exam
    A comprehensive review that takes one application from first request to operated service, drawing on every phase of the course: Messages API, models and tokens, tools, output control and throughput, reliability, cost, evaluation, security and operations.

Access

The first 2 levels are free with a free account. Every level, the podcast edition and the AI tutor come with All Access at £4.99/month or any Creator plan — see pricing.

Start free →