← Back to daily report

build-with-claude/working-with-messages.md

Changed on 2026-06-27 03:45:07 EST

Unified Diff

--- a/build-with-claude/working-with-messages.md
+++ b/build-with-claude/working-with-messages.md
@@ -6,22 +6,22 @@
 
 Anthropic offers two ways to build with Claude, each suited to different use cases:
 
-| | Messages API | Claude Managed Agents |
-|---|---|---|
-| **What it is** | Direct model prompting access | Pre-built, configurable agent harness that runs in managed infrastructure |
-| **Best for** | Custom agent loops and fine-grained control | Long-running tasks and asynchronous work |
-| **Learn more** | [Messages API docs](/docs/en/build-with-claude/working-with-messages) | [Claude Managed Agents docs](/docs/en/managed-agents/overview) |
+|                | Messages API                                                          | Claude Managed Agents                                                     |
+| -------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| **What it is** | Direct model prompting access                                         | Pre-built, configurable agent harness that runs in managed infrastructure |
+| **Best for**   | Custom agent loops and fine-grained control                           | Long-running tasks and asynchronous work                                  |
+| **Learn more** | [Messages API docs](/docs/en/build-with-claude/working-with-messages) | [Claude Managed Agents docs](/docs/en/managed-agents/overview)            |
 
 This guide covers common patterns for working with the Messages API, including basic requests, multi-turn conversations, prefill techniques, and vision capabilities. For complete API specifications, see the [Messages API reference](/docs/en/api/messages/create).
 
 <Note>
-This feature is eligible for [Zero Data Retention (ZDR)](/docs/en/build-with-claude/api-and-data-retention). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.
+  This feature is eligible for [Zero Data Retention (ZDR)](/docs/en/build-with-claude/api-and-data-retention). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.
 </Note>
 
 ## Basic request and response
 
 <Note>
-The `temperature`, `top_p`, and `top_k` sampling parameters are not supported on Claude Opus 4.7 and later models, including Claude Opus 4.8. Setting them to a non-default value returns a 400 error. Omit them from request payloads and use prompting to guide the model's behavior instead. See the [migration guide](/docs/en/about-claude/models/migration-guide#migrating-from-claude-opus-47).
+  The `temperature`, `top_p`, and `top_k` sampling parameters are not supported on Claude Opus 4.7 and later models, including Claude Opus 4.8. Setting them to a non-default value returns a 400 error. Omit them from request payloads and use prompting to guide the model's behavior instead. See the [migration guide](/docs/en/about-claude/models/migration-guide#migrating-from-claude-opus-47).
 </Note>
 
 <CodeGroup>
@@ -48,9 +48,7 @@
     --message '{role: user, content: "Hello, Claude"}'
   ```
 
-  ```python Python hidelines={1..2}
-  import anthropic
-
+  ```python Python
   message = anthropic.Anthropic().messages.create(
       model="claude-opus-4-8",
       max_tokens=1024,
@@ -59,9 +57,7 @@
   print(message)
   ```
 
