References: The Messages API in production

Source material

Source curriculum (structural mirror, cited as further study):
• Anthropic Academy (https://anthropic.skilljar.com/):
    "Building with the Claude API" course (production sections)
  Anthropic Academy is a free training catalog hosted on Skilljar
    (full course content requires a free Anthropic account; the
    course catalog itself is public).
  License: Anthropic Academy course content is account-gated;
    Clawdemy structurally mirrors the Academy's lesson progression
    as inspiration and cites it as further study. Every substantive
    claim in this lesson is verifiable against the public Anthropic
    documentation.

Primary public-doc anchors (every substantive claim verified against):
• Anthropic, "Using the Messages API"
  https://platform.claude.com/docs/en/build-with-claude/working-with-messages
• Anthropic, "Streaming messages"
  https://platform.claude.com/docs/en/build-with-claude/streaming
• Anthropic, "Batch processing"
  https://platform.claude.com/docs/en/build-with-claude/batch-processing
• Anthropic, "Errors"
  https://platform.claude.com/docs/en/api/errors
• Anthropic, "Client SDKs"
  https://platform.claude.com/docs/en/api/client-sdks
  Note: the docs domain migrated from docs.anthropic.com to
    platform.claude.com/docs in late 2025.

Verbatim claims sourced from the public docs:
• "most batches finishing in less than 1 hour while reducing costs
   by 50%" (Batch processing page; paraphrased into the lesson's
   "50 percent less" and "most batches finish in under one hour")
• Request size limits (32 MB Messages, 256 MB Batches, 500 MB Files)
   from the Errors page request size limits table
• HTTP status code map from the Errors page top-of-page list
• Streaming context-manager and event-emitter SDK patterns
   from the Streaming messages page Python and TypeScript examples

Required attribution: "Based on the structure of the Anthropic Academy
  'Building with the Claude API' course
  (https://anthropic.skilljar.com/). This lesson is an independent
  structural mirror in original prose; every substantive claim is
  verified against the public Anthropic Claude documentation at
  https://platform.claude.com/docs/. Anthropic does not endorse it."

This is lesson 2 of 12 in Track 22 (Building with Claude). The previous
lesson is lesson 1 (Your first Claude API call); the next is lesson 3
(Choosing your model and the effort dial). All three together are
Phase 1, the foundations every later T22 lesson extends.

Watch / read this next

• Anthropic, “Streaming messages”. The deeper reference; covers the full SSE event sequence (message_start, content_block_delta, message_delta, message_stop) and SDK helper methods beyond get_final_message() / finalMessage().
• Anthropic, “Batch processing”. The Message Batches API in full: submission shape, the custom_id convention, status polling, and the result-streaming flow this lesson sketches.
• Anthropic, “Errors”. The full error-code map and the request_id convention. Includes the 10-minute timeout discussion and the TCP keep-alive note for direct API integrators.
• Anthropic, “Client SDKs”. The official SDK landing page; confirms all seven (Python, TypeScript, Java, Go, Ruby, C#, PHP) plus the CLI are Anthropic-published, and lists per-SDK minimum version requirements.

Going deeper

A short, durable list. Each link is a specific next step inside Track 22, not a generic pile.

• Lesson 3 of this track, “Choosing your model and the effort dial.” Opus / Sonnet / Haiku trade-offs; when extended thinking and the effort parameter earn their keep; the cost / latency / quality trade. Closes Phase 1.
• Lesson 4 of this track, “Tool use, the foundation.” What stop_reason: tool_use means and how to handle the tool-use / tool-result loop the next four lessons all extend.
• Lesson 7 of this track, “Prompt caching and context management.” The cost shape this lesson named (“every turn pays for the full prior history” from lesson 1; batches at 50 percent here) gets a third lever: cache stable system prompts and context blocks so repeated calls pay only for the new parts.
• Lesson 12 of this track, “Shipping a Claude application.” Where the request_id + usage logging habit from this lesson turns into cost-per-feature dashboards via the Admin / Usage / Cost APIs.
• Anthropic, “Welcome to Claude”. The two-paths framing (Messages API for full control, Claude Managed Agents for long-running tasks) lesson 12 closes the track on.

Adjacent tracks (the natural next destinations)

• Track 21 (LLM Ops and Production): pick this if you want the provider-agnostic view of LLM production discipline (LLMOps as a category; lesson 7 there). T22 lesson 12 cross-references T21 lesson 7 “LLMOps” explicitly; the request_id + usage logging habit introduced here is a specific Anthropic-side instance of the T21 LLMOps observability principle.
• Track 5 (AI Foundations): pick this if you want the broader-than-Claude view of what LLMs are and what they can / cannot do. The conceptual prerequisite Track 22 does not re-derive.

Where this connects inside the track

The production-side floor every later lesson extends:

• Lesson 1 (first call): this lesson is the same call with the production patterns added on the response, error, retry, and batch sides. Streaming response is the same Message shape, just delivered chunk by chunk.
• Lesson 3 (model selection): the model parameter from lesson 1’s request body, now with a proper selection conversation (Opus vs Sonnet vs Haiku, the effort dial, extended thinking).
• Lessons 4-5 (tool use): the stop_reason: tool_use case lesson 1 named but did not handle. Mid-stream tool-call handling extends this lesson’s streaming patterns.
• Lesson 6 (Model Context Protocol): how to define one tool that works across many providers.
• Lesson 7 (prompt caching): the cost lever this lesson did not cover. With caching, batches, and the standard call, you have three cost dials.
• Lesson 8 (agent loop): when one call becomes a loop. Streaming, errors, retries, and request_id logging all extend into the loop.
• Lesson 12 (shipping): the request_id + usage data this lesson logs becomes the input to production cost monitoring via the Admin / Usage / Cost APIs.