Files API

FILE_ID=$(ant files upload \
  --file /path/to/document.pdf \
  --transform id \
  --raw-output)
echo "$FILE_ID"

uploaded = client.files.upload(
    file=("document.pdf", open("/path/to/document.pdf", "rb"), "application/pdf"),
)
file_id = uploaded.id
print(file_id)

const uploaded = await client.files.upload({
  file: await toFile(
    fs.createReadStream("/path/to/document.pdf"),
    undefined,
    { type: "application/pdf" },
  ),
});
console.log(uploaded.id);

var uploaded = await client.Files.Upload(
    new FileUploadParams
    {
        File = new BinaryContent
        {
            Stream = File.OpenRead("/path/to/document.pdf"),
            FileName = "document.pdf",
            ContentType = new("application/pdf")
        }
    });

var fileId = uploaded.ID;
Console.WriteLine(fileId);

f, err := os.Open("/path/to/document.pdf")
if err != nil {
	log.Fatal(err)
}
defer f.Close()

response, err := client.Files.Upload(context.Background(),
	anthropic.FileUploadParams{
		File: anthropic.File(f, "document.pdf", "application/pdf"),
	})
if err != nil {
	log.Fatal(err)
}

fileID := response.ID
fmt.Println(fileID)

FileMetadata file = client.files().upload(
    FileUploadParams.builder()
        .file(MultipartField.<InputStream>builder()
            .value(Files.newInputStream(Path.of("/path/to/document.pdf")))
            .filename("document.pdf")
            .contentType("application/pdf")
            .build())
        .build()
);

String fileId = file.id();
System.out.println(fileId);

$file = $client->files->upload(
    file: FileParam::fromResource(fopen('/path/to/document.pdf', 'rb'), contentType: 'application/pdf'),
);

$fileId = $file->id;
echo $fileId;

file = client.files.upload(
  file: Anthropic::FilePart.new(
    Pathname("/path/to/document.pdf"),
    content_type: "application/pdf"
  )
)

file_id = file.id
puts file_id

curl https://api.anthropic.com/v1/messages
-H "content-type: application/json"
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-d @- <<EOF { "model": "claude-opus-5-5", "max_tokens": 1024, "messages": [ { "role": "user", "content": [ { "type": "text", "text": "Here's the document content:\n\n${TEXT_CONTENT}\n\nPlease summarize this document." } ] } ] } EOF

```bash CLI
# The "@./path" reference inlines the file contents directly into the field.
ant messages create \
  --model claude-opus-5-5 \
  --max-tokens 1024 \
  --transform 'content.#(type=="text").text' \
  --raw-output <<'YAML'
messages:
  - role: user
    content:
      - type: text
        text: "Here's the document content:"
      - type: text
        text: "@./document.txt"
      - type: text
        text: "Please summarize this document."
YAML

client = anthropic.Anthropic()

# Read the text file
with open("document.txt") as f:
    text_content = f.read()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": f"Here's the document content:\n\n{text_content}\n\nPlease summarize this document.",
                }
            ],
        }
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

import fs from "node:fs/promises";
// ...
const client = new Anthropic();

// Read the text file
const textContent = await fs.readFile("document.txt", "utf-8");

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: `Here's the document content:\n\n${textContent}\n\nPlease summarize this document.`
        }
      ]
    }
  ]
});

const textBlock = response.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text"
);
console.log(textBlock?.text);

AnthropicClient client = new();

// Read the text file
string textContent = await File.ReadAllTextAsync("document.txt");

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Messages = [new()
    {
        Role = Role.User,
        Content = $"Here's the document content:\n\n{textContent}\n\nPlease summarize this document."
    }]
};

var message = await client.Messages.Create(parameters);
foreach (var block in message.Content)
{
    if (block.TryPickText(out var textBlock))
    {
        Console.WriteLine(textBlock.Text);
    }
}

client := anthropic.NewClient()

// Read the text file
textContent, err := os.ReadFile("document.txt")
if err != nil {
	log.Fatal(err)
}

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(
			fmt.Sprintf("Here's the document content:\n\n%s\n\nPlease summarize this document.", string(textContent)),
		)),
	},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