-  ```typescript TypeScript hidelines={1..2}
-  import Anthropic from "@anthropic-ai/sdk";
-
+  ```typescript TypeScript
   const anthropic = new Anthropic();
 
   const message = await anthropic.messages.create({
@@ -88,62 +84,36 @@
   Console.WriteLine(message);
   ```
 
-  ```go Go hidelines={1..11,-1}
-  package main
-
-  import (
-  	"context"
-  	"fmt"
-  	"log"
-
-  	"github.com/anthropics/anthropic-sdk-go"
-  )
-
-  func main() {
-  	client := anthropic.NewClient()
-
-  	response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
-  		Model:     anthropic.ModelClaudeOpus4_8,
-  		MaxTokens: 1024,
-  		Messages: []anthropic.MessageParam{
-  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
-  		},
-  	})
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	fmt.Println(response)
-  }
-  ```
-
-  ```java Java hidelines={1..8,-2..}
-  import com.anthropic.client.AnthropicClient;
-  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
-  import com.anthropic.models.messages.MessageCreateParams;
-  import com.anthropic.models.messages.Message;
-  import com.anthropic.models.messages.Model;
-
-  public class Main {
-      public static void main(String[] args) {
-          AnthropicClient client = AnthropicOkHttpClient.fromEnv();
-
-          MessageCreateParams params = MessageCreateParams.builder()
-              .model(Model.CLAUDE_OPUS_4_8)
-              .maxTokens(1024L)
-              .addUserMessage("Hello, Claude")
-              .build();
-
-          Message response = client.messages().create(params);
-          System.out.println(response);
-      }
-  }
-  ```
-
-  ```php PHP hidelines={1..4}
-  <?php
-
-  use Anthropic\Client;
-
+  ```go Go
+  client := anthropic.NewClient()
+
+  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
+  	Model:     anthropic.ModelClaudeOpus4_8,
+  	MaxTokens: 1024,
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
+  	},
+  })
+  if err != nil {
+  	log.Fatal(err)
+  }
+  fmt.Println(response)
+  ```
+
+  ```java Java
+  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
+
+  MessageCreateParams params = MessageCreateParams.builder()
+      .model(Model.CLAUDE_OPUS_4_8)
+      .maxTokens(1024L)
+      .addUserMessage("Hello, Claude")
+      .build();
+
+  Message response = client.messages().create(params);
+  System.out.println(response);
+  ```
+
+  ```php PHP
   $client = new Client();
 
   $message = $client->messages->create(
@@ -154,9 +124,7 @@
   echo $message->content[0]->text;
   ```
 
-  ```ruby Ruby hidelines={1..2}
-  require "anthropic"
-
+  ```ruby Ruby
   client = Anthropic::Client.new
 
   message = client.messages.create(
@@ -198,179 +166,147 @@
 The Messages API is stateless, which means that you always send the full conversational history to the API. You can use this pattern to build up a conversation over time. Earlier conversational turns don't necessarily need to actually originate from Claude. You can use synthetic `assistant` messages.
 
 <CodeGroup>
-```bash cURL
-#!/bin/sh
-curl https://api.anthropic.com/v1/messages \
-     --header "x-api-key: $ANTHROPIC_API_KEY" \
-     --header "anthropic-version: 2023-06-01" \
-     --header "content-type: application/json" \
-     --data \
-'{
-    "model": "claude-opus-4-8",
-    "max_tokens": 1024,
-    "messages": [
-        {"role": "user", "content": "Hello, Claude"},
-        {"role": "assistant", "content": "Hello!"},
-        {"role": "user", "content": "Can you describe LLMs to me?"}
-
+  ```bash cURL
+  #!/bin/sh
+  curl https://api.anthropic.com/v1/messages \
+       --header "x-api-key: $ANTHROPIC_API_KEY" \
+       --header "anthropic-version: 2023-06-01" \
+       --header "content-type: application/json" \
+       --data \
+  '{
+      "model": "claude-opus-4-8",
+      "max_tokens": 1024,
+      "messages": [
+          {"role": "user", "content": "Hello, Claude"},
+          {"role": "assistant", "content": "Hello!"},
+          {"role": "user", "content": "Can you describe LLMs to me?"}
+
+      ]
+  }'
+  ```
+
+  ```bash CLI
+  ant messages create \
+    --model claude-opus-4-8 \
+    --max-tokens 1024 \
+    --message '{role: user, content: "Hello, Claude"}' \
+    --message '{role: assistant, content: "Hello!"}' \
+    --message '{role: user, content: "Can you describe LLMs to me?"}'
+  ```
+
+  ```python Python
+  message = anthropic.Anthropic().messages.create(
+      model="claude-opus-4-8",
+      max_tokens=1024,
+      messages=[
+          {"role": "user", "content": "Hello, Claude"},
+          {"role": "assistant", "content": "Hello!"},
+          {"role": "user", "content": "Can you describe LLMs to me?"},
+      ],
+  )
+  print(message)
+  ```
+
+  ```typescript TypeScript
+  const anthropic = new Anthropic();
+
+  const message = await anthropic.messages.create({
+    model: "claude-opus-4-8",
+    max_tokens: 1024,
+    messages: [
+      { role: "user", content: "Hello, Claude" },
+      { role: "assistant", content: "Hello!" },
+      { role: "user", content: "Can you describe LLMs to me?" }
     ]
-}'
-```
-
-```bash CLI
-ant messages create \
-  --model claude-opus-4-8 \
-  --max-tokens 1024 \
-  --message '{role: user, content: "Hello, Claude"}' \
-  --message '{role: assistant, content: "Hello!"}' \
-  --message '{role: user, content: "Can you describe LLMs to me?"}'
-```
-
-```python Python hidelines={1..2}
-import anthropic
-
-message = anthropic.Anthropic().messages.create(
-    model="claude-opus-4-8",
-    max_tokens=1024,
-    messages=[
-        {"role": "user", "content": "Hello, Claude"},
-        {"role": "assistant", "content": "Hello!"},
-        {"role": "user", "content": "Can you describe LLMs to me?"},
-    ],
-)
-print(message)
-```
-
-```typescript TypeScript hidelines={1..2}
-import Anthropic from "@anthropic-ai/sdk";
-
-const anthropic = new Anthropic();
-
-const message = await anthropic.messages.create({
-  model: "claude-opus-4-8",
-  max_tokens: 1024,
-  messages: [
-    { role: "user", content: "Hello, Claude" },
-    { role: "assistant", content: "Hello!" },
-    { role: "user", content: "Can you describe LLMs to me?" }
-  ]
-});
-console.log(message);
-```
-
-```csharp C#
-using Anthropic;
-using Anthropic.Models.Messages;
-
-AnthropicClient client = new();
-
-var parameters = new MessageCreateParams
-{
-    Model = Model.ClaudeOpus4_8,
-    MaxTokens = 1024,
-    Messages =
-    [
-        new() { Role = Role.User, Content = "Hello, Claude" },
-        new() { Role = Role.Assistant, Content = "Hello!" },
-        new() { Role = Role.User, Content = "Can you describe LLMs to me?" }
+  });
+  console.log(message);
+  ```
+
+  ```csharp C#
+  using Anthropic;
+  using Anthropic.Models.Messages;
+
+  AnthropicClient client = new();
+
+  var parameters = new MessageCreateParams
+  {
+      Model = Model.ClaudeOpus4_8,
+      MaxTokens = 1024,
+      Messages =
+      [
+          new() { Role = Role.User, Content = "Hello, Claude" },
+          new() { Role = Role.Assistant, Content = "Hello!" },
+          new() { Role = Role.User, Content = "Can you describe LLMs to me?" }
+      ]
+  };
+
+  var message = await client.Messages.Create(parameters);
+  Console.WriteLine(message);
+  ```
+
+  ```go Go
+  client := anthropic.NewClient()
+
+  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
+  	Model:     anthropic.ModelClaudeOpus4_8,
+  	MaxTokens: 1024,
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
+  		anthropic.NewAssistantMessage(anthropic.NewTextBlock("Hello!")),
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("Can you describe LLMs to me?")),
+  	},
+  })
+  if err != nil {
+  	log.Fatal(err)
+  }
+  fmt.Println(response)
+  ```
+
+  ```java Java
+  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
+
+  MessageCreateParams params = MessageCreateParams.builder()
+      .model(Model.CLAUDE_OPUS_4_8)
+      .maxTokens(1024L)
+      .addUserMessage("Hello, Claude")
+      .addAssistantMessage("Hello!")
+      .addUserMessage("Can you describe LLMs to me?")
+      .build();
+
+  Message response = client.messages().create(params);
+  System.out.println(response);
+  ```
+
+  ```php PHP
+  $client = new Client();
+
+  $message = $client->messages->create(
+      maxTokens: 1024,
+      messages: [
+          ['role' => 'user', 'content' => 'Hello, Claude'],
+          ['role' => 'assistant', 'content' => 'Hello!'],
+          ['role' => 'user', 'content' => 'Can you describe LLMs to me?'],
+      ],
+      model: 'claude-opus-4-8',
+  );
+
+  echo $message->content[0]->text;
+  ```
+
+  ```ruby Ruby
+  client = Anthropic::Client.new
+
+  message = client.messages.create(
+    model: "claude-opus-4-8",
+    max_tokens: 1024,
+    messages: [
+      { role: "user", content: "Hello, Claude" },
+      { role: "assistant", content: "Hello!" },
+      { role: "user", content: "Can you describe LLMs to me?" }
     ]
-};
-
-var message = await client.Messages.Create(parameters);
-Console.WriteLine(message);
-```
-
-```go Go hidelines={1..11,-1}
-package main
-
-import (
-	"context"
-	"fmt"
-	"log"
-
-	"github.com/anthropics/anthropic-sdk-go"
-)
-
-func main() {
-	client := anthropic.NewClient()
-
-	response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
-		Model:     anthropic.ModelClaudeOpus4_8,
-		MaxTokens: 1024,
-		Messages: []anthropic.MessageParam{
-			anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
-			anthropic.NewAssistantMessage(anthropic.NewTextBlock("Hello!")),
-			anthropic.NewUserMessage(anthropic.NewTextBlock("Can you describe LLMs to me?")),
-		},
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Println(response)
-}
-```
-
-```java Java hidelines={1..8,-2..}
-import com.anthropic.client.AnthropicClient;
-import com.anthropic.client.okhttp.AnthropicOkHttpClient;
-import com.anthropic.models.messages.MessageCreateParams;
-import com.anthropic.models.messages.Message;
-import com.anthropic.models.messages.Model;
-
-public class MultiTurnConversation {
-    public static void main(String[] args) {
-        AnthropicClient client = AnthropicOkHttpClient.fromEnv();
-
-        MessageCreateParams params = MessageCreateParams.builder()
-            .model(Model.CLAUDE_OPUS_4_8)
-            .maxTokens(1024L)
-            .addUserMessage("Hello, Claude")
-            .addAssistantMessage("Hello!")
-            .addUserMessage("Can you describe LLMs to me?")
-            .build();
-
-        Message response = client.messages().create(params);
-        System.out.println(response);
-    }
-}
-```
-
-```php PHP hidelines={1..4}
-<?php
-
-use Anthropic\Client;
-
-$client = new Client();
-
-$message = $client->messages->create(
-    maxTokens: 1024,
-    messages: [
-        ['role' => 'user', 'content' => 'Hello, Claude'],
-        ['role' => 'assistant', 'content' => 'Hello!'],
-        ['role' => 'user', 'content' => 'Can you describe LLMs to me?'],
-    ],
-    model: 'claude-opus-4-8',
-);
-
-echo $message->content[0]->text;
-```
-
-```ruby Ruby hidelines={1..2}
-require "anthropic"
-
-client = Anthropic::Client.new
-
-message = client.messages.create(
-  model: "claude-opus-4-8",
-  max_tokens: 1024,
-  messages: [
-    { role: "user", content: "Hello, Claude" },
-    { role: "assistant", content: "Hello!" },
-    { role: "user", content: "Can you describe LLMs to me?" }
-  ]
-)
-puts message
-```
+  )
+  puts message
+  ```
 </CodeGroup>
 
 ```json Output
@@ -407,7 +343,7 @@
 You can pre-fill part of Claude's response in the last position of the input messages list. This can be used to shape Claude's response. The example below uses `"max_tokens": 1` to get a single multiple choice answer from Claude.
 
 <Warning>
-Prefilling is not supported on Claude Fable 5, [Claude Mythos 5](https://anthropic.com/glasswing), [Claude Mythos Preview](https://anthropic.com/glasswing), Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6. Requests using prefill with these models return a 400 error. Use [structured outputs](/docs/en/build-with-claude/structured-outputs) on models that support it, or system prompt instructions, instead. See the [migration guide](/docs/en/about-claude/models/migration-guide) for migration patterns.
+  Prefilling is not supported on Claude Fable 5, [Claude Mythos 5](https://anthropic.com/glasswing), [Claude Mythos Preview](https://anthropic.com/glasswing), Claude Opus 4.8, Claude Opus 4.7, Claude Opus 4.6, and Claude Sonnet 4.6. Requests using prefill with these models return a 400 error. Use [structured outputs](/docs/en/build-with-claude/structured-outputs) on models that support it, or system prompt instructions, instead. See the [migration guide](/docs/en/about-claude/models/migration-guide) for migration patterns.
 </Warning>
 
 <CodeGroup>
@@ -440,9 +376,7 @@
   YAML
   ```
 
-  ```python Python hidelines={1..2}
-  import anthropic
-
+  ```python Python
   message = anthropic.Anthropic().messages.create(
       model="claude-sonnet-4-5",
       max_tokens=1,
@@ -457,9 +391,7 @@
   print(message)
   ```
 
-  ```typescript TypeScript hidelines={1..2}
-  import Anthropic from "@anthropic-ai/sdk";
-
+  ```typescript TypeScript
   const anthropic = new Anthropic();
 
   const message = await anthropic.messages.create({
@@ -496,64 +428,38 @@
   Console.WriteLine(message);
   ```
 
-  ```go Go hidelines={1..11,-1}
-  package main
-
-  import (
-  	"context"
-  	"fmt"
-  	"log"
-
-  	"github.com/anthropics/anthropic-sdk-go"
-  )
-
-  func main() {
-  	client := anthropic.NewClient()
-
-  	response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
-  		Model:     anthropic.ModelClaudeSonnet4_5,
-  		MaxTokens: 1,
-  		Messages: []anthropic.MessageParam{
-  			anthropic.NewUserMessage(anthropic.NewTextBlock("What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae")),
-  			anthropic.NewAssistantMessage(anthropic.NewTextBlock("The answer is (")),
-  		},
-  	})
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	fmt.Println(response)
-  }
-  ```
-
-  ```java Java hidelines={1..8,-2..}
-  import com.anthropic.client.AnthropicClient;
-  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
-  import com.anthropic.models.messages.MessageCreateParams;
-  import com.anthropic.models.messages.Message;
-  import com.anthropic.models.messages.Model;
-
-  public class PrefillExample {
-      public static void main(String[] args) {
-          AnthropicClient client = AnthropicOkHttpClient.fromEnv();
-
-          MessageCreateParams params = MessageCreateParams.builder()
-              .model(Model.CLAUDE_SONNET_4_5)
-              .maxTokens(1L)
-              .addUserMessage("What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae")
-              .addAssistantMessage("The answer is (")
-              .build();
-
-          Message response = client.messages().create(params);
-          System.out.println(response);
-      }
-  }
-  ```
-
-  ```php PHP hidelines={1..4}
-  <?php
-
-  use Anthropic\Client;
-
+  ```go Go
+  client := anthropic.NewClient()
+
+  response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
+  	Model:     anthropic.ModelClaudeSonnet4_5,
+  	MaxTokens: 1,
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(anthropic.NewTextBlock("What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae")),
+  		anthropic.NewAssistantMessage(anthropic.NewTextBlock("The answer is (")),
+  	},
+  })
+  if err != nil {
+  	log.Fatal(err)
+  }
+  fmt.Println(response)
+  ```
+
+  ```java Java
+  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
+
+  MessageCreateParams params = MessageCreateParams.builder()
+      .model(Model.CLAUDE_SONNET_4_5)
+      .maxTokens(1L)
+      .addUserMessage("What is latin for Ant? (A) Apoidea, (B) Rhopalocera, (C) Formicidae")
+      .addAssistantMessage("The answer is (")
+      .build();
+
+  Message response = client.messages().create(params);
+  System.out.println(response);
+  ```
+
+  ```php PHP
   $client = new Client();
 
   $message = $client->messages->create(
@@ -567,9 +473,7 @@
   echo $message->content[0]->text;
   ```
 
-  ```ruby Ruby hidelines={1..2}
-  require "anthropic"
-
+  ```ruby Ruby
   client = Anthropic::Client.new
 
   message = client.messages.create(
@@ -662,8 +566,7 @@
   }'
   ```
 
-  
-  ```bash CLI nocheck
+  ```bash CLI
   IMAGE_URL="https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
 
   # Option 1: Base64-encoded image (CLI auto-encodes binary @file refs)
@@ -700,9 +603,7 @@
   YAML
   ```
 
-  
-  ```python Python nocheck hidelines={1}
-  import anthropic
+  ```python Python
   import base64
   import httpx
 
@@ -756,10 +657,7 @@
   print(message_from_url)
   ```
 
-  
-  ```typescript TypeScript nocheck hidelines={1..2}
-  import Anthropic from "@anthropic-ai/sdk";
-
+  ```typescript TypeScript
   const anthropic = new Anthropic();
 
   // Option 1: Base64-encoded image
@@ -820,8 +718,7 @@
   console.log(messageFromUrl);
   ```
 
-  
-  ```csharp C# nocheck
+  ```csharp C#
   using System.Collections.Generic;
   using System.Net.Http;
   using Anthropic;
@@ -891,157 +788,119 @@
   Console.WriteLine(messageFromUrl);
   ```
 
-  
-  ```go Go nocheck hidelines={1..16,-1}
-  package main
-
-  import (
-  	"context"
-  	"encoding/base64"
-  	"fmt"
-  	"io"
-  	"log"
-  	"net/http"
-
-  	"github.com/anthropics/anthropic-sdk-go"
-  )
-
-  func main() {
-  	client := anthropic.NewClient()
-
-  	// Option 1: Base64-encoded image
-  	imageURL := "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
-
-  	req, err := http.NewRequest("GET", imageURL, nil)
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	req.Header.Set("User-Agent", "AnthropicDocsBot/1.0")
-
-  	resp, err := http.DefaultClient.Do(req)
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	defer resp.Body.Close()
-
-  	imageBytes, err := io.ReadAll(resp.Body)
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	imageData := base64.StdEncoding.EncodeToString(imageBytes)
-
-  	message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
-  		Model:     anthropic.ModelClaudeOpus4_8,
-  		MaxTokens: 1024,
-  		Messages: []anthropic.MessageParam{
-  			anthropic.NewUserMessage(
-  				anthropic.NewImageBlockBase64("image/jpeg", imageData),
-  				anthropic.NewTextBlock("What is in the above image?"),
-  			),
-  		},
-  	})
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	fmt.Println(message)
-
-  	// Option 2: URL-referenced image
-  	messageFromURL, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
-  		Model:     anthropic.ModelClaudeOpus4_8,
-  		MaxTokens: 1024,
-  		Messages: []anthropic.MessageParam{
-  			anthropic.NewUserMessage(
-  				anthropic.NewImageBlock(anthropic.URLImageSourceParam{
-  					URL: "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
-  				}),
-  				anthropic.NewTextBlock("What is in the above image?"),
-  			),
-  		},
-  	})
-  	if err != nil {
-  		log.Fatal(err)
-  	}
-  	fmt.Println(messageFromURL)
-  }
-  ```
-
-  
-  ```java Java nocheck hidelines={1..12,-2..}
-  import com.anthropic.client.AnthropicClient;
-  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
-  import com.anthropic.models.messages.*;
-  import java.net.URI;
-  import java.net.http.HttpClient;
-  import java.net.http.HttpRequest;
-  import java.net.http.HttpResponse;
-  import java.util.Base64;
-  import java.util.List;
-
-  public class VisionExample {
-      public static void main(String[] args) throws Exception {
-          AnthropicClient client = AnthropicOkHttpClient.fromEnv();
-
-          // Option 1: Base64-encoded image
-          String imageUrl = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg";
-
-          HttpClient httpClient = HttpClient.newHttpClient();
-          HttpRequest request = HttpRequest.newBuilder().uri(URI.create(imageUrl)).build();
-          HttpResponse<byte[]> response = httpClient.send(request, HttpResponse.BodyHandlers.ofByteArray());
-          String imageData = Base64.getEncoder().encodeToString(response.body());
-
-          List<ContentBlockParam> base64Content = List.of(
-              ContentBlockParam.ofImage(
-                  ImageBlockParam.builder()
-                      .source(Base64ImageSource.builder()
-                          .data(imageData)
-                          .mediaType(Base64ImageSource.MediaType.IMAGE_JPEG)
-                          .build())
-                      .build()),
-              ContentBlockParam.ofText(
-                  TextBlockParam.builder()
-                      .text("What is in the above image?")
-                      .build())
-          );
-
-          Message message = client.messages().create(
-              MessageCreateParams.builder()
-                  .model(Model.CLAUDE_OPUS_4_8)
-                  .maxTokens(1024L)
-                  .addUserMessageOfBlockParams(base64Content)
-                  .build());
-          System.out.println(message);
-
-          // Option 2: URL-referenced image
-          List<ContentBlockParam> urlContent = List.of(
-              ContentBlockParam.ofImage(
-                  ImageBlockParam.builder()
-                      .source(UrlImageSource.builder()
-                          .url("https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg")
-                          .build())
-                      .build()),
-              ContentBlockParam.ofText(
-                  TextBlockParam.builder()
-                      .text("What is in the above image?")
-                      .build())
-          );
-
-          Message messageFromUrl = client.messages().create(
-              MessageCreateParams.builder()
-                  .model(Model.CLAUDE_OPUS_4_8)
-                  .maxTokens(1024L)
-                  .addUserMessageOfBlockParams(urlContent)
-                  .build());
-          System.out.println(messageFromUrl);
-      }
-  }
-  ```
-
-  
-  ```php PHP hidelines={1..4} nocheck
-  <?php
-
-  use Anthropic\Client;
-
+  ```go Go
+  // Option 1: Base64-encoded image
+  imageURL := "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg"
+
+  req, err := http.NewRequest("GET", imageURL, nil)
+  if err != nil {
+  	log.Fatal(err)
+  }
+  req.Header.Set("User-Agent", "AnthropicDocsBot/1.0")
+
+  resp, err := http.DefaultClient.Do(req)
+  if err != nil {
+  	log.Fatal(err)
+  }
+  defer resp.Body.Close()
+
+  imageBytes, err := io.ReadAll(resp.Body)
+  if err != nil {
+  	log.Fatal(err)
+  }
+  imageData := base64.StdEncoding.EncodeToString(imageBytes)
+
+  message, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
+  	Model:     anthropic.ModelClaudeOpus4_8,
+  	MaxTokens: 1024,
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(
+  			anthropic.NewImageBlockBase64("image/jpeg", imageData),
+  			anthropic.NewTextBlock("What is in the above image?"),
+  		),
+  	},
+  })
+  if err != nil {
+  	log.Fatal(err)
+  }
+  fmt.Println(message)
+
+  // Option 2: URL-referenced image
+  messageFromURL, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
+  	Model:     anthropic.ModelClaudeOpus4_8,
+  	MaxTokens: 1024,
+  	Messages: []anthropic.MessageParam{
+  		anthropic.NewUserMessage(
+  			anthropic.NewImageBlock(anthropic.URLImageSourceParam{
+  				URL: "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg",
+  			}),
+  			anthropic.NewTextBlock("What is in the above image?"),
+  		),
+  	},
+  })
+  if err != nil {
+  	log.Fatal(err)
+  }
+  fmt.Println(messageFromURL)
+  ```
+
+  ```java Java
+  AnthropicClient client = AnthropicOkHttpClient.fromEnv();
+
+  // Option 1: Base64-encoded image
+  String imageUrl = "https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg";
+
+  HttpClient httpClient = HttpClient.newHttpClient();
+  HttpRequest request = HttpRequest.newBuilder().uri(URI.create(imageUrl)).build();
+  HttpResponse<byte[]> response = httpClient.send(request, HttpResponse.BodyHandlers.ofByteArray());
+  String imageData = Base64.getEncoder().encodeToString(response.body());
+
+  List<ContentBlockParam> base64Content = List.of(
+      ContentBlockParam.ofImage(
+          ImageBlockParam.builder()
+              .source(Base64ImageSource.builder()
+                  .data(imageData)
+                  .mediaType(Base64ImageSource.MediaType.IMAGE_JPEG)
+                  .build())
+              .build()),
+      ContentBlockParam.ofText(
+          TextBlockParam.builder()
+              .text("What is in the above image?")
+              .build())
+  );
+
+  Message message = client.messages().create(
+      MessageCreateParams.builder()
+          .model(Model.CLAUDE_OPUS_4_8)
+          .maxTokens(1024L)
+          .addUserMessageOfBlockParams(base64Content)
+          .build());
+  System.out.println(message);
+
+  // Option 2: URL-referenced image
+  List<ContentBlockParam> urlContent = List.of(
+      ContentBlockParam.ofImage(
+          ImageBlockParam.builder()
+              .source(UrlImageSource.builder()
+                  .url("https://upload.wikimedia.org/wikipedia/commons/a/a7/Camponotus_flavomarginatus_ant.jpg")
+                  .build())
+              .build()),
+      ContentBlockParam.ofText(
+          TextBlockParam.builder()
+              .text("What is in the above image?")
+              .build())
+  );
+
+  Message messageFromUrl = client.messages().create(
+      MessageCreateParams.builder()
+          .model(Model.CLAUDE_OPUS_4_8)
+          .maxTokens(1024L)
+          .addUserMessageOfBlockParams(urlContent)
+          .build());
+  System.out.println(messageFromUrl);
+  ```
+
+  ```php PHP
   $client = new Client();
 
   // Option 1: Base64-encoded image