// Read the text file
String textContent = Files.readString(Path.of("document.txt"));

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(1024L)
    .addUserMessage("Here's the document content:\n\n" + textContent + "\n\nPlease summarize this document.")
    .build();

Message response = client.messages().create(params);
response.content().stream()
    .flatMap(block -> block.text().stream())
    .forEach(textBlock -> System.out.println(textBlock.text()));

$client = new Client();

// Read the text file
$textContent = file_get_contents("document.txt");

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        [
            'role' => 'user',
            'content' => [
                [
                    'type' => 'text',
                    'text' => "Here's the document content:\n\n{$textContent}\n\nPlease summarize this document."
                ]
            ]
        ]
    ],
    model: 'claude-opus-5-5',
);

foreach ($message->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

# Read the text file
text_content = File.read("document.txt")

message = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "Here's the document content:\n\n#{text_content}\n\nPlease summarize this document."
        }
      ]
    }
  ]
)

message.content.each do |block|
  puts block.text if block.type == :text
end

ant files list --max-items 10

client = anthropic.Anthropic()
files = client.files.list()
print(files)

const client = new Anthropic();
const files = await client.files.list();
console.log(files);

AnthropicClient client = new();

var files = await client.Files.List();
Console.WriteLine(files);

client := anthropic.NewClient()

files, err := client.Files.List(context.TODO(), anthropic.FileListParams{})
if err != nil {
	log.Fatal(err)
}
fmt.Println(files)

import com.anthropic.models.files.FileListPage;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    FileListPage files = client.files().list();
    System.out.println(files);
}

$client = new Client();

$files = $client->files->list();
echo $files;

client = Anthropic::Client.new

files = client.files.list
puts files

ant files retrieve-metadata \
  --file-id "$FILE_ID"

file = client.files.retrieve_metadata(file_id)
print(file)

const file = await client.files.retrieveMetadata(uploaded.id);
console.log(file);

var file = await client.Files.RetrieveMetadata(fileId);
Console.WriteLine(file);

metadata, err := client.Files.GetMetadata(context.TODO(), fileID, anthropic.FileGetMetadataParams{})
if err != nil {
	log.Fatal(err)
}

fmt.Println(metadata)

FileMetadata metadata = client.files().retrieveMetadata(fileId);

System.out.println(metadata);

$file = $client->files->retrieveMetadata($fileId);
echo $file;

file = client.files.retrieve_metadata(file_id)
puts file

ant files delete \
  --file-id "$FILE_ID"

client.files.delete(file_id)

await client.files.delete(uploaded.id);

await client.Files.Delete(fileId);

_, err = client.Files.Delete(context.TODO(), fileID, anthropic.FileDeleteParams{})
if err != nil {
	log.Fatal(err)
}

client.files().delete(fileId);

$client->files->delete($fileId);

client.files.delete(file_id)

ant files download \
  --file-id "$FILE_ID" \
  --output downloaded_file.txt

file_content = client.files.download(file_id)

file_content.write_to_file("downloaded_file.txt")

const content = await client.files.download(uploaded.id);

const bytes = Buffer.from(await content.arrayBuffer());
await fsp.writeFile("downloaded_file.txt", bytes);

using var fileContent = await client.Files.Download(fileId);
await using var source = await fileContent.ReadAsStream();
await using var destination = File.Create("downloaded_file.txt");
await source.CopyToAsync(destination);

func downloadFile(client anthropic.Client, fileID string) error {
	resp, err := client.Files.Download(context.TODO(), fileID, anthropic.FileDownloadParams{})
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	out, err := os.Create("downloaded_file.txt")
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, resp.Body)
	return err
}

try (HttpResponse response = client.files().download(fileId)) {
    try (InputStream body = response.body()) {
        Files.copy(body, Path.of("downloaded_file.txt"),
            StandardCopyOption.REPLACE_EXISTING);
    }
}

$fileContent = $client->files->download($fileId);

file_put_contents('downloaded_file.txt', $fileContent);

file_content = client.files.download(file_id)

File.binwrite("downloaded_file.txt", file_content.read)