@@ -1100,9 +959,7 @@
   echo $message_from_url;
   ```
 
-  
-  ```ruby Ruby nocheck hidelines={1}
-  require "anthropic"
+  ```ruby Ruby
   require "base64"
   require "net/http"
 
@@ -1192,16 +1049,20 @@
   <Card title="Stop reasons and fallback" icon="list" href="/docs/en/build-with-claude/handling-stop-reasons">
     Handle each `stop_reason` value and decide what to do when a response ends.
   </Card>
+
   <Card title="Tool use with Claude" icon="wrench" href="/docs/en/agents-and-tools/tool-use/overview">
     Give Claude tools to call external services and APIs from within the Messages API.
   </Card>
+
   <Card title="Computer use tool" icon="computer" href="/docs/en/agents-and-tools/tool-use/computer-use-tool">
     Control desktop computer environments with the Messages API.
   </Card>
+
   <Card title="Structured outputs" icon="code-brackets" href="/docs/en/build-with-claude/structured-outputs">
     Get guaranteed, schema-validated JSON output from Claude.
   </Card>
+
   <Card title="Task budgets" icon="gauge" href="/docs/en/build-with-claude/task-budgets">
     Set an advisory token budget across a full agentic loop with `output_config.task_budget`.
   </Card>
-</CardGroup>+</CardGroup>