skills-guide changedbuild-with-claude/skills-guide
Nearest release: v2.1.238, published under an hour after this site recorded the change. Shown because the two are within 24 hours of each other. Nothing here says the release caused the edit.
Recorded here
Lines+597added
Lines−738removed
From line
9
where the diff opens
First seen
14 Aug 2026
this site's first read of the page
Recorded edits21to this page, all time
The whole hunk
from line 9, old and new numbered
/
The two sides of this change are more than 400 edits apart, too far apart to line up, so this is the differ's own diff of it and the words inside a line are not marked.
from line 9
99<Note>
1010 For complete API reference including request/response schemas and all parameters, see:
1111
12 * [Skill Management API Reference](https://platform.claude.com/docs/en/api/beta/skills/list) - CRUD operations for Skills
13 * [Skill Versions API Reference](https://platform.claude.com/docs/en/api/beta/skills/versions/list) - Version management
12 * [Skill Management API Reference](https://platform.claude.com/docs/en/api/skills/list) - CRUD operations for Skills
13 * [Skill Versions API Reference](https://platform.claude.com/docs/en/api/skills/versions/list) - Version management
1414</Note>
1515
1616<Note>
from line 43
4343
4444You can use Skills from two sources:
4545
46| Aspect | Anthropic Skills | Custom Skills |
47| ------------------ | ------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
48| **Type value** | `anthropic` | `custom` |
49| **Skill IDs** | Short names: `pptx`, `xlsx`, `docx`, `pdf` | Generated: `skill_01AbCdEfGhIjKlMnOpQrStUv` |
50| **Version format** | Date-based: `20251013` or `latest` | Version ID: `skver_01AbCdEfGhIjKlMnOpQrStUv` or `latest` |
51| **Management** | Pre-built and maintained by Anthropic | Upload and manage through the [Skills API](https://platform.claude.com/docs/en/api/beta/skills/create) |
52| **Availability** | Available to all users | Private to your workspace |
53
54Both skill sources are returned by the [List Skills endpoint](https://platform.claude.com/docs/en/api/beta/skills/list) (use the `source` parameter to filter). The integration shape and execution environment are identical. The only difference is where the Skills come from and how they're managed.
46| Aspect | Anthropic Skills | Custom Skills |
47| ------------------ | ------------------------------------------ | ------------------------------------------------------------------------------------------------- |
48| **Type value** | `anthropic` | `custom` |
49| **Skill IDs** | Short names: `pptx`, `xlsx`, `docx`, `pdf` | Generated: `skill_01AbCdEfGhIjKlMnOpQrStUv` |
50| **Version format** | Date-based: `20251013` or `latest` | Version ID: `skver_01AbCdEfGhIjKlMnOpQrStUv` or `latest` |
51| **Management** | Pre-built and maintained by Anthropic | Upload and manage through the [Skills API](https://platform.claude.com/docs/en/api/skills/create) |
52| **Availability** | Available to all users | Private to your workspace |
53
54Both skill sources are returned by the [List Skills endpoint](https://platform.claude.com/docs/en/api/skills/list) (use the `source` parameter to filter). The integration shape and execution environment are identical. The only difference is where the Skills come from and how they're managed.
5555
5656### Prerequisites
5757
from line 60
60601. **Claude API key** from the [Claude Console](https://platform.claude.com/settings/keys)
61612. **[Code execution tool](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool)** enabled in your requests
6262
63Skills are generally available on the Claude API and don't require an `anthropic-beta` header, either for the Skills API or for `container.skills` in Messages requests. The examples in this guide still send the `skills-2025-10-02` beta header (plus `code-execution-2025-08-25` in Messages requests) and use the SDKs' `beta` namespace. Both headers remain valid opt-ins, so the examples work as written, and you can omit them in your own requests.
63Skills are generally available on the Claude API and don't require an `anthropic-beta` header, either for the Skills API or for `container.skills` in Messages requests. Requests that still send the `skills-2025-10-02` beta header keep working, and Skills API requests that send it keep the earlier beta response format. The PHP tabs on this page still call the SDK's `beta` namespace and send that header, so their printed output shows the earlier response fields.
6464
6565Skills require the code execution tool, so use a model from its [model compatibility list](https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool#model-compatibility).
6666
from line 79
7979 curl https://api.anthropic.com/v1/messages \
8080 -H "x-api-key: $ANTHROPIC_API_KEY" \
8181 -H "anthropic-version: 2023-06-01" \
82 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
8382 -H "content-type: application/json" \
8483 -d '{
8584 "model": "claude-opus-5",
from line 104
105104 ```
106105
107106 ```bash CLI
108 ant beta:messages create \
109 --beta code-execution-2025-08-25,skills-2025-10-02 <<'YAML'
107 ant messages create <<'YAML'
110108 model: claude-opus-5
111109 max_tokens: 4096
112110 container:
from line 124
126124 ```python Python
127125 client = anthropic.Anthropic()
128126
129 response = client.beta.messages.create(
127 response = client.messages.create(
130128 model="claude-opus-5",
131129 max_tokens=4096,
132 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
133130 container={
134131 "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
135132 },
from line 140
143140 ```typescript TypeScript
144141 const client = new Anthropic();
145142
146 const response = await client.beta.messages.create({
143 const response = await client.messages.create({
147144 model: "claude-opus-5",
148145 max_tokens: 4096,
149 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
150146 container: {
151147 skills: [
152148 {
from line 174
178174 {
179175 Model = "claude-opus-5",
180176 MaxTokens = 4096,
181 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
182 Container = new BetaContainerParams
177 Container = new ContainerParams
183178 {
184179 Skills =
185180 [
186 new BetaSkillParams
181 new SkillParams
187182 {
188 Type = BetaSkillParamsType.Anthropic,
183 Type = SkillParamsType.Anthropic,
189184 SkillID = "pptx",
190185 Version = "latest",
191186 },
192187 ],
193188 },
194189 Messages = [new() { Role = Role.User, Content = "Create a presentation about renewable energy" }],
195 Tools = [new BetaCodeExecutionTool20250825()],
190 Tools = [new CodeExecutionTool20250825()],
196191 };
197192
198 var message = await client.Beta.Messages.Create(parameters);
193 var message = await client.Messages.Create(parameters);
199194 Console.WriteLine(message);
200195 ```
201196
202197 ```go Go
203198 client := anthropic.NewClient()
204199
205 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
200 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
206201 Model: "claude-opus-5",
207202 MaxTokens: 4096,
208 Betas: []anthropic.AnthropicBeta{
209 "code-execution-2025-08-25",
210 anthropic.AnthropicBetaSkills2025_10_02,
211 },
212 Container: anthropic.BetaMessageNewParamsContainerUnion{
213 OfContainers: &anthropic.BetaContainerParams{
214 Skills: []anthropic.BetaSkillParams{
203 Container: anthropic.MessageCreateParamsContainerUnion{
204 OfContainers: &anthropic.ContainerParams{
205 Skills: []anthropic.SkillParams{
215206 {
216 Type: anthropic.BetaSkillParamsTypeAnthropic,
207 Type: anthropic.SkillParamsTypeAnthropic,
217208 SkillID: "pptx",
218209 Version: anthropic.String("latest"),
219210 },
220211 },
221212 },
222213 },
223 Messages: []anthropic.BetaMessageParam{
224 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a presentation about renewable energy")),
214 Messages: []anthropic.MessageParam{
215 anthropic.NewUserMessage(anthropic.NewTextBlock("Create a presentation about renewable energy")),
225216 },
226 Tools: []anthropic.BetaToolUnionParam{
227 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
217 Tools: []anthropic.ToolUnionParam{
218 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
228219 },
229220 })
230221 if err != nil {
from line 225
234225 ```
235226
236227 ```java Java
237 import com.anthropic.models.beta.messages.BetaContainerParams;
238 import com.anthropic.models.beta.messages.BetaSkillParams;
239 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
228 import com.anthropic.models.messages.ContainerParams;
229 import com.anthropic.models.messages.SkillParams;
230 import com.anthropic.models.messages.CodeExecutionTool20250825;
240231 // ...
241232 void main() {
242233 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 235
244235 MessageCreateParams params = MessageCreateParams.builder()
245236 .model(Model.CLAUDE_OPUS_5)
246237 .maxTokens(4096L)
247 .addBeta("code-execution-2025-08-25")
248 .addBeta("skills-2025-10-02")
249 .container(BetaContainerParams.builder()
250 .addSkill(BetaSkillParams.builder()
251 .type(BetaSkillParams.Type.ANTHROPIC)
238 .container(ContainerParams.builder()
239 .addSkill(SkillParams.builder()
240 .type(SkillParams.Type.ANTHROPIC)
252241 .skillId("pptx")
253242 .version("latest")
254243 .build())
255244 .build())
256245 .addUserMessage("Create a presentation about renewable energy")
257 .addTool(BetaCodeExecutionTool20250825.builder().build())
246 .addTool(CodeExecutionTool20250825.builder().build())
258247 .build();
259248
260 BetaMessage response = client.beta().messages().create(params);
249 Message response = client.messages().create(params);
261250 System.out.println(response);
262251 }
263252 ```
from line 281
292281 ```ruby Ruby
293282 client = Anthropic::Client.new
294283
295 message = client.beta.messages.create(
284 message = client.messages.create(
296285 model: "claude-opus-5",
297286 max_tokens: 4096,
298 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
299287 container: {
300288 skills: [
301289 {
from line 325
337325 RESPONSE=$(curl https://api.anthropic.com/v1/messages \
338326 -H "x-api-key: $ANTHROPIC_API_KEY" \
339327 -H "anthropic-version: 2023-06-01" \
340 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
341328 -H "content-type: application/json" \
342329 -d '{
343330 "model": "claude-opus-5",
from line 350
363350 # Step 3: Get filename from metadata
364351 FILENAME=$(curl "https://api.anthropic.com/v1/files/$FILE_ID" \
365352 -H "x-api-key: $ANTHROPIC_API_KEY" \
366 -H "anthropic-version: 2023-06-01" \
367 -H "anthropic-beta: files-api-2025-04-14" | jq -r '.filename')
353 -H "anthropic-version: 2023-06-01" | jq -r '.filename')
368354
369355 # Step 4: Download the file using Files API
370356 curl "https://api.anthropic.com/v1/files/$FILE_ID/content" \
371357 -H "x-api-key: $ANTHROPIC_API_KEY" \
372358 -H "anthropic-version: 2023-06-01" \
373 -H "anthropic-beta: files-api-2025-04-14" \
374359 --output "$FILENAME"
375360
376361 echo "Downloaded: $FILENAME"
from line 364
379364 ```bash CLI
380365 # Step 1: Use the xlsx Skill to create a file
381366 # Step 2: Extract file_id from the response with --transform (GJSON path)
382 FILE_ID=$(ant beta:messages create \
383 --beta code-execution-2025-08-25,skills-2025-10-02 \
367 FILE_ID=$(ant messages create \
384368 --transform 'content.#.content.content.#.file_id|@flatten|0' \
385369 --raw-output <<'YAML'
386370 model: claude-opus-5
from line 384
400384 )
401385
402386 # Step 3: Get the filename from file metadata
403 FILENAME=$(ant beta:files retrieve-metadata \
387 FILENAME=$(ant files retrieve-metadata \
404388 --file-id "$FILE_ID" \
405389 --transform filename \
406390 --raw-output)
407391
408392 # Step 4: Download the file using Files API
409 ant beta:files download \
393 ant files download \
410394 --file-id "$FILE_ID" \
411395 --output "$FILENAME" > /dev/null
412396
from line 401
417401 client = anthropic.Anthropic()
418402
419403 # Step 1: Use a Skill to create a file
420 response = client.beta.messages.create(
404 response = client.messages.create(
421405 model="claude-opus-5",
422406 max_tokens=4096,
423 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
424407 container={
425408 "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
426409 },
from line 432
449432
450433 # Step 3: Download the file using Files API
451434 for file_id in extract_file_ids(response):
452 file_metadata = client.beta.files.retrieve_metadata(file_id=file_id)
453 file_content = client.beta.files.download(file_id=file_id)
435 file_metadata = client.files.retrieve_metadata(file_id=file_id)
436 file_content = client.files.download(file_id=file_id)
454437
455438 # Step 4: Save to disk
456439 file_content.write_to_file(file_metadata.filename)
from line 446
463446 const client = new Anthropic();
464447
465448 // Step 1: Use a Skill to create a file
466 const response = await client.beta.messages.create({
449 const response = await client.messages.create({
467450 model: "claude-opus-5",
468451 max_tokens: 4096,
469 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
470452 container: {
471453 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
472454 },
from line 476
494476
495477 // Step 3: Download each file and save to disk
496478 for (const fileId of fileIds) {
497 const fileMetadata = await client.beta.files.retrieveMetadata(fileId);
498 const fileResponse = await client.beta.files.download(fileId);
479 const fileMetadata = await client.files.retrieveMetadata(fileId);
480 const fileResponse = await client.files.download(fileId);
499481
500482 await writeFile(fileMetadata.filename, Buffer.from(await fileResponse.arrayBuffer()));
501483 console.log(`Downloaded: ${fileMetadata.filename}`);
from line 492
510492 {
511493 Model = "claude-opus-5",
512494 MaxTokens = 4096,
513 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
514 Container = new BetaContainerParams
495 Container = new ContainerParams
515496 {
516497 Skills =
517498 [
518 new BetaSkillParams
499 new SkillParams
519500 {
520 Type = BetaSkillParamsType.Anthropic,
501 Type = SkillParamsType.Anthropic,
521502 SkillID = "xlsx",
522503 Version = "latest",
523504 },
524505 ],
525506 },
526507 Messages = [new() { Role = Role.User, Content = "Create an Excel file with a simple budget spreadsheet" }],
527 Tools = [new BetaCodeExecutionTool20250825()],
508 Tools = [new CodeExecutionTool20250825()],
528509 };
529510
530 var response = await client.Beta.Messages.Create(parameters);
511 var response = await client.Messages.Create(parameters);
531512
532513 // Step 2: Extract file IDs from the response
533514 List<string> fileIds = [];
534515 foreach (var block in response.Content)
535516 {
536517 if (block.TryPickBashCodeExecutionToolResult(out var toolResult)
537 && toolResult.Content.TryPickBetaBashCodeExecutionResultBlock(out var result))
518 && toolResult.Content.TryPickBashCodeExecutionResultBlock(out var result))
538519 {
539520 foreach (var output in result.Content)
540521 {
from line 527
546527 // Step 3: Download each file and save to disk
547528 foreach (var fileId in fileIds)
548529 {
549 var fileMetadata = await client.Beta.Files.RetrieveMetadata(fileId);
550 using var download = await client.Beta.Files.Download(fileId);
530 var fileMetadata = await client.Files.RetrieveMetadata(fileId);
531 using var download = await client.Files.Download(fileId);
551532 using var downloadStream = await download.ReadAsStream();
552533 using var outputFile = File.Create(fileMetadata.Filename);
553534 await downloadStream.CopyToAsync(outputFile);
from line 541
560541 client := anthropic.NewClient()
561542
562543 // Step 1: Use a Skill to create a file
563 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
544 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
564545 Model: "claude-opus-5",
565546 MaxTokens: 4096,
566 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
567 Container: anthropic.BetaMessageNewParamsContainerUnion{
568 OfContainers: &anthropic.BetaContainerParams{
569 Skills: []anthropic.BetaSkillParams{
547 Container: anthropic.MessageCreateParamsContainerUnion{
548 OfContainers: &anthropic.ContainerParams{
549 Skills: []anthropic.SkillParams{
570550 {
571 Type: anthropic.BetaSkillParamsTypeAnthropic,
551 Type: anthropic.SkillParamsTypeAnthropic,
572552 SkillID: "xlsx",
573553 Version: anthropic.String("latest"),
574554 },
575555 },
576556 },
577557 },
578 Messages: []anthropic.BetaMessageParam{
579 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create an Excel file with a simple budget spreadsheet")),
558 Messages: []anthropic.MessageParam{
559 anthropic.NewUserMessage(anthropic.NewTextBlock("Create an Excel file with a simple budget spreadsheet")),
580560 },
581 Tools: []anthropic.BetaToolUnionParam{
582 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
561 Tools: []anthropic.ToolUnionParam{
562 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
583563 },
584564 })
585565 if err != nil {
from line 571
591571
592572 // Step 3: Download the file using Files API
593573 for _, fileID := range fileIDs {
594 fileMetadata, err := client.Beta.Files.GetMetadata(context.TODO(), fileID, anthropic.BetaFileGetMetadataParams{})
574 fileMetadata, err := client.Files.GetMetadata(context.TODO(), fileID)
595575 if err != nil {
596576 log.Fatal(err)
597577 }
598578
599 fileContent, err := client.Beta.Files.Download(context.TODO(), fileID, anthropic.BetaFileDownloadParams{})
579 fileContent, err := client.Files.Download(context.TODO(), fileID)
600580 if err != nil {
601581 log.Fatal(err)
602582 }
from line 595
615595 }
616596 }
617597
618 func extractFileIDs(response *anthropic.BetaMessage) []string {
598 func extractFileIDs(response *anthropic.Message) []string {
619599 var fileIDs []string
620600 for _, item := range response.Content {
621601 switch v := item.AsAny().(type) {
622 case anthropic.BetaBashCodeExecutionToolResultBlock:
602 case anthropic.BashCodeExecutionToolResultBlock:
623603 if v.Content.Type == "bash_code_execution_result" {
624604 for _, output := range v.Content.Content {
625605 fileIDs = append(fileIDs, output.FileID)
from line 612
632612 ```
633613
634614 ```java Java
635 import com.anthropic.models.beta.messages.BetaContainerParams;
636 import com.anthropic.models.beta.messages.BetaSkillParams;
637 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
638 import com.anthropic.models.beta.messages.BetaContentBlock;
639 import com.anthropic.models.beta.files.FileMetadata;
615 import com.anthropic.models.messages.ContainerParams;
616 import com.anthropic.models.messages.SkillParams;
617 import com.anthropic.models.messages.CodeExecutionTool20250825;
618 import com.anthropic.models.messages.ContentBlock;
619 import com.anthropic.models.files.FileMetadata;
640620 import com.anthropic.core.http.HttpResponse;
641621 // ...
642622 void main() throws Exception {
from line 626
646626 MessageCreateParams params = MessageCreateParams.builder()
647627 .model(Model.CLAUDE_OPUS_5)
648628 .maxTokens(4096L)
649 .addBeta("code-execution-2025-08-25")
650 .addBeta("skills-2025-10-02")
651 .container(BetaContainerParams.builder()
652 .addSkill(BetaSkillParams.builder()
653 .type(BetaSkillParams.Type.ANTHROPIC)
629 .container(ContainerParams.builder()
630 .addSkill(SkillParams.builder()
631 .type(SkillParams.Type.ANTHROPIC)
654632 .skillId("xlsx")
655633 .version("latest")
656634 .build())
657635 .build())
658636 .addUserMessage("Create an Excel file with a simple budget spreadsheet")
659 .addTool(BetaCodeExecutionTool20250825.builder().build())
637 .addTool(CodeExecutionTool20250825.builder().build())
660638 .build();
661639
662 BetaMessage response = client.beta().messages().create(params);
640 Message response = client.messages().create(params);
663641
664642 // Step 2: Extract file IDs from the response
665643 List<String> fileIds = new ArrayList<>();
666 for (BetaContentBlock block : response.content()) {
644 for (ContentBlock block : response.content()) {
667645 if (block.isBashCodeExecutionToolResult()) {
668646 var content = block.asBashCodeExecutionToolResult().content();
669 if (content.isBetaBashCodeExecutionResultBlock()) {
670 for (var outputBlock : content.asBetaBashCodeExecutionResultBlock().content()) {
647 if (content.isBashCodeExecutionResultBlock()) {
648 for (var outputBlock : content.asBashCodeExecutionResultBlock().content()) {
671649 fileIds.add(outputBlock.fileId());
672650 }
673651 }
from line 654
676654
677655 // Step 3: Download the file using Files API
678656 for (String fileId : fileIds) {
679 FileMetadata fileMetadata = client.beta().files().retrieveMetadata(fileId);
680 HttpResponse fileContent = client.beta().files().download(fileId);
657 FileMetadata fileMetadata = client.files().retrieveMetadata(fileId);
658 HttpResponse fileContent = client.files().download(fileId);
681659
682660 // Step 4: Save to disk
683661 try (InputStream is = fileContent.body();
from line 719
741719 client = Anthropic::Client.new
742720
743721 # Step 1: Use a Skill to create a file
744 response = client.beta.messages.create(
722 response = client.messages.create(
745723 model: "claude-opus-5",
746724 max_tokens: 4096,
747 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
748725 container: {
749726 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
750727 },
from line 752
775752
776753 # Step 3: Download the file using Files API
777754 extract_file_ids(response).each do |file_id|
778 file_metadata = client.beta.files.retrieve_metadata(file_id)
779
780 file_content = client.beta.files.download(file_id)
755 file_metadata = client.files.retrieve_metadata(file_id)
756
757 file_content = client.files.download(file_id)
781758
782759 # Step 4: Save to disk
783760 File.binwrite(file_metadata.filename, file_content.read)
from line 770
793770 # Get file metadata
794771 curl "https://api.anthropic.com/v1/files/$FILE_ID" \
795772 -H "x-api-key: $ANTHROPIC_API_KEY" \
796 -H "anthropic-version: 2023-06-01" \
797 -H "anthropic-beta: files-api-2025-04-14"
773 -H "anthropic-version: 2023-06-01"
798774
799775 # List all files
800776 curl "https://api.anthropic.com/v1/files" \
801777 -H "x-api-key: $ANTHROPIC_API_KEY" \
802 -H "anthropic-version: 2023-06-01" \
803 -H "anthropic-beta: files-api-2025-04-14"
778 -H "anthropic-version: 2023-06-01"
804779
805780 # Delete a file
806781 curl -X DELETE "https://api.anthropic.com/v1/files/$FILE_ID" \
807782 -H "x-api-key: $ANTHROPIC_API_KEY" \
808 -H "anthropic-version: 2023-06-01" \
809 -H "anthropic-beta: files-api-2025-04-14"
783 -H "anthropic-version: 2023-06-01"
810784 ```
811785
812786 ```bash CLI
813787 # Get file metadata
814 ant beta:files retrieve-metadata \
788 ant files retrieve-metadata \
815789 --file-id "$FILE_ID" \
816790 --transform '{filename,size_bytes}' \
817791 --format yaml
818792
819793 # List all files
820 ant beta:files list \
794 ant files list \
821795 --transform '{filename,created_at}' \
822796 --format yaml
823797
824798 # Delete a file
825 ant beta:files delete --file-id "$FILE_ID" >/dev/null
799 ant files delete --file-id "$FILE_ID" >/dev/null
826800 ```
827801
828802 ```python Python
829803 client = anthropic.Anthropic()
830804 file_id = "file_011CNha8iCJcU1wXNR6q4V8w"
831805 # Get file metadata
832 file_info = client.beta.files.retrieve_metadata(file_id=file_id)
806 file_info = client.files.retrieve_metadata(file_id=file_id)
833807 print(f"Filename: {file_info.filename}, Size: {file_info.size_bytes} bytes")
834808
835809 # List all files
836 for file in client.beta.files.list():
810 for file in client.files.list():
837811 print(f"{file.filename} - {file.created_at}")
838812
839813 # Delete a file
840 client.beta.files.delete(file_id=file_id)
814 client.files.delete(file_id=file_id)
841815 ```
842816
843817 ```typescript TypeScript
from line 819
845819 const fileId = "file_011CNha8iCJcU1wXNR6q4V8w";
846820
847821 // Get file metadata
848 const fileInfo = await client.beta.files.retrieveMetadata(fileId);
822 const fileInfo = await client.files.retrieveMetadata(fileId);
849823 console.log(`Filename: ${fileInfo.filename}, Size: ${fileInfo.size_bytes} bytes`);
850824
851825 // List all files
852 for await (const file of client.beta.files.list()) {
826 for await (const file of client.files.list()) {
853827 console.log(`${file.filename} - ${file.created_at}`);
854828 }
855829
856830 // Delete a file
857 await client.beta.files.delete(fileId);
831 await client.files.delete(fileId);
858832 ```
859833
860834 ```csharp C#
from line 837
863837 var fileId = "file_011CNha8iCJcU1wXNR6q4V8w";
864838
865839 // Get file metadata
866 var fileInfo = await client.Beta.Files.RetrieveMetadata(fileId);
840 var fileInfo = await client.Files.RetrieveMetadata(fileId);
867841 Console.WriteLine($"Filename: {fileInfo.Filename}, Size: {fileInfo.SizeBytes} bytes");
868842
869843 // List files
870 await foreach (var file in (await client.Beta.Files.List()).Paginate())
844 await foreach (var file in (await client.Files.List()).Paginate())
871845 {
872846 Console.WriteLine($"{file.Filename} - {file.CreatedAt}");
873847 }
874848
875849 // Delete the file
876 await client.Beta.Files.Delete(fileId);
850 await client.Files.Delete(fileId);
877851 ```
878852
879853 ```go Go
from line 855
881855 fileID := "file_011CNha8iCJcU1wXNR6q4V8w"
882856
883857 // Get file metadata
884 fileInfo, err := client.Beta.Files.GetMetadata(context.TODO(), fileID, anthropic.BetaFileGetMetadataParams{})
858 fileInfo, err := client.Files.GetMetadata(context.TODO(), fileID)
885859 if err != nil {
886860 log.Fatal(err)
887861 }
888862 fmt.Printf("Filename: %s, Size: %d bytes\n", fileInfo.Filename, fileInfo.SizeBytes)
889863
890864 // List all files
891 files := client.Beta.Files.ListAutoPaging(context.TODO(), anthropic.BetaFileListParams{})
865 files := client.Files.ListAutoPaging(context.TODO(), anthropic.FileListParams{})
892866 for files.Next() {
893867 file := files.Current()
894868 fmt.Printf("%s - %s\n", file.Filename, file.CreatedAt)
from line 872
898872 }
899873
900874 // Delete a file
901 _, err = client.Beta.Files.Delete(context.TODO(), fileID, anthropic.BetaFileDeleteParams{})
875 _, err = client.Files.Delete(context.TODO(), fileID)
902876 if err != nil {
903877 log.Fatal(err)
904878 }
905879 ```
906880
907881 ```java Java
908 import com.anthropic.models.beta.files.FileMetadata;
909 import com.anthropic.models.beta.files.FileListPage;
882 import com.anthropic.models.files.FileMetadata;
883 import com.anthropic.models.files.FileListPage;
910884 // ...
911885 void main() {
912886 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
913887 String fileId = "file_011CNha8iCJcU1wXNR6q4V8w";
914888
915889 // Get file metadata
916 FileMetadata fileInfo = client.beta().files().retrieveMetadata(fileId);
890 FileMetadata fileInfo = client.files().retrieveMetadata(fileId);
917891 System.out.println("Filename: " + fileInfo.filename() + ", Size: " + fileInfo.sizeBytes() + " bytes");
918892
919893 // List files (first page)
920 FileListPage files = client.beta().files().list();
894 FileListPage files = client.files().list();
921895 for (var file : files.data()) {
922896 System.out.println(file.filename() + " - " + file.createdAt());
923897 }
924898
925899 // Delete a file
926 client.beta().files().delete(fileId);
900 client.files().delete(fileId);
927901 }
928902 ```
929903
from line 924
950924 file_id = "file_011CNha8iCJcU1wXNR6q4V8w"
951925
952926 # Get file metadata
953 file_info = client.beta.files.retrieve_metadata(file_id)
927 file_info = client.files.retrieve_metadata(file_id)
954928 puts "Filename: #{file_info.filename}, Size: #{file_info.size_bytes} bytes"
955929
956930 # List all files
957 client.beta.files.list.auto_paging_each do |file|
931 client.files.list.auto_paging_each do |file|
958932 puts "#{file.filename} - #{file.created_at}"
959933 end
960934
961935 # Delete a file
962 client.beta.files.delete(file_id)
936 client.files.delete(file_id)
963937 ```
964938</CodeGroup>
965939
from line 955
981955
982956 ```bash CLI
983957 # First request creates container
984 CONTAINER_ID=$(ant beta:messages create \
985 --beta code-execution-2025-08-25,skills-2025-10-02 \
958 CONTAINER_ID=$(ant messages create \
986959 --transform container.id \
987960 --raw-output <<'YAML'
988961 model: claude-opus-5
from line 972
999972 )
1000973
1001974 # Continue conversation with same container
1002 ant beta:messages create \
1003 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
975 ant messages create <<YAML
1004976 model: claude-opus-5
1005977 max_tokens: 4096
1006978 container:
from line 995
1023995 client = anthropic.Anthropic()
1024996
1025997 # First request creates container
1026 response1 = client.beta.messages.create(
998 response1 = client.messages.create(
1027999 model="claude-opus-5",
10281000 max_tokens=4096,
1029 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
10301001 container={
10311002 "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
10321003 },
from line 1020
10491020 {"role": "user", "content": "What was the total revenue?"},
10501021 ]
10511022
1052 response2 = client.beta.messages.create(
1023 response2 = client.messages.create(
10531024 model="claude-opus-5",
10541025 max_tokens=4096,
1055 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
10561026 container={
10571027 "id": response1.container.id, # Reuse container
10581028 "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}],
from line 1036
10661036 const client = new Anthropic();
10671037
10681038 // First request creates container
1069 const response1 = await client.beta.messages.create({
1039 const response1 = await client.messages.create({
10701040 model: "claude-opus-5",
10711041 max_tokens: 4096,
1072 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
10731042 container: {
10741043 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
10751044 },
from line 1047
10781047 });
10791048
10801049 // Continue conversation with same container
1081 const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
1050 const messages: Anthropic.MessageParam[] = [
10821051 { role: "user", content: "Create a sample sales dataset and analyze it" },
10831052 {
10841053 role: "assistant",
from line 1060
10911060 { role: "user", content: "What was the total revenue?" }
10921061 ];
10931062
1094 const response2 = await client.beta.messages.create({
1063 const response2 = await client.messages.create({
10951064 model: "claude-opus-5",
10961065 max_tokens: 4096,
1097 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
10981066 container: {
10991067 id: response1.container!.id, // Reuse container
11001068 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
from line 1080
11121080 {
11131081 Model = "claude-opus-5",
11141082 MaxTokens = 4096,
1115 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
1116 Container = new BetaContainerParams
1083 Container = new ContainerParams
11171084 {
11181085 Skills =
11191086 [
1120 new BetaSkillParams
1087 new SkillParams
11211088 {
1122 Type = BetaSkillParamsType.Anthropic,
1089 Type = SkillParamsType.Anthropic,
11231090 SkillID = "xlsx",
11241091 Version = "latest",
11251092 },
11261093 ],
11271094 },
11281095 Messages = [new() { Role = Role.User, Content = "Create a sample sales dataset and analyze it" }],
1129 Tools = [new BetaCodeExecutionTool20250825()],
1096 Tools = [new CodeExecutionTool20250825()],
11301097 };
11311098
1132 var response1 = await client.Beta.Messages.Create(parameters1);
1099 var response1 = await client.Messages.Create(parameters1);
11331100
11341101 // Continue the conversation in the same container
11351102 // Carry the assistant's text forward; container.id carries the execution state
from line 1109
11421109 {
11431110 Model = "claude-opus-5",
11441111 MaxTokens = 4096,
1145 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
1146 Container = new BetaContainerParams
1112 Container = new ContainerParams
11471113 {
11481114 ID = response1.Container!.ID,
11491115 Skills =
11501116 [
1151 new BetaSkillParams
1117 new SkillParams
11521118 {
1153 Type = BetaSkillParamsType.Anthropic,
1119 Type = SkillParamsType.Anthropic,
11541120 SkillID = "xlsx",
11551121 Version = "latest",
11561122 },
from line 1128
11621128 new() { Role = Role.Assistant, Content = assistantText },
11631129 new() { Role = Role.User, Content = "What was the total revenue?" },
11641130 ],
1165 Tools = [new BetaCodeExecutionTool20250825()],
1131 Tools = [new CodeExecutionTool20250825()],
11661132 };
11671133
1168 var response2 = await client.Beta.Messages.Create(parameters2);
1134 var response2 = await client.Messages.Create(parameters2);
11691135 Console.WriteLine(response2);
11701136 ```
11711137
11721138 ```go Go
11731139 client := anthropic.NewClient()
11741140
1175 response1, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
1141 response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
11761142 Model: "claude-opus-5",
11771143 MaxTokens: 4096,
1178 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
1179 Container: anthropic.BetaMessageNewParamsContainerUnion{
1180 OfContainers: &anthropic.BetaContainerParams{
1181 Skills: []anthropic.BetaSkillParams{
1144 Container: anthropic.MessageCreateParamsContainerUnion{
1145 OfContainers: &anthropic.ContainerParams{
1146 Skills: []anthropic.SkillParams{
11821147 {
1183 Type: anthropic.BetaSkillParamsTypeAnthropic,
1148 Type: anthropic.SkillParamsTypeAnthropic,
11841149 SkillID: "xlsx",
11851150 Version: anthropic.String("latest"),
11861151 },
11871152 },
11881153 },
11891154 },
1190 Messages: []anthropic.BetaMessageParam{
1191 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a sample sales dataset and analyze it")),
1155 Messages: []anthropic.MessageParam{
1156 anthropic.NewUserMessage(anthropic.NewTextBlock("Create a sample sales dataset and analyze it")),
11921157 },
1193 Tools: []anthropic.BetaToolUnionParam{
1194 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
1158 Tools: []anthropic.ToolUnionParam{
1159 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
11951160 },
11961161 })
11971162 if err != nil {
from line 1172
12071172 }
12081173 assistantText := strings.Join(textParts, "\n")
12091174
1210 response2, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
1175 response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
12111176 Model: "claude-opus-5",
12121177 MaxTokens: 4096,
1213 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
1214 Container: anthropic.BetaMessageNewParamsContainerUnion{
1215 OfContainers: &anthropic.BetaContainerParams{
1178 Container: anthropic.MessageCreateParamsContainerUnion{
1179 OfContainers: &anthropic.ContainerParams{
12161180 ID: anthropic.String(response1.Container.ID), // Reuse container
1217 Skills: []anthropic.BetaSkillParams{
1181 Skills: []anthropic.SkillParams{
12181182 {
1219 Type: anthropic.BetaSkillParamsTypeAnthropic,
1183 Type: anthropic.SkillParamsTypeAnthropic,
12201184 SkillID: "xlsx",
12211185 Version: anthropic.String("latest"),
12221186 },
12231187 },
12241188 },
12251189 },
1226 Messages: []anthropic.BetaMessageParam{
1227 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a sample sales dataset and analyze it")),
1190 Messages: []anthropic.MessageParam{
1191 anthropic.NewUserMessage(anthropic.NewTextBlock("Create a sample sales dataset and analyze it")),
12281192 {
1229 Role: anthropic.BetaMessageParamRoleAssistant,
1230 Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock(assistantText)},
1193 Role: anthropic.MessageParamRoleAssistant,
1194 Content: []anthropic.ContentBlockParamUnion{anthropic.NewTextBlock(assistantText)},
12311195 },
1232 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What was the total revenue?")),
1196 anthropic.NewUserMessage(anthropic.NewTextBlock("What was the total revenue?")),
12331197 },
1234 Tools: []anthropic.BetaToolUnionParam{
1235 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
1198 Tools: []anthropic.ToolUnionParam{
1199 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
12361200 },
12371201 })
12381202 if err != nil {
from line 1207
12431207 ```
12441208
12451209 ```java Java
1246 import com.anthropic.models.beta.messages.BetaContainerParams;
1247 import com.anthropic.models.beta.messages.BetaSkillParams;
1248 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
1249 import com.anthropic.models.beta.messages.BetaContentBlock;
1210 import com.anthropic.models.messages.ContainerParams;
1211 import com.anthropic.models.messages.SkillParams;
1212 import com.anthropic.models.messages.CodeExecutionTool20250825;
1213 import com.anthropic.models.messages.ContentBlock;
12501214 // ...
12511215 void main() {
12521216 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 1218
12541218 MessageCreateParams params1 = MessageCreateParams.builder()
12551219 .model(Model.CLAUDE_OPUS_5)
12561220 .maxTokens(4096L)
1257 .addBeta("code-execution-2025-08-25")
1258 .addBeta("skills-2025-10-02")
1259 .container(BetaContainerParams.builder()
1260 .addSkill(BetaSkillParams.builder()
1261 .type(BetaSkillParams.Type.ANTHROPIC)
1221 .container(ContainerParams.builder()
1222 .addSkill(SkillParams.builder()
1223 .type(SkillParams.Type.ANTHROPIC)
12621224 .skillId("xlsx")
12631225 .version("latest")
12641226 .build())
12651227 .build())
12661228 .addUserMessage("Create a sample sales dataset and analyze it")
1267 .addTool(BetaCodeExecutionTool20250825.builder().build())
1229 .addTool(CodeExecutionTool20250825.builder().build())
12681230 .build();
12691231
1270 BetaMessage response1 = client.beta().messages().create(params1);
1232 Message response1 = client.messages().create(params1);
12711233
12721234 MessageCreateParams params2 = MessageCreateParams.builder()
12731235 .model(Model.CLAUDE_OPUS_5)
12741236 .maxTokens(4096L)
1275 .addBeta("code-execution-2025-08-25")
1276 .addBeta("skills-2025-10-02")
1277 .container(BetaContainerParams.builder()
1237 .container(ContainerParams.builder()
12781238 .id(response1.container().get().id())
1279 .addSkill(BetaSkillParams.builder()
1280 .type(BetaSkillParams.Type.ANTHROPIC)
1239 .addSkill(SkillParams.builder()
1240 .type(SkillParams.Type.ANTHROPIC)
12811241 .skillId("xlsx")
12821242 .version("latest")
12831243 .build())
from line 1245
12851245 .addUserMessage("Create a sample sales dataset and analyze it")
12861246 // Carry the assistant's text forward; container.id carries the execution state
12871247 .addAssistantMessage(response1.content().stream()
1288 .filter(BetaContentBlock::isText)
1248 .filter(ContentBlock::isText)
12891249 .map(block -> block.asText().text())
12901250 .collect(Collectors.joining("\n")))
12911251 .addUserMessage("What was the total revenue?")
1292 .addTool(BetaCodeExecutionTool20250825.builder().build())
1252 .addTool(CodeExecutionTool20250825.builder().build())
12931253 .build();
12941254
1295 BetaMessage response2 = client.beta().messages().create(params2);
1255 Message response2 = client.messages().create(params2);
12961256 System.out.println(response2);
12971257 }
12981258 ```
from line 1309
13491309 ```ruby Ruby
13501310 client = Anthropic::Client.new
13511311
1352 response1 = client.beta.messages.create(
1312 response1 = client.messages.create(
13531313 model: "claude-opus-5",
13541314 max_tokens: 4096,
1355 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
13561315 container: {
13571316 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
13581317 },
from line 1333
13741333 { role: "user", content: "What was the total revenue?" }
13751334 ]
13761335
1377 response2 = client.beta.messages.create(
1336 response2 = client.messages.create(
13781337 model: "claude-opus-5",
13791338 max_tokens: 4096,
1380 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
13811339 container: {
13821340 id: response1.container.id,
13831341 skills: [
from line 1362
14041362 RESPONSE=$(curl https://api.anthropic.com/v1/messages \
14051363 -H "x-api-key: $ANTHROPIC_API_KEY" \
14061364 -H "anthropic-version: 2023-06-01" \
1407 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
14081365 -H "content-type: application/json" \
14091366 -d '{
14101367 "model": "claude-opus-5",
from line 1394
14371394 RESPONSE=$(curl https://api.anthropic.com/v1/messages \
14381395 -H "x-api-key: $ANTHROPIC_API_KEY" \
14391396 -H "anthropic-version: 2023-06-01" \
1440 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
14411397 -H "content-type: application/json" \
14421398 -d "{
14431399 \"model\": \"claude-opus-5\",
from line 1418
14621418 RESP=$(mktemp)
14631419
14641420 # Initial request: capture the full JSON response to a temp file
1465 ant beta:messages create \
1466 --beta code-execution-2025-08-25,skills-2025-10-02 \
1467 > "$RESP" <<'YAML'
1421 ant messages create > "$RESP" <<'YAML'
14681422 model: claude-opus-5
14691423 max_tokens: 4096
14701424 container:
from line 1439
14851439 # assistant turn. Repeat until stop_reason is no longer "pause_turn".
14861440 CONTAINER_ID=$(jq -r '.container.id' "$RESP")
14871441
1488 ant beta:messages create \
1489 --beta code-execution-2025-08-25,skills-2025-10-02 \
1490 > "$RESP" <<YAML
1442 ant messages create > "$RESP" <<YAML
14911443 model: claude-opus-5
14921444 max_tokens: 4096
14931445 container:
from line 1461
15091461 messages = [{"role": "user", "content": "Generate and process a large sample dataset"}]
15101462 max_retries = 10
15111463
1512 response = client.beta.messages.create(
1464 response = client.messages.create(
15131465 model="claude-opus-5",
15141466 max_tokens=4096,
1515 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
15161467 container={
15171468 "skills": [
15181469 {
from line 1483
15321483 break
15331484
15341485 messages.append({"role": "assistant", "content": response.content})
1535 response = client.beta.messages.create(
1486 response = client.messages.create(
15361487 model="claude-opus-5",
15371488 max_tokens=4096,
1538 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
15391489 container={
15401490 "id": response.container.id,
15411491 "skills": [
from line 1503
15531503
15541504 ```typescript TypeScript
15551505 const client = new Anthropic();
1556 const messages: Anthropic.Beta.Messages.BetaMessageParam[] = [
1506 const messages: Anthropic.MessageParam[] = [
15571507 { role: "user", content: "Generate and process a large sample dataset" }
15581508 ];
15591509 const maxRetries = 10;
15601510
1561 let response = await client.beta.messages.create({
1511 let response = await client.messages.create({
15621512 model: "claude-opus-5",
15631513 max_tokens: 4096,
1564 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
15651514 container: {
15661515 skills: [{ type: "custom", skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv", version: "latest" }]
15671516 },
from line 1526
15771526
15781527 messages.push({
15791528 role: "assistant",
1580 content: response.content as Anthropic.Beta.Messages.BetaContentBlockParam[]
1529 content: response.content as Anthropic.ContentBlockParam[]
15811530 });
1582 response = await client.beta.messages.create({
1531 response = await client.messages.create({
15831532 model: "claude-opus-5",
15841533 max_tokens: 4096,
1585 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
15861534 container: {
15871535 id: response.container!.id,
15881536 skills: [
from line 1548
16001548 // ...
16011549 AnthropicClient client = new();
16021550
1603 List<BetaMessageParam> messages =
1551 List<MessageParam> messages =
16041552 [
16051553 new() { Role = Role.User, Content = "Generate and process a large sample dataset" },
16061554 ];
16071555
16081556 var maxRetries = 10;
16091557 string? containerId = null;
1610 BetaMessage? response = null;
1558 Message? response = null;
16111559
16121560 for (var i = 0; i < maxRetries; i++)
16131561 {
from line 1563
16151563 {
16161564 Model = "claude-opus-5",
16171565 MaxTokens = 4096,
1618 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
16191566 Container = containerId is null
1620 ? new BetaContainerParams
1567 ? new ContainerParams
16211568 {
16221569 Skills =
16231570 [
1624 new BetaSkillParams
1571 new SkillParams
16251572 {
1626 Type = BetaSkillParamsType.Custom,
1573 Type = SkillParamsType.Custom,
16271574 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
16281575 Version = "latest",
16291576 },
16301577 ],
16311578 }
1632 : new BetaContainerParams
1579 : new ContainerParams
16331580 {
16341581 ID = containerId,
16351582 Skills =
16361583 [
1637 new BetaSkillParams
1584 new SkillParams
16381585 {
1639 Type = BetaSkillParamsType.Custom,
1586 Type = SkillParamsType.Custom,
16401587 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
16411588 Version = "latest",
16421589 },
16431590 ],
16441591 },
16451592 Messages = messages,
1646 Tools = [new BetaCodeExecutionTool20250825()],
1593 Tools = [new CodeExecutionTool20250825()],
16471594 };
16481595
1649 response = await client.Beta.Messages.Create(parameters);
1596 response = await client.Messages.Create(parameters);
16501597 containerId = response.Container!.ID;
16511598
1652 if (response.StopReason != BetaStopReason.PauseTurn)
1599 if (response.StopReason != StopReason.PauseTurn)
16531600 {
16541601 break;
16551602 }
from line 1605
16581605 var assistantContent = JsonSerializer.SerializeToElement(
16591606 response.Content.Select(block => block.Json).ToArray()
16601607 );
1661 messages.Add(new() { Role = Role.Assistant, Content = new BetaMessageParamContent(assistantContent) });
1608 messages.Add(new() { Role = Role.Assistant, Content = new MessageParamContent(assistantContent) });
16621609 }
16631610 ```
16641611
16651612 ```go Go
16661613 client := anthropic.NewClient()
16671614
1668 messages := []anthropic.BetaMessageParam{
1669 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Generate and process a large sample dataset")),
1615 messages := []anthropic.MessageParam{
1616 anthropic.NewUserMessage(anthropic.NewTextBlock("Generate and process a large sample dataset")),
16701617 }
16711618 maxRetries := 10
16721619
1673 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
1620 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
16741621 Model: "claude-opus-5",
16751622 MaxTokens: 4096,
1676 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
1677 Container: anthropic.BetaMessageNewParamsContainerUnion{
1678 OfContainers: &anthropic.BetaContainerParams{
1679 Skills: []anthropic.BetaSkillParams{
1623 Container: anthropic.MessageCreateParamsContainerUnion{
1624 OfContainers: &anthropic.ContainerParams{
1625 Skills: []anthropic.SkillParams{
16801626 {
1681 Type: anthropic.BetaSkillParamsTypeCustom,
1627 Type: anthropic.SkillParamsTypeCustom,
16821628 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
16831629 Version: anthropic.String("latest"),
16841630 },
from line 1632
16861632 },
16871633 },
16881634 Messages: messages,
1689 Tools: []anthropic.BetaToolUnionParam{
1690 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
1635 Tools: []anthropic.ToolUnionParam{
1636 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
16911637 },
16921638 })
16931639 if err != nil {
from line 1641
16951641 }
16961642
16971643 for i := 0; i < maxRetries; i++ {
1698 if response.StopReason != anthropic.BetaStopReasonPauseTurn {
1644 if response.StopReason != anthropic.StopReasonPauseTurn {
16991645 break
17001646 }
17011647
17021648 messages = append(messages, response.ToParam())
17031649
1704 response, err = client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
1650 response, err = client.Messages.New(context.TODO(), anthropic.MessageNewParams{
17051651 Model: "claude-opus-5",
17061652 MaxTokens: 4096,
1707 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
1708 Container: anthropic.BetaMessageNewParamsContainerUnion{
1709 OfContainers: &anthropic.BetaContainerParams{
1653 Container: anthropic.MessageCreateParamsContainerUnion{
1654 OfContainers: &anthropic.ContainerParams{
17101655 ID: anthropic.String(response.Container.ID), // Reuse container
1711 Skills: []anthropic.BetaSkillParams{
1656 Skills: []anthropic.SkillParams{
17121657 {
1713 Type: anthropic.BetaSkillParamsTypeCustom,
1658 Type: anthropic.SkillParamsTypeCustom,
17141659 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
17151660 Version: anthropic.String("latest"),
17161661 },
from line 1663
17181663 },
17191664 },
17201665 Messages: messages,
1721 Tools: []anthropic.BetaToolUnionParam{
1722 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
1666 Tools: []anthropic.ToolUnionParam{
1667 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
17231668 },
17241669 })
17251670 if err != nil {
from line 1676
17311676 ```
17321677
17331678 ```java Java
1734 import com.anthropic.models.beta.messages.BetaContainerParams;
1735 import com.anthropic.models.beta.messages.BetaSkillParams;
1736 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
1737 import com.anthropic.models.beta.messages.BetaStopReason;
1679 import com.anthropic.models.messages.ContainerParams;
1680 import com.anthropic.models.messages.SkillParams;
1681 import com.anthropic.models.messages.CodeExecutionTool20250825;
1682 import com.anthropic.models.messages.StopReason;
17381683 // ...
17391684 void main() {
17401685 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
17411686
1742 List<BetaMessageParam> messages = new ArrayList<>();
1687 List<MessageParam> messages = new ArrayList<>();
17431688 messages.add(
1744 BetaMessageParam.builder()
1745 .role(BetaMessageParam.Role.USER)
1689 MessageParam.builder()
1690 .role(MessageParam.Role.USER)
17461691 .content("Generate and process a large sample dataset")
17471692 .build()
17481693 );
17491694 int maxRetries = 10;
17501695
1751 BetaMessage response = client.beta().messages().create(
1696 Message response = client.messages().create(
17521697 MessageCreateParams.builder()
17531698 .model(Model.CLAUDE_OPUS_5)
17541699 .maxTokens(4096L)
1755 .addBeta("code-execution-2025-08-25")
1756 .addBeta("skills-2025-10-02")
1757 .container(BetaContainerParams.builder()
1758 .addSkill(BetaSkillParams.builder()
1759 .type(BetaSkillParams.Type.CUSTOM)
1700 .container(ContainerParams.builder()
1701 .addSkill(SkillParams.builder()
1702 .type(SkillParams.Type.CUSTOM)
17601703 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
17611704 .version("latest")
17621705 .build())
17631706 .build())
17641707 .messages(messages)
1765 .addTool(BetaCodeExecutionTool20250825.builder().build())
1708 .addTool(CodeExecutionTool20250825.builder().build())
17661709 .build());
17671710
17681711 for (int i = 0; i < maxRetries; i++) {
17691712 if (!response.stopReason().isPresent()
1770 || !response.stopReason().get().equals(BetaStopReason.PAUSE_TURN)) {
1713 || !response.stopReason().get().equals(StopReason.PAUSE_TURN)) {
17711714 break;
17721715 }
17731716
17741717 messages.add(response.toParam());
17751718
1776 response = client.beta().messages().create(
1719 response = client.messages().create(
17771720 MessageCreateParams.builder()
17781721 .model(Model.CLAUDE_OPUS_5)
17791722 .maxTokens(4096L)
1780 .addBeta("code-execution-2025-08-25")
1781 .addBeta("skills-2025-10-02")
1782 .container(BetaContainerParams.builder()
1723 .container(ContainerParams.builder()
17831724 .id(response.container().get().id())
1784 .addSkill(BetaSkillParams.builder()
1785 .type(BetaSkillParams.Type.CUSTOM)
1725 .addSkill(SkillParams.builder()
1726 .type(SkillParams.Type.CUSTOM)
17861727 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
17871728 .version("latest")
17881729 .build())
17891730 .build())
17901731 .messages(messages)
1791 .addTool(BetaCodeExecutionTool20250825.builder().build())
1732 .addTool(CodeExecutionTool20250825.builder().build())
17921733 .build());
17931734 }
17941735 }
from line 1795
18541795 ]
18551796 max_retries = 10
18561797
1857 response = client.beta.messages.create(
1798 response = client.messages.create(
18581799 model: "claude-opus-5",
18591800 max_tokens: 4096,
1860 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
18611801 container: {
18621802 skills: [
18631803 {
from line 1816
18761816
18771817 messages << { role: "assistant", content: response.content }
18781818
1879 response = client.beta.messages.create(
1819 response = client.messages.create(
18801820 model: "claude-opus-5",
18811821 max_tokens: 4096,
1882 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
18831822 container: {
18841823 id: response.container.id,
18851824 skills: [
from line 1849
19101849 curl https://api.anthropic.com/v1/messages \
19111850 -H "x-api-key: $ANTHROPIC_API_KEY" \
19121851 -H "anthropic-version: 2023-06-01" \
1913 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
19141852 -H "content-type: application/json" \
19151853 -d '{
19161854 "model": "claude-opus-5",
from line 1884
19461884 ```
19471885
19481886 ```bash CLI
1949 ant beta:messages create \
1950 --beta code-execution-2025-08-25,skills-2025-10-02 <<'YAML'
1887 ant messages create <<'YAML'
19511888 model: claude-opus-5
19521889 max_tokens: 4096
19531890 container:
from line 1910
19731910 ```python Python
19741911 client = anthropic.Anthropic()
19751912
1976 response = client.beta.messages.create(
1913 response = client.messages.create(
19771914 model="claude-opus-5",
19781915 max_tokens=4096,
1979 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
19801916 container={
19811917 "skills": [
19821918 {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
from line 1934
19981934 ```typescript TypeScript
19991935 const client = new Anthropic();
20001936
2001 const response = await client.beta.messages.create({
1937 const response = await client.messages.create({
20021938 model: "claude-opus-5",
20031939 max_tokens: 4096,
2004 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
20051940 container: {
20061941 skills: [
20071942 {
from line 1978
20431978 {
20441979 Model = "claude-opus-5",
20451980 MaxTokens = 4096,
2046 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
2047 Container = new BetaContainerParams
1981 Container = new ContainerParams
20481982 {
20491983 Skills =
20501984 [
2051 new BetaSkillParams
1985 new SkillParams
20521986 {
2053 Type = BetaSkillParamsType.Anthropic,
1987 Type = SkillParamsType.Anthropic,
20541988 SkillID = "xlsx",
20551989 Version = "latest",
20561990 },
2057 new BetaSkillParams
1991 new SkillParams
20581992 {
2059 Type = BetaSkillParamsType.Anthropic,
1993 Type = SkillParamsType.Anthropic,
20601994 SkillID = "pptx",
20611995 Version = "latest",
20621996 },
2063 new BetaSkillParams
1997 new SkillParams
20641998 {
2065 Type = BetaSkillParamsType.Custom,
1999 Type = SkillParamsType.Custom,
20662000 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
20672001 Version = "latest",
20682002 },
20692003 ],
20702004 },
20712005 Messages = [new() { Role = Role.User, Content = "Analyze sales data and create a presentation" }],
2072 Tools = [new BetaCodeExecutionTool20250825()],
2006 Tools = [new CodeExecutionTool20250825()],
20732007 };
20742008
2075 var message = await client.Beta.Messages.Create(parameters);
2009 var message = await client.Messages.Create(parameters);
20762010 Console.WriteLine(message);
20772011 ```
20782012
20792013 ```go Go
20802014 client := anthropic.NewClient()
20812015
2082 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
2016 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
20832017 Model: "claude-opus-5",
20842018 MaxTokens: 4096,
2085 Betas: []anthropic.AnthropicBeta{
2086 "code-execution-2025-08-25",
2087 anthropic.AnthropicBetaSkills2025_10_02,
2088 },
2089 Container: anthropic.BetaMessageNewParamsContainerUnion{
2090 OfContainers: &anthropic.BetaContainerParams{
2091 Skills: []anthropic.BetaSkillParams{
2019 Container: anthropic.MessageCreateParamsContainerUnion{
2020 OfContainers: &anthropic.ContainerParams{
2021 Skills: []anthropic.SkillParams{
20922022 {
2093 Type: anthropic.BetaSkillParamsTypeAnthropic,
2023 Type: anthropic.SkillParamsTypeAnthropic,
20942024 SkillID: "xlsx",
20952025 Version: anthropic.String("latest"),
20962026 },
20972027 {
2098 Type: anthropic.BetaSkillParamsTypeAnthropic,
2028 Type: anthropic.SkillParamsTypeAnthropic,
20992029 SkillID: "pptx",
21002030 Version: anthropic.String("latest"),
21012031 },
21022032 {
2103 Type: anthropic.BetaSkillParamsTypeCustom,
2033 Type: anthropic.SkillParamsTypeCustom,
21042034 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
21052035 Version: anthropic.String("latest"),
21062036 },
21072037 },
21082038 },
21092039 },
2110 Messages: []anthropic.BetaMessageParam{
2111 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Analyze sales data and create a presentation")),
2040 Messages: []anthropic.MessageParam{
2041 anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze sales data and create a presentation")),
21122042 },
2113 Tools: []anthropic.BetaToolUnionParam{
2114 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
2043 Tools: []anthropic.ToolUnionParam{
2044 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
21152045 },
21162046 })
21172047 if err != nil {
from line 2051
21212051 ```
21222052
21232053 ```java Java
2124 import com.anthropic.models.beta.messages.BetaContainerParams;
2125 import com.anthropic.models.beta.messages.BetaSkillParams;
2126 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
2054 import com.anthropic.models.messages.ContainerParams;
2055 import com.anthropic.models.messages.SkillParams;
2056 import com.anthropic.models.messages.CodeExecutionTool20250825;
21272057 // ...
21282058 void main() {
21292059 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 2061
21312061 MessageCreateParams params = MessageCreateParams.builder()
21322062 .model(Model.CLAUDE_OPUS_5)
21332063 .maxTokens(4096L)
2134 .addBeta("code-execution-2025-08-25")
2135 .addBeta("skills-2025-10-02")
2136 .container(BetaContainerParams.builder()
2064 .container(ContainerParams.builder()
21372065 .skills(List.of(
2138 BetaSkillParams.builder()
2139 .type(BetaSkillParams.Type.ANTHROPIC)
2066 SkillParams.builder()
2067 .type(SkillParams.Type.ANTHROPIC)
21402068 .skillId("xlsx")
21412069 .version("latest")
21422070 .build(),
2143 BetaSkillParams.builder()
2144 .type(BetaSkillParams.Type.ANTHROPIC)
2071 SkillParams.builder()
2072 .type(SkillParams.Type.ANTHROPIC)
21452073 .skillId("pptx")
21462074 .version("latest")
21472075 .build(),
2148 BetaSkillParams.builder()
2149 .type(BetaSkillParams.Type.CUSTOM)
2076 SkillParams.builder()
2077 .type(SkillParams.Type.CUSTOM)
21502078 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
21512079 .version("latest")
21522080 .build()
21532081 ))
21542082 .build())
21552083 .addUserMessage("Analyze sales data and create a presentation")
2156 .addTool(BetaCodeExecutionTool20250825.builder().build())
2084 .addTool(CodeExecutionTool20250825.builder().build())
21572085 .build();
21582086
2159 BetaMessage response = client.beta().messages().create(params);
2087 Message response = client.messages().create(params);
21602088 System.out.println(response);
21612089 }
21622090 ```
from line 2129
22012129 ```ruby Ruby
22022130 client = Anthropic::Client.new
22032131
2204 message = client.beta.messages.create(
2132 message = client.messages.create(
22052133 model: "claude-opus-5",
22062134 max_tokens: 4096,
2207 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
22082135 container: {
22092136 skills: [
22102137 {
from line 2185
22582185 curl -X POST "https://api.anthropic.com/v1/skills" \
22592186 -H "x-api-key: $ANTHROPIC_API_KEY" \
22602187 -H "anthropic-version: 2023-06-01" \
2261 -H "anthropic-beta: skills-2025-10-02" \
22622188 -F "files[]=@financial_skill/SKILL.md;filename=financial_skill/SKILL.md" \
22632189 -F "files[]=@financial_skill/analyze.py;filename=financial_skill/analyze.py"
22642190 ```
22652191
2266 ```bash CLI
2267 ant beta:skills create \
2268 --file example_skill.zip \
2269 --beta skills-2025-10-02
2270
2271 # Per-file upload requires path-qualified filenames, which the CLI
2272 # can't currently set. Upload a zip archive instead.
2273 ```
2192 <MultiFileExample language="cli" label="CLI">
2193 ```bash CLI
2194 zip -r financial_skill.zip financial_skill/
2195 ant skills create --file financial_skill.zip
2196 ```
2197
2198 <File filename="financial_skill/SKILL.md">
2199 ```markdown
2200 ---
2201 name: financial-skill
2202 description: Docs example skill.
2203 ---
2204 ```
2205 </File>
2206
2207 <File filename="financial_skill/analyze.py">
2208 ```python
2209 print("financial analysis helper")
2210 ```
2211 </File>
2212 </MultiFileExample>
22742213
22752214 ```python Python
22762215 from anthropic.lib import files_from_dir
from line 2217
22782217 client = anthropic.Anthropic()
22792218
22802219 # Option 1: Using a zip file
2281 skill = client.beta.skills.create(
2220 skill = client.skills.create(
22822221 files=[open("example_skill.zip", "rb")],
22832222 )
22842223
22852224 # Option 2: Using file tuples (filename, file_content, mime_type)
2286 skill = client.beta.skills.create(
2225 skill = client.skills.create(
22872226 files=[
22882227 (
22892228 "financial_skill/SKILL.md",
from line 2238
22992238 )
23002239
23012240 # Option 3: Using the files_from_dir helper (Python only)
2302 skill = client.beta.skills.create(
2241 skill = client.skills.create(
23032242 files=files_from_dir("financial_skill"),
23042243 )
23052244
23062245 print(f"Created skill: {skill.id}")
2307 print(f"Latest version: {skill.latest_version}")
2246 print(f"Latest version: {skill.latest_version_id}")
23082247 ```
23092248
23102249 ```typescript TypeScript
from line 2254
23152254 const client = new Anthropic();
23162255
23172256 // Option 1: Using a zip file
2318 const skillFromZip = await client.beta.skills.create({
2257 const skillFromZip = await client.skills.create({
23192258 files: [await toFile(fs.createReadStream("example_skill.zip"), "example_skill.zip")]
23202259 });
23212260
23222261 // Option 2: Using individual file objects
2323 const skill = await client.beta.skills.create({
2262 const skill = await client.skills.create({
23242263 files: [
23252264 await toFile(fs.createReadStream("financial_skill/SKILL.md"), "financial_skill/SKILL.md", {
23262265 type: "text/markdown"
from line 2273
23342273 });
23352274
23362275 console.log(`Created skill: ${skill.id}`);
2337 console.log(`Latest version: ${skill.latest_version}`);
2276 console.log(`Latest version: ${skill.latest_version_id}`);
23382277 ```
23392278
23402279 ```csharp C#
from line 2288
23492288 Files = [File.OpenRead("example_skill.zip")],
23502289 };
23512290
2352 var skill = await client.Beta.Skills.Create(parameters);
2291 var skill = await client.Skills.Create(parameters);
23532292
23542293 // Option 2: Using individual files (path-qualified filenames preserve the Skill's directory layout)
23552294 var parameters2 = new SkillCreateParams
from line 2308
23692308 ],
23702309 };
23712310
2372 var skill2 = await client.Beta.Skills.Create(parameters2);
2311 var skill2 = await client.Skills.Create(parameters2);
23732312
23742313 Console.WriteLine($"Created skill: {skill.ID}");
2375 Console.WriteLine($"Latest version: {skill.LatestVersion}");
2314 Console.WriteLine($"Latest version: {skill.LatestVersionID}");
23762315 Console.WriteLine($"Created skill 2: {skill2.ID}");
23772316 ```
23782317
from line 2325
23862325 }
23872326 defer zipFile.Close()
23882327
2389 skill, err := client.Beta.Skills.New(context.TODO(), anthropic.BetaSkillNewParams{
2328 skill, err := client.Skills.New(context.TODO(), anthropic.SkillNewParams{
23902329 Files: []io.Reader{zipFile},
23912330 })
23922331 if err != nil {
from line 2345
24062345 }
24072346 defer analyzePy.Close()
24082347
2409 skill2, err := client.Beta.Skills.New(context.TODO(), anthropic.BetaSkillNewParams{
2348 skill2, err := client.Skills.New(context.TODO(), anthropic.SkillNewParams{
24102349 Files: []io.Reader{
24112350 anthropic.File(skillMd, "financial_skill/SKILL.md", "text/markdown"),
24122351 anthropic.File(analyzePy, "financial_skill/analyze.py", "text/x-python"),
from line 2356
24172356 }
24182357
24192358 fmt.Printf("Created skill: %s\n", skill.ID)
2420 fmt.Printf("Latest version: %s\n", skill.LatestVersion)
2359 fmt.Printf("Latest version: %s\n", skill.LatestVersionID)
24212360 fmt.Printf("Created skill 2: %s\n", skill2.ID)
24222361 ```
24232362
24242363 ```java Java
24252364 import com.anthropic.core.MultipartField;
2426 import com.anthropic.models.beta.skills.SkillCreateParams;
2427 import com.anthropic.models.beta.skills.SkillCreateResponse;
2365 import com.anthropic.models.skills.SkillCreateParams;
2366 import com.anthropic.models.skills.Skill;
24282367 // ...
24292368 void main() throws Exception {
24302369 // ...
from line 2378
24392378 .build())
24402379 .build();
24412380
2442 SkillCreateResponse skill = client.beta().skills().create(params);
2381 Skill skill = client.skills().create(params);
24432382
24442383 // Option 2: Using individual files (path-qualified filenames preserve the Skill's directory layout)
24452384 SkillCreateParams params2 = SkillCreateParams.builder()
from line 2394
24552394 .build())
24562395 .build();
24572396
2458 SkillCreateResponse skill2 = client.beta().skills().create(params2);
2397 Skill skill2 = client.skills().create(params2);
24592398
24602399 System.out.println("Created skill: " + skill.id());
2461 System.out.println("Latest version: " + skill.latestVersion().orElseThrow());
2400 System.out.println("Latest version: " + skill.latestVersionId());
24622401 System.out.println("Created skill 2: " + skill2.id());
24632402 }
24642403 ```
from line 2431
24922431 client = Anthropic::Client.new
24932432
24942433 # Option 1: Using a zip file
2495 skill = client.beta.skills.create(
2434 skill = client.skills.create(
24962435 files: [
24972436 File.open("example_skill.zip", "rb")
24982437 ]
24992438 )
25002439
25012440 # Option 2: Using individual files
2502 skill = client.beta.skills.create(
2441 skill = client.skills.create(
25032442 files: [
25042443 Anthropic::FilePart.new(
25052444 Pathname("financial_skill/SKILL.md"),
from line 2454
25152454 )
25162455
25172456 puts "Created skill: #{skill.id}"
2518 puts "Latest version: #{skill.latest_version}"
2457 puts "Latest version: #{skill.latest_version_id}"
25192458 ```
25202459</CodeGroup>
25212460
from line 2471
25322471 * `name`: Maximum 64 characters, lowercase letters/numbers/hyphens only, no XML tags, no reserved words ("anthropic", "claude")
25332472 * `description`: Maximum 1024 characters, non-empty, no XML tags
25342473
2535For complete request/response schemas, see the [Create Skill API reference](https://platform.claude.com/docs/en/api/beta/skills/create).
2474For complete request/response schemas, see the [Create Skill API reference](https://platform.claude.com/docs/en/api/skills/create).
25362475
25372476### Listing Skills
25382477
from line 2482
25432482 # List all Skills
25442483 curl "https://api.anthropic.com/v1/skills" \
25452484 -H "x-api-key: $ANTHROPIC_API_KEY" \
2546 -H "anthropic-version: 2023-06-01" \
2547 -H "anthropic-beta: skills-2025-10-02"
2485 -H "anthropic-version: 2023-06-01"
25482486
25492487 # List only custom Skills
25502488 curl "https://api.anthropic.com/v1/skills?source=custom" \
25512489 -H "x-api-key: $ANTHROPIC_API_KEY" \
2552 -H "anthropic-version: 2023-06-01" \
2553 -H "anthropic-beta: skills-2025-10-02"
2490 -H "anthropic-version: 2023-06-01"
25542491 ```
25552492
25562493 ```bash CLI
25572494 # List all Skills
2558 ant beta:skills list
2495 ant skills list
25592496
25602497 # List only custom Skills
2561 ant beta:skills list --source custom
2498 ant skills list --source custom
25622499 ```
25632500
25642501 ```python Python
25652502 client = anthropic.Anthropic()
25662503
25672504 # List all Skills
2568 for skill in client.beta.skills.list():
2569 print(f"{skill.id}: {skill.display_title} (source: {skill.source})")
2505 for skill in client.skills.list():
2506 print(f"{skill.id}: {skill.display_name} (source: {skill.source.type})")
25702507
25712508 # List only custom Skills
2572 custom_skills = client.beta.skills.list(source="custom")
2509 custom_skills = client.skills.list(source="custom")
25732510 ```
25742511
25752512 ```typescript TypeScript
25762513 const client = new Anthropic();
25772514
25782515 // List all Skills
2579 for await (const skill of client.beta.skills.list()) {
2580 console.log(`${skill.id}: ${skill.display_title} (source: ${skill.source})`);
2516 for await (const skill of client.skills.list()) {
2517 console.log(`${skill.id}: ${skill.display_name} (source: ${skill.source.type})`);
25812518 }
25822519
25832520 // List only custom Skills
2584 const customSkills = await client.beta.skills.list({
2521 const customSkills = await client.skills.list({
25852522 source: "custom"
25862523 });
25872524 ```
from line 2527
25902527 AnthropicClient client = new();
25912528
25922529 // List all Skills
2593 await foreach (var skill in (await client.Beta.Skills.List()).Paginate())
2530 await foreach (var skill in (await client.Skills.List()).Paginate())
25942531 {
2595 Console.WriteLine($"{skill.ID}: {skill.DisplayTitle} (source: {skill.Source})");
2532 Console.WriteLine($"{skill.ID}: {skill.DisplayName} (source: {skill.Source.Type})");
25962533 }
25972534
25982535 // List only custom Skills
2599 var customSkills = await client.Beta.Skills.List(new SkillListParams { Source = "custom" });
2536 var customSkills = await client.Skills.List(new SkillListParams { Source = "custom" });
26002537 ```
26012538
26022539 ```go Go
26032540 client := anthropic.NewClient()
26042541
26052542 // List all Skills
2606 skills := client.Beta.Skills.ListAutoPaging(context.TODO(), anthropic.BetaSkillListParams{})
2543 skills := client.Skills.ListAutoPaging(context.TODO(), anthropic.SkillListParams{})
26072544
26082545 for skills.Next() {
26092546 skill := skills.Current()
2610 fmt.Printf("%s: %s (source: %s)\n", skill.ID, skill.DisplayTitle, skill.Source)
2547 fmt.Printf("%s: %s (source: %s)\n", skill.ID, skill.DisplayName, skill.Source.Type)
26112548 }
26122549 if skills.Err() != nil {
26132550 log.Fatal(skills.Err())
26142551 }
26152552
26162553 // List only custom Skills
2617 customSkills := client.Beta.Skills.ListAutoPaging(context.TODO(), anthropic.BetaSkillListParams{
2554 customSkills := client.Skills.ListAutoPaging(context.TODO(), anthropic.SkillListParams{
26182555 Source: anthropic.String("custom"),
26192556 })
26202557
26212558 for customSkills.Next() {
26222559 skill := customSkills.Current()
2623 fmt.Printf("%s: %s (source: %s)\n", skill.ID, skill.DisplayTitle, skill.Source)
2560 fmt.Printf("%s: %s (source: %s)\n", skill.ID, skill.DisplayName, skill.Source.Type)
26242561 }
26252562 if customSkills.Err() != nil {
26262563 log.Fatal(customSkills.Err())
from line 2565
26282565 ```
26292566
26302567 ```java Java
2631 import com.anthropic.models.beta.skills.SkillListParams;
2632 import com.anthropic.models.beta.skills.SkillListPage;
2633 import com.anthropic.models.beta.skills.SkillListResponse;
2568 import com.anthropic.models.skills.SkillListParams;
2569 import com.anthropic.models.skills.SkillListPage;
2570 import com.anthropic.models.skills.Skill;
26342571 // ...
26352572 void main() {
26362573 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
26372574
26382575 // List Skills (first page)
2639 SkillListPage skills = client.beta().skills().list();
2640
2641 for (SkillListResponse skill : skills.data()) {
2642 System.out.println(skill.id() + ": " + skill.displayTitle().orElseThrow() + " (source: " + skill.source() + ")");
2576 SkillListPage skills = client.skills().list();
2577
2578 for (Skill skill : skills.data()) {
2579 System.out.println(skill.id() + ": " + skill.displayName() + " (source: " + skill.source().type() + ")");
26432580 }
26442581
26452582 // List only custom Skills
from line 2584
26472584 .source("custom")
26482585 .build();
26492586
2650 SkillListPage customSkills = client.beta().skills().list(customParams);
2587 SkillListPage customSkills = client.skills().list(customParams);
26512588 }
26522589 ```
26532590
from line 2608
26712608 client = Anthropic::Client.new
26722609
26732610 # List all Skills
2674 client.beta.skills.list.auto_paging_each do |skill|
2675 puts "#{skill.id}: #{skill.display_title} (source: #{skill.source})"
2611 client.skills.list.auto_paging_each do |skill|
2612 puts "#{skill.id}: #{skill.display_name} (source: #{skill.source.type})"
26762613 end
26772614
26782615 # List only custom Skills
2679 custom_skills = client.beta.skills.list(
2616 custom_skills = client.skills.list(
26802617 source: "custom"
26812618 )
26822619 ```
26832620</CodeGroup>
26842621
2685See the [List Skills API reference](https://platform.claude.com/docs/en/api/beta/skills/list) for pagination and filtering options.
2622See the [List Skills API reference](https://platform.claude.com/docs/en/api/skills/list) for pagination and filtering options.
26862623
26872624### Retrieving a Skill
26882625
from line 2629
26922629 ```bash cURL
26932630 curl "https://api.anthropic.com/v1/skills/skill_01AbCdEfGhIjKlMnOpQrStUv" \
26942631 -H "x-api-key: $ANTHROPIC_API_KEY" \
2695 -H "anthropic-version: 2023-06-01" \
2696 -H "anthropic-beta: skills-2025-10-02"
2632 -H "anthropic-version: 2023-06-01"
26972633 ```
26982634
26992635 ```bash CLI
2700 ant beta:skills retrieve \
2636 ant skills retrieve \
27012637 --skill-id skill_01AbCdEfGhIjKlMnOpQrStUv
27022638 ```
27032639
27042640 ```python Python
27052641 client = anthropic.Anthropic()
27062642
2707 skill = client.beta.skills.retrieve(skill_id="skill_01AbCdEfGhIjKlMnOpQrStUv")
2708
2709 print(f"Skill: {skill.display_title}")
2710 print(f"Latest version: {skill.latest_version}")
2643 skill = client.skills.retrieve(skill_id="skill_01AbCdEfGhIjKlMnOpQrStUv")
2644
2645 print(f"Skill: {skill.display_name}")
2646 print(f"Latest version: {skill.latest_version_id}")
27112647 print(f"Created: {skill.created_at}")
27122648 ```
27132649
27142650 ```typescript TypeScript
27152651 const client = new Anthropic();
27162652
2717 const skill = await client.beta.skills.retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2718
2719 console.log(`Skill: ${skill.display_title}`);
2720 console.log(`Latest version: ${skill.latest_version}`);
2653 const skill = await client.skills.retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2654
2655 console.log(`Skill: ${skill.display_name}`);
2656 console.log(`Latest version: ${skill.latest_version_id}`);
27212657 console.log(`Created: ${skill.created_at}`);
27222658 ```
27232659
27242660 ```csharp C#
27252661 AnthropicClient client = new();
27262662
2727 var skill = await client.Beta.Skills.Retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2728
2729 Console.WriteLine($"Skill: {skill.DisplayTitle}");
2730 Console.WriteLine($"Latest version: {skill.LatestVersion}");
2663 var skill = await client.Skills.Retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2664
2665 Console.WriteLine($"Skill: {skill.DisplayName}");
2666 Console.WriteLine($"Latest version: {skill.LatestVersionID}");
27312667 Console.WriteLine($"Created: {skill.CreatedAt}");
27322668 ```
27332669
27342670 ```go Go
27352671 client := anthropic.NewClient()
27362672
2737 skill, err := client.Beta.Skills.Get(
2673 skill, err := client.Skills.Get(
27382674 context.TODO(),
27392675 "skill_01AbCdEfGhIjKlMnOpQrStUv",
2740 anthropic.BetaSkillGetParams{},
27412676 )
27422677 if err != nil {
27432678 log.Fatal(err)
27442679 }
27452680
2746 fmt.Printf("Skill: %s\n", skill.DisplayTitle)
2747 fmt.Printf("Latest version: %s\n", skill.LatestVersion)
2681 fmt.Printf("Skill: %s\n", skill.DisplayName)
2682 fmt.Printf("Latest version: %s\n", skill.LatestVersionID)
27482683 fmt.Printf("Created: %s\n", skill.CreatedAt)
27492684 ```
27502685
27512686 ```java Java
2752 import com.anthropic.models.beta.skills.SkillRetrieveResponse;
2687 import com.anthropic.models.skills.Skill;
27532688 // ...
27542689 void main() {
27552690 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
27562691
2757 SkillRetrieveResponse skill = client.beta().skills().retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2758
2759 System.out.println("Skill: " + skill.displayTitle().orElseThrow());
2760 System.out.println("Latest version: " + skill.latestVersion().orElseThrow());
2692 Skill skill = client.skills().retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv");
2693
2694 System.out.println("Skill: " + skill.displayName());
2695 System.out.println("Latest version: " + skill.latestVersionId());
27612696 System.out.println("Created: " + skill.createdAt());
27622697 }
27632698 ```
from line 2712
27772712 ```ruby Ruby
27782713 client = Anthropic::Client.new
27792714
2780 skill = client.beta.skills.retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv")
2781
2782 puts "Skill: #{skill.display_title}"
2783 puts "Latest version: #{skill.latest_version}"
2715 skill = client.skills.retrieve("skill_01AbCdEfGhIjKlMnOpQrStUv")
2716
2717 puts "Skill: #{skill.display_name}"
2718 puts "Latest version: #{skill.latest_version_id}"
27842719 puts "Created: #{skill.created_at}"
27852720 ```
27862721</CodeGroup>
27872722
27882723### Deleting a Skill
27892724
2790Deleting a Skill also removes all of its versions. The cascade is GA-only behavior, so unlike the other examples in this guide, these call the GA surface directly rather than the `beta` namespace.
2725Deleting a Skill also removes all of its versions.
27912726
27922727<CodeGroup defaultLanguage="CLI">
27932728 ```bash cURL
from line 2777
28422777 ```php PHP
28432778 $client = new Client();
28442779
2845 $client->skills->delete(
2846 skillID: 'skill_01AbCdEfGhIjKlMnOpQrStUv',
2847 );
2780 // The PHP SDK still uses the beta Skills namespace, where a Skill's versions
2781 // must be deleted before the Skill itself.
2782 $skillId = 'skill_01AbCdEfGhIjKlMnOpQrStUv';
2783 foreach ($client->beta->skills->versions->list($skillId)->pagingEachItem() as $version) {
2784 $client->beta->skills->versions->delete($version->version, skillID: $skillId);
2785 }
2786 $client->beta->skills->delete($skillId);
28482787 ```
28492788
28502789 ```ruby Ruby
from line 2817
28782817 NEW_VERSION=$(curl -X POST "https://api.anthropic.com/v1/skills/skill_01AbCdEfGhIjKlMnOpQrStUv/versions" \
28792818 -H "x-api-key: $ANTHROPIC_API_KEY" \
28802819 -H "anthropic-version: 2023-06-01" \
2881 -H "anthropic-beta: skills-2025-10-02" \
28822820 -F "files[]=@financial_skill/SKILL.md;filename=financial_skill/SKILL.md" \
28832821 -F "files[]=@financial_skill/analyze.py;filename=financial_skill/analyze.py")
28842822
2885 VERSION_NUMBER=$(echo "$NEW_VERSION" | jq -r '.version')
2823 VERSION_ID=$(echo "$NEW_VERSION" | jq -r '.id')
28862824
28872825 # Use specific version
28882826 curl https://api.anthropic.com/v1/messages \
28892827 -H "x-api-key: $ANTHROPIC_API_KEY" \
28902828 -H "anthropic-version: 2023-06-01" \
2891 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
28922829 -H "content-type: application/json" \
28932830 -d "{
28942831 \"model\": \"claude-opus-5\",
from line 2834
28972834 \"skills\": [{
28982835 \"type\": \"custom\",
28992836 \"skill_id\": \"skill_01AbCdEfGhIjKlMnOpQrStUv\",
2900 \"version\": \"$VERSION_NUMBER\"
2837 \"version\": \"$VERSION_ID\"
29012838 }]
29022839 },
29032840 \"messages\": [{\"role\": \"user\", \"content\": \"Use updated Skill\"}],
from line 2845
29082845 curl https://api.anthropic.com/v1/messages \
29092846 -H "x-api-key: $ANTHROPIC_API_KEY" \
29102847 -H "anthropic-version: 2023-06-01" \
2911 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
29122848 -H "content-type: application/json" \
29132849 -d '{
29142850 "model": "claude-opus-5",
from line 2863
29272863
29282864 ```bash CLI
29292865 # Create a new version
2930 VERSION_NUMBER=$(ant beta:skills:versions create \
2866 VERSION_ID=$(ant skills:versions create \
29312867 --skill-id skill_01AbCdEfGhIjKlMnOpQrStUv \
29322868 --file financial_skill.zip \
2933 --transform version \
2869 --transform id \
29342870 --raw-output)
29352871
29362872 # Use specific version
2937 ant beta:messages create \
2938 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
2873 ant messages create <<YAML
29392874 model: claude-opus-5
29402875 max_tokens: 4096
29412876 container:
29422877 skills:
29432878 - type: custom
29442879 skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
2945 version: "$VERSION_NUMBER"
2880 version: "$VERSION_ID"
29462881 messages:
29472882 - role: user
29482883 content: Use updated Skill
from line 2887
29522887 YAML
29532888
29542889 # Use latest version
2955 ant beta:messages create \
2956 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
2890 ant messages create <<YAML
29572891 model: claude-opus-5
29582892 max_tokens: 4096
29592893 container:
from line 2911
29772911
29782912 # Create a new version
29792913
2980 new_version = client.beta.skills.versions.create(
2914 new_version = client.skills.versions.create(
29812915 skill_id="skill_01AbCdEfGhIjKlMnOpQrStUv",
29822916 files=files_from_dir("financial_skill"),
29832917 )
29842918
29852919 # Use specific version
2986 response = client.beta.messages.create(
2920 response = client.messages.create(
29872921 model="claude-opus-5",
29882922 max_tokens=4096,
2989 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
29902923 container={
29912924 "skills": [
29922925 {
29932926 "type": "custom",
29942927 "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
2995 "version": new_version.version,
2928 "version": new_version.id,
29962929 }
29972930 ]
29982931 },
from line 2934
30012934 )
30022935
30032936 # Use latest version
3004 response = client.beta.messages.create(
2937 response = client.messages.create(
30052938 model="claude-opus-5",
30062939 max_tokens=4096,
3007 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
30082940 container={
30092941 "skills": [
30102942 {
from line 2957
30252957 const client = new Anthropic();
30262958
30272959 // Create a new version from a zip of the complete financial_skill/ bundle
3028 const newVersion = await client.beta.skills.versions.create("skill_01AbCdEfGhIjKlMnOpQrStUv", {
2960 const newVersion = await client.skills.versions.create("skill_01AbCdEfGhIjKlMnOpQrStUv", {
30292961 files: [fs.createReadStream("financial_skill.zip")]
30302962 });
30312963
30322964 // Use specific version
3033 const specificVersionResponse = await client.beta.messages.create({
2965 const specificVersionResponse = await client.messages.create({
30342966 model: "claude-opus-5",
30352967 max_tokens: 4096,
3036 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
30372968 container: {
30382969 skills: [
30392970 {
30402971 type: "custom",
30412972 skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3042 version: newVersion.version
2973 version: newVersion.id
30432974 }
30442975 ]
30452976 },
from line 2979
30482979 });
30492980
30502981 // Use latest version
3051 const latestVersionResponse = await client.beta.messages.create({
2982 const latestVersionResponse = await client.messages.create({
30522983 model: "claude-opus-5",
30532984 max_tokens: 4096,
3054 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
30552985 container: {
30562986 skills: [
30572987 {
from line 2998
30682998
30692999 ```csharp C#
30703000 using Anthropic.Core;
3071 using Anthropic.Models.Beta.Skills.Versions;
3001 using Anthropic.Models.Skills.Versions;
30723002 // ...
30733003 AnthropicClient client = new();
30743004
from line 3020
30903020 ],
30913021 };
30923022
3093 var newVersion = await client.Beta.Skills.Versions.Create("skill_01AbCdEfGhIjKlMnOpQrStUv", versionParams);
3023 var newVersion = await client.Skills.Versions.Create("skill_01AbCdEfGhIjKlMnOpQrStUv", versionParams);
30943024
30953025 // Use specific version
30963026 var specificVersionParams = new MessageCreateParams
30973027 {
30983028 Model = "claude-opus-5",
30993029 MaxTokens = 4096,
3100 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
3101 Container = new BetaContainerParams
3030 Container = new ContainerParams
31023031 {
31033032 Skills =
31043033 [
3105 new BetaSkillParams
3034 new SkillParams
31063035 {
3107 Type = BetaSkillParamsType.Custom,
3036 Type = SkillParamsType.Custom,
31083037 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
3109 Version = newVersion.Version,
3038 Version = newVersion.ID,
31103039 },
31113040 ],
31123041 },
31133042 Messages = [new() { Role = Role.User, Content = "Use updated Skill" }],
3114 Tools = [new BetaCodeExecutionTool20250825()],
3043 Tools = [new CodeExecutionTool20250825()],
31153044 };
31163045
3117 var response = await client.Beta.Messages.Create(specificVersionParams);
3046 var response = await client.Messages.Create(specificVersionParams);
31183047 Console.WriteLine(response);
31193048
31203049 // Use latest version
from line 3051
31223051 {
31233052 Model = "claude-opus-5",
31243053 MaxTokens = 4096,
3125 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
3126 Container = new BetaContainerParams
3054 Container = new ContainerParams
31273055 {
31283056 Skills =
31293057 [
3130 new BetaSkillParams
3058 new SkillParams
31313059 {
3132 Type = BetaSkillParamsType.Custom,
3060 Type = SkillParamsType.Custom,
31333061 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
31343062 Version = "latest",
31353063 },
31363064 ],
31373065 },
31383066 Messages = [new() { Role = Role.User, Content = "Use latest Skill version" }],
3139 Tools = [new BetaCodeExecutionTool20250825()],
3067 Tools = [new CodeExecutionTool20250825()],
31403068 };
31413069
3142 var latestResponse = await client.Beta.Messages.Create(latestVersionParams);
3070 var latestResponse = await client.Messages.Create(latestVersionParams);
31433071 Console.WriteLine(latestResponse);
31443072 ```
31453073
from line 3086
31583086 }
31593087 defer analyzePy.Close()
31603088
3161 newVersion, err := client.Beta.Skills.Versions.New(
3089 newVersion, err := client.Skills.Versions.New(
31623090 context.TODO(),
31633091 "skill_01AbCdEfGhIjKlMnOpQrStUv",
3164 anthropic.BetaSkillVersionNewParams{
3092 anthropic.SkillVersionNewParams{
31653093 Files: []io.Reader{
31663094 anthropic.File(skillMd, "financial_skill/SKILL.md", "text/markdown"),
31673095 anthropic.File(analyzePy, "financial_skill/analyze.py", "text/x-python"),
from line 3101
31733101 }
31743102
31753103 // Use specific version
3176 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
3104 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
31773105 Model: "claude-opus-5",
31783106 MaxTokens: 4096,
3179 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
3180 Container: anthropic.BetaMessageNewParamsContainerUnion{
3181 OfContainers: &anthropic.BetaContainerParams{
3182 Skills: []anthropic.BetaSkillParams{
3107 Container: anthropic.MessageCreateParamsContainerUnion{
3108 OfContainers: &anthropic.ContainerParams{
3109 Skills: []anthropic.SkillParams{
31833110 {
3184 Type: anthropic.BetaSkillParamsTypeCustom,
3111 Type: anthropic.SkillParamsTypeCustom,
31853112 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3186 Version: anthropic.String(newVersion.Version),
3113 Version: anthropic.String(newVersion.ID),
31873114 },
31883115 },
31893116 },
31903117 },
3191 Messages: []anthropic.BetaMessageParam{
3192 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Use updated Skill")),
3118 Messages: []anthropic.MessageParam{
3119 anthropic.NewUserMessage(anthropic.NewTextBlock("Use updated Skill")),
31933120 },
3194 Tools: []anthropic.BetaToolUnionParam{
3195 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
3121 Tools: []anthropic.ToolUnionParam{
3122 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
31963123 },
31973124 })
31983125 if err != nil {
from line 3128
32013128 fmt.Println(response)
32023129
32033130 // Use latest version
3204 latestResponse, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
3131 latestResponse, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
32053132 Model: "claude-opus-5",
32063133 MaxTokens: 4096,
3207 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
3208 Container: anthropic.BetaMessageNewParamsContainerUnion{
3209 OfContainers: &anthropic.BetaContainerParams{
3210 Skills: []anthropic.BetaSkillParams{
3134 Container: anthropic.MessageCreateParamsContainerUnion{
3135 OfContainers: &anthropic.ContainerParams{
3136 Skills: []anthropic.SkillParams{
32113137 {
3212 Type: anthropic.BetaSkillParamsTypeCustom,
3138 Type: anthropic.SkillParamsTypeCustom,
32133139 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
32143140 Version: anthropic.String("latest"),
32153141 },
32163142 },
32173143 },
32183144 },
3219 Messages: []anthropic.BetaMessageParam{
3220 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Use latest Skill version")),
3145 Messages: []anthropic.MessageParam{
3146 anthropic.NewUserMessage(anthropic.NewTextBlock("Use latest Skill version")),
32213147 },
3222 Tools: []anthropic.BetaToolUnionParam{
3223 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
3148 Tools: []anthropic.ToolUnionParam{
3149 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
32243150 },
32253151 })
32263152 if err != nil {
from line 3156
32303156 ```
32313157
32323158 ```java Java
3233 import com.anthropic.models.beta.messages.MessageCreateParams;
3234 import com.anthropic.models.beta.messages.BetaMessage;
3159 import com.anthropic.models.messages.MessageCreateParams;
3160 import com.anthropic.models.messages.Message;
32353161 import com.anthropic.models.messages.Model;
32363162 import com.anthropic.core.MultipartField;
3237 import com.anthropic.models.beta.messages.BetaContainerParams;
3238 import com.anthropic.models.beta.messages.BetaSkillParams;
3239 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
3240 import com.anthropic.models.beta.skills.versions.VersionCreateParams;
3241 import com.anthropic.models.beta.skills.versions.VersionCreateResponse;
3163 import com.anthropic.models.messages.ContainerParams;
3164 import com.anthropic.models.messages.SkillParams;
3165 import com.anthropic.models.messages.CodeExecutionTool20250825;
3166 import com.anthropic.models.skills.versions.VersionCreateParams;
3167 import com.anthropic.models.skills.versions.SkillVersion;
32423168 import java.io.InputStream;
32433169 import java.nio.file.Files;
32443170 import java.nio.file.Path;
from line 3180
32543180 .build())
32553181 .build();
32563182
3257 VersionCreateResponse newVersion = client.beta().skills().versions()
3183 SkillVersion newVersion = client.skills().versions()
32583184 .create("skill_01AbCdEfGhIjKlMnOpQrStUv", versionParams);
32593185
32603186 // Use specific version
32613187 MessageCreateParams specificVersionParams = MessageCreateParams.builder()
32623188 .model(Model.CLAUDE_OPUS_5)
32633189 .maxTokens(4096L)
3264 .addBeta("code-execution-2025-08-25")
3265 .addBeta("skills-2025-10-02")
3266 .container(BetaContainerParams.builder()
3267 .addSkill(BetaSkillParams.builder()
3268 .type(BetaSkillParams.Type.CUSTOM)
3190 .container(ContainerParams.builder()
3191 .addSkill(SkillParams.builder()
3192 .type(SkillParams.Type.CUSTOM)
32693193 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
3270 .version(newVersion.version())
3194 .version(newVersion.id())
32713195 .build())
32723196 .build())
32733197 .addUserMessage("Use updated Skill")
3274 .addTool(BetaCodeExecutionTool20250825.builder().build())
3198 .addTool(CodeExecutionTool20250825.builder().build())
32753199 .build();
32763200
3277 BetaMessage response = client.beta().messages().create(specificVersionParams);
3201 Message response = client.messages().create(specificVersionParams);
32783202 System.out.println(response);
32793203
32803204 // Use latest version
32813205 MessageCreateParams latestVersionParams = MessageCreateParams.builder()
32823206 .model(Model.CLAUDE_OPUS_5)
32833207 .maxTokens(4096L)
3284 .addBeta("code-execution-2025-08-25")
3285 .addBeta("skills-2025-10-02")
3286 .container(BetaContainerParams.builder()
3287 .addSkill(BetaSkillParams.builder()
3288 .type(BetaSkillParams.Type.CUSTOM)
3208 .container(ContainerParams.builder()
3209 .addSkill(SkillParams.builder()
3210 .type(SkillParams.Type.CUSTOM)
32893211 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
32903212 .version("latest")
32913213 .build())
32923214 .build())
32933215 .addUserMessage("Use latest Skill version")
3294 .addTool(BetaCodeExecutionTool20250825.builder().build())
3216 .addTool(CodeExecutionTool20250825.builder().build())
32953217 .build();
32963218
3297 BetaMessage latestResponse = client.beta().messages().create(latestVersionParams);
3219 Message latestResponse = client.messages().create(latestVersionParams);
32983220 System.out.println(latestResponse);
32993221 ```
33003222
from line 3274
33523274 client = Anthropic::Client.new
33533275
33543276 # Create a new version
3355 new_version = client.beta.skills.versions.create(
3277 new_version = client.skills.versions.create(
33563278 "skill_01AbCdEfGhIjKlMnOpQrStUv",
33573279 files: [
33583280 Anthropic::FilePart.new(
from line 3291
33693291 )
33703292
33713293 # Use specific version
3372 response = client.beta.messages.create(
3294 response = client.messages.create(
33733295 model: "claude-opus-5",
33743296 max_tokens: 4096,
3375 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
33763297 container: {
33773298 skills: [{
33783299 type: "custom",
33793300 skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3380 version: new_version.version
3301 version: new_version.id
33813302 }]
33823303 },
33833304 messages: [{ role: "user", content: "Use updated Skill" }],
from line 3307
33863307 puts response
33873308
33883309 # Use latest version
3389 latest_response = client.beta.messages.create(
3310 latest_response = client.messages.create(
33903311 model: "claude-opus-5",
33913312 max_tokens: 4096,
3392 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
33933313 container: {
33943314 skills: [{
33953315 type: "custom",
from line 3324
34043324 ```
34053325</CodeGroup>
34063326
3407See the [Create Skill Version API reference](https://platform.claude.com/docs/en/api/beta/skills/versions/create) for complete details.
3327See the [Create Skill Version API reference](https://platform.claude.com/docs/en/api/skills/versions/create) for complete details.
34083328
34093329***
34103330
from line 3355
34353355 DCF_SKILL=$(curl -X POST "https://api.anthropic.com/v1/skills" \
34363356 -H "x-api-key: $ANTHROPIC_API_KEY" \
34373357 -H "anthropic-version: 2023-06-01" \
3438 -H "anthropic-beta: skills-2025-10-02" \
34393358 -F "files[]=@dcf_skill/SKILL.md;filename=dcf_skill/SKILL.md")
34403359
34413360 DCF_SKILL_ID=$(echo "$DCF_SKILL" | jq -r '.id')
from line 3363
34443363 curl https://api.anthropic.com/v1/messages \
34453364 -H "x-api-key: $ANTHROPIC_API_KEY" \
34463365 -H "anthropic-version: 2023-06-01" \
3447 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
34483366 -H "content-type: application/json" \
34493367 -d "{
34503368 \"model\": \"claude-opus-5\",
from line 3394
34763394
34773395 ```bash CLI
34783396 # Create custom DCF analysis Skill
3479 DCF_SKILL_ID=$(ant beta:skills create \
3397 DCF_SKILL_ID=$(ant skills create \
34803398 --file dcf_skill.zip \
34813399 --transform id \
34823400 --raw-output)
34833401
34843402 # Use with Excel to create financial model
3485 ant beta:messages create \
3486 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
3403 ant messages create <<YAML
34873404 model: claude-opus-5
34883405 max_tokens: 4096
34893406 container:
from line 3427
35103427
35113428 # Create custom DCF analysis Skill
35123429
3513 dcf_skill = client.beta.skills.create(
3430 dcf_skill = client.skills.create(
35143431 files=files_from_dir("/path/to/dcf_skill"),
35153432 )
35163433
35173434 # Use with Excel to create financial model
3518 response = client.beta.messages.create(
3435 response = client.messages.create(
35193436 model="claude-opus-5",
35203437 max_tokens=4096,
3521 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
35223438 container={
35233439 "skills": [
35243440 {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
from line 3459
35433459 const client = new Anthropic();
35443460
35453461 // Create custom DCF analysis Skill
3546 const dcfSkill = await client.beta.skills.create({
3462 const dcfSkill = await client.skills.create({
35473463 files: [await toFile(fs.createReadStream("dcf_skill.zip"), "dcf_skill.zip")]
35483464 });
35493465
35503466 // Use with Excel to create financial model
3551 const response = await client.beta.messages.create({
3467 const response = await client.messages.create({
35523468 model: "claude-opus-5",
35533469 max_tokens: 4096,
3554 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
35553470 container: {
35563471 skills: [
35573472 { type: "anthropic", skill_id: "xlsx", version: "latest" },
from line 3490
35753490 AnthropicClient client = new();
35763491
35773492 // Create custom DCF analysis Skill
3578 var dcfSkill = await client.Beta.Skills.Create(new SkillCreateParams
3493 var dcfSkill = await client.Skills.Create(new SkillCreateParams
35793494 {
35803495 Files =
35813496 [
from line 3507
35923507 {
35933508 Model = "claude-opus-5",
35943509 MaxTokens = 4096,
3595 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
3596 Container = new BetaContainerParams
3510 Container = new ContainerParams
35973511 {
35983512 Skills =
35993513 [
3600 new BetaSkillParams
3514 new SkillParams
36013515 {
3602 Type = BetaSkillParamsType.Anthropic,
3516 Type = SkillParamsType.Anthropic,
36033517 SkillID = "xlsx",
36043518 Version = "latest",
36053519 },
3606 new BetaSkillParams
3520 new SkillParams
36073521 {
3608 Type = BetaSkillParamsType.Custom,
3522 Type = SkillParamsType.Custom,
36093523 SkillID = dcfSkill.ID,
36103524 Version = "latest",
36113525 },
36123526 ],
36133527 },
36143528 Messages = [new() { Role = Role.User, Content = "Build a DCF valuation model for a SaaS company" }],
3615 Tools = [new BetaCodeExecutionTool20250825()],
3529 Tools = [new CodeExecutionTool20250825()],
36163530 };
36173531
3618 var message = await client.Beta.Messages.Create(parameters);
3532 var message = await client.Messages.Create(parameters);
36193533 Console.WriteLine(message);
36203534 ```
36213535
from line 3540
36263540 dcfSkillID := "skill_01AbCdEfGhIjKlMnOpQrStUv"
36273541
36283542 // Use with Excel to create financial model
3629 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
3543 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
36303544 Model: "claude-opus-5",
36313545 MaxTokens: 4096,
3632 Betas: []anthropic.AnthropicBeta{
3633 "code-execution-2025-08-25",
3634 anthropic.AnthropicBetaSkills2025_10_02,
3635 },
3636 Container: anthropic.BetaMessageNewParamsContainerUnion{
3637 OfContainers: &anthropic.BetaContainerParams{
3638 Skills: []anthropic.BetaSkillParams{
3546 Container: anthropic.MessageCreateParamsContainerUnion{
3547 OfContainers: &anthropic.ContainerParams{
3548 Skills: []anthropic.SkillParams{
36393549 {
3640 Type: anthropic.BetaSkillParamsTypeAnthropic,
3550 Type: anthropic.SkillParamsTypeAnthropic,
36413551 SkillID: "xlsx",
36423552 Version: anthropic.String("latest"),
36433553 },
36443554 {
3645 Type: anthropic.BetaSkillParamsTypeCustom,
3555 Type: anthropic.SkillParamsTypeCustom,
36463556 SkillID: dcfSkillID,
36473557 Version: anthropic.String("latest"),
36483558 },
36493559 },
36503560 },
36513561 },
3652 Messages: []anthropic.BetaMessageParam{
3653 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Build a DCF valuation model for a SaaS company")),
3562 Messages: []anthropic.MessageParam{
3563 anthropic.NewUserMessage(anthropic.NewTextBlock("Build a DCF valuation model for a SaaS company")),
36543564 },
3655 Tools: []anthropic.BetaToolUnionParam{
3656 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
3565 Tools: []anthropic.ToolUnionParam{
3566 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
36573567 },
36583568 })
36593569 if err != nil {
from line 3573
36633573 ```
36643574
36653575 ```java Java
3666 import com.anthropic.models.beta.messages.BetaContainerParams;
3667 import com.anthropic.models.beta.messages.BetaSkillParams;
3668 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
3576 import com.anthropic.models.messages.ContainerParams;
3577 import com.anthropic.models.messages.SkillParams;
3578 import com.anthropic.models.messages.CodeExecutionTool20250825;
36693579 // ...
36703580 void main() {
36713581 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 3587
36773587 MessageCreateParams params = MessageCreateParams.builder()
36783588 .model(Model.CLAUDE_OPUS_5)
36793589 .maxTokens(4096L)
3680 .addBeta("code-execution-2025-08-25")
3681 .addBeta("skills-2025-10-02")
3682 .container(BetaContainerParams.builder()
3590 .container(ContainerParams.builder()
36833591 .skills(List.of(
3684 BetaSkillParams.builder()
3685 .type(BetaSkillParams.Type.ANTHROPIC)
3592 SkillParams.builder()
3593 .type(SkillParams.Type.ANTHROPIC)
36863594 .skillId("xlsx")
36873595 .version("latest")
36883596 .build(),
3689 BetaSkillParams.builder()
3690 .type(BetaSkillParams.Type.CUSTOM)
3597 SkillParams.builder()
3598 .type(SkillParams.Type.CUSTOM)
36913599 .skillId(dcfSkillId)
36923600 .version("latest")
36933601 .build()
36943602 ))
36953603 .build())
36963604 .addUserMessage("Build a DCF valuation model for a SaaS company")
3697 .addTool(BetaCodeExecutionTool20250825.builder().build())
3605 .addTool(CodeExecutionTool20250825.builder().build())
36983606 .build();
36993607
3700 BetaMessage response = client.beta().messages().create(params);
3608 Message response = client.messages().create(params);
37013609 System.out.println(response);
37023610 }
37033611 ```
from line 3641
37333641 client = Anthropic::Client.new
37343642
37353643 # Create custom DCF analysis Skill
3736 dcf_skill = client.beta.skills.create(
3644 dcf_skill = client.skills.create(
37373645 files: [
37383646 Anthropic::FilePart.new(
37393647 Pathname("dcf_skill/SKILL.md"),
from line 3652
37443652 )
37453653
37463654 # Use with Excel to create financial model
3747 response = client.beta.messages.create(
3655 response = client.messages.create(
37483656 model: "claude-opus-5",
37493657 max_tokens: 4096,
3750 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
37513658 container: {
37523659 skills: [
37533660 { type: "anthropic", skill_id: "xlsx", version: "latest" },
from line 3717
38103717
38113718The SDK tabs in this section show the `container` value to include in a Messages request. The cURL and CLI tabs show the full request.
38123719
3813**For production:** pin a specific version, so Skill updates never change your deployed behavior. If you omit `version` or set it to `"latest"`, requests use the newest version of the Skill, so a version uploaded by anyone in the [workspace](https://platform.claude.com/docs/en/build-with-claude/skills-guide#workspace-scoped-access) immediately changes what your production agents run. The version ID comes from the create-version response in [Versioning](https://platform.claude.com/docs/en/build-with-claude/skills-guide#versioning) or from the [List Skill Versions API](https://platform.claude.com/docs/en/api/beta/skills/versions/list). The ID is always a string: quote epoch-timestamp IDs in JSON or YAML.
3720**For production:** pin a specific version, so Skill updates never change your deployed behavior. If you omit `version` or set it to `"latest"`, requests use the newest version of the Skill, so a version uploaded by anyone in the [workspace](https://platform.claude.com/docs/en/build-with-claude/skills-guide#workspace-scoped-access) immediately changes what your production agents run. The version ID comes from the create-version response in [Versioning](https://platform.claude.com/docs/en/build-with-claude/skills-guide#versioning) or from the [List Skill Versions API](https://platform.claude.com/docs/en/api/skills/versions/list). The ID is always a string, so quote it in JSON or YAML (versions created under the `skills-2025-10-02` beta header have numeric-looking epoch-timestamp IDs).
38143721
38153722<CodeGroup>
38163723 ```bash cURL
from line 3725
38183725 curl https://api.anthropic.com/v1/messages \
38193726 -H "x-api-key: $ANTHROPIC_API_KEY" \
38203727 -H "anthropic-version: 2023-06-01" \
3821 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
38223728 -H "content-type: application/json" \
38233729 -d '{
38243730 "model": "claude-opus-5",
from line 3733
38273733 "skills": [{
38283734 "type": "custom",
38293735 "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
3830 "version": "1759178010641129"
3736 "version": "skver_01AbCdEfGhIjKlMnOpQrStUv"
38313737 }]
38323738 },
38333739 "messages": [{"role": "user", "content": "Analyze the sales data"}],
from line 3743
38373743
38383744 ```bash CLI
38393745 # Pin to specific versions for stability
3840 ant beta:messages create \
3841 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
3746 ant messages create <<YAML
38423747 model: claude-opus-5
38433748 max_tokens: 4096
38443749 container:
38453750 skills:
38463751 - type: custom
38473752 skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
3848 version: "1759178010641129" # quoted: the API requires a string
3753 version: "skver_01AbCdEfGhIjKlMnOpQrStUv"
38493754 messages:
38503755 - role: user
38513756 content: Analyze the sales data
from line 3767
38623767 {
38633768 "type": "custom",
38643769 "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
3865 "version": "1759178010641129",
3770 "version": "skver_01AbCdEfGhIjKlMnOpQrStUv",
38663771 }
38673772 ]
38683773 }
from line 3775
38703775
38713776 ```typescript TypeScript
38723777 // Pin to specific versions for stability
3873 const container: Anthropic.Beta.Messages.BetaContainerParams = {
3778 const container: Anthropic.ContainerParams = {
38743779 skills: [
38753780 {
38763781 type: "custom",
38773782 skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3878 version: "1759178010641129"
3783 version: "skver_01AbCdEfGhIjKlMnOpQrStUv"
38793784 }
38803785 ]
38813786 };
38823787 ```
38833788
38843789 ```csharp C#
3885 using Anthropic.Models.Beta.Messages;
3790 using Anthropic.Models.Messages;
38863791
38873792 // Pin to specific versions for stability
3888 var container = new BetaContainerParams
3793 var container = new ContainerParams
38893794 {
38903795 Skills =
38913796 [
3892 new BetaSkillParams
3797 new SkillParams
38933798 {
3894 Type = BetaSkillParamsType.Custom,
3799 Type = SkillParamsType.Custom,
38953800 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
3896 Version = "1759178010641129",
3801 Version = "skver_01AbCdEfGhIjKlMnOpQrStUv",
38973802 },
38983803 ],
38993804 };
from line 3806
39013806
39023807 ```go Go
39033808 // Pin to specific versions for stability
3904 container := anthropic.BetaMessageNewParamsContainerUnion{
3905 OfContainers: &anthropic.BetaContainerParams{
3906 Skills: []anthropic.BetaSkillParams{
3809 container := anthropic.MessageCreateParamsContainerUnion{
3810 OfContainers: &anthropic.ContainerParams{
3811 Skills: []anthropic.SkillParams{
39073812 {
3908 Type: anthropic.BetaSkillParamsTypeCustom,
3813 Type: anthropic.SkillParamsTypeCustom,
39093814 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3910 Version: anthropic.String("1759178010641129"),
3815 Version: anthropic.String("skver_01AbCdEfGhIjKlMnOpQrStUv"),
39113816 },
39123817 },
39133818 },
from line 3820
39153820 ```
39163821
39173822 ```java Java
3918 import com.anthropic.models.beta.messages.BetaContainerParams;
3919 import com.anthropic.models.beta.messages.BetaSkillParams;
3823 import com.anthropic.models.messages.ContainerParams;
3824 import com.anthropic.models.messages.SkillParams;
39203825
39213826 void main() {
39223827 // Pin to specific versions for stability
3923 BetaContainerParams container = BetaContainerParams.builder()
3924 .addSkill(BetaSkillParams.builder()
3925 .type(BetaSkillParams.Type.CUSTOM)
3828 ContainerParams container = ContainerParams.builder()
3829 .addSkill(SkillParams.builder()
3830 .type(SkillParams.Type.CUSTOM)
39263831 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
3927 .version("1759178010641129")
3832 .version("skver_01AbCdEfGhIjKlMnOpQrStUv")
39283833 .build())
39293834 .build();
39303835 }
from line 3852
39473852 skills: [{
39483853 type: "custom",
39493854 skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
3950 version: "1759178010641129"
3855 version: "skver_01AbCdEfGhIjKlMnOpQrStUv"
39513856 }]
39523857 }
39533858 ```
from line 3866
39613866 curl https://api.anthropic.com/v1/messages \
39623867 -H "x-api-key: $ANTHROPIC_API_KEY" \
39633868 -H "anthropic-version: 2023-06-01" \
3964 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
39653869 -H "content-type: application/json" \
39663870 -d '{
39673871 "model": "claude-opus-5",
from line 3884
39803884
39813885 ```bash CLI
39823886 # Use latest for active development
3983 ant beta:messages create \
3984 --beta code-execution-2025-08-25,skills-2025-10-02 <<YAML
3887 ant messages create <<YAML
39853888 model: claude-opus-5
39863889 max_tokens: 4096
39873890 container:
from line 3916
40133916
40143917 ```typescript TypeScript
40153918 // Use latest for active development
4016 const container: Anthropic.Beta.Messages.BetaContainerParams = {
3919 const container: Anthropic.ContainerParams = {
40173920 skills: [
40183921 {
40193922 type: "custom",
from line 3928
40253928 ```
40263929
40273930 ```csharp C#
4028 using Anthropic.Models.Beta.Messages;
3931 using Anthropic.Models.Messages;
40293932
40303933 // Use latest for active development
4031 var container = new BetaContainerParams
3934 var container = new ContainerParams
40323935 {
40333936 Skills =
40343937 [
4035 new BetaSkillParams
3938 new SkillParams
40363939 {
4037 Type = BetaSkillParamsType.Custom,
3940 Type = SkillParamsType.Custom,
40383941 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
40393942 Version = "latest",
40403943 },
from line 3947
40443947
40453948 ```go Go
40463949 // Use latest for active development
4047 container := anthropic.BetaMessageNewParamsContainerUnion{
4048 OfContainers: &anthropic.BetaContainerParams{
4049 Skills: []anthropic.BetaSkillParams{
3950 container := anthropic.MessageCreateParamsContainerUnion{
3951 OfContainers: &anthropic.ContainerParams{
3952 Skills: []anthropic.SkillParams{
40503953 {
4051 Type: anthropic.BetaSkillParamsTypeCustom,
3954 Type: anthropic.SkillParamsTypeCustom,
40523955 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
40533956 Version: anthropic.String("latest"),
40543957 },
from line 3961
40583961 ```
40593962
40603963 ```java Java
4061 import com.anthropic.models.beta.messages.BetaContainerParams;
4062 import com.anthropic.models.beta.messages.BetaSkillParams;
3964 import com.anthropic.models.messages.ContainerParams;
3965 import com.anthropic.models.messages.SkillParams;
40633966
40643967 void main() {
40653968 // Use latest for active development
4066 BetaContainerParams container = BetaContainerParams.builder()
4067 .addSkill(BetaSkillParams.builder()
4068 .type(BetaSkillParams.Type.CUSTOM)
3969 ContainerParams container = ContainerParams.builder()
3970 .addSkill(SkillParams.builder()
3971 .type(SkillParams.Type.CUSTOM)
40693972 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
40703973 .version("latest")
40713974 .build())
from line 4009
41064009 curl https://api.anthropic.com/v1/messages \
41074010 -H "x-api-key: $ANTHROPIC_API_KEY" \
41084011 -H "anthropic-version: 2023-06-01" \
4109 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
41104012 -H "content-type: application/json" \
41114013 -d '{
41124014 "model": "claude-opus-5",
from line 4026
41244026 curl https://api.anthropic.com/v1/messages \
41254027 -H "x-api-key: $ANTHROPIC_API_KEY" \
41264028 -H "anthropic-version: 2023-06-01" \
4127 -H "anthropic-beta: code-execution-2025-08-25,skills-2025-10-02" \
41284029 -H "content-type: application/json" \
41294030 -d '{
41304031 "model": "claude-opus-5",
from line 4043
41424043
41434044 ```bash CLI
41444045 # Skills render into the system prompt in a fixed, cache-friendly order
4145 ant beta:messages create \
4146 --beta code-execution-2025-08-25,skills-2025-10-02 <<'YAML'
4046 ant messages create <<'YAML'
41474047 model: claude-opus-5
41484048 max_tokens: 4096
41494049 container:
from line 4060
41604060 YAML
41614061
41624062 # Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
4163 ant beta:messages create \
4164 --beta code-execution-2025-08-25,skills-2025-10-02 <<'YAML'
4063 ant messages create <<'YAML'
41654064 model: claude-opus-5
41664065 max_tokens: 4096
41674066 container:
from line 4084
41854084 client = anthropic.Anthropic()
41864085
41874086 # Skills render into the system prompt in a fixed, cache-friendly order
4188 response1 = client.beta.messages.create(
4087 response1 = client.messages.create(
41894088 model="claude-opus-5",
41904089 max_tokens=4096,
4191 betas=[
4192 "code-execution-2025-08-25",
4193 "skills-2025-10-02",
4194 ],
41954090 container={
41964091 "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
41974092 },
from line 4095
42004095 )
42014096
42024097 # Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
4203 response2 = client.beta.messages.create(
4098 response2 = client.messages.create(
42044099 model="claude-opus-5",
42054100 max_tokens=4096,
4206 betas=[
4207 "code-execution-2025-08-25",
4208 "skills-2025-10-02",
4209 ],
42104101 container={
42114102 "skills": [
42124103 {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
from line 4117
42264117 const client = new Anthropic();
42274118
42284119 // Skills render into the system prompt in a fixed, cache-friendly order
4229 const response1 = await client.beta.messages.create({
4120 const response1 = await client.messages.create({
42304121 model: "claude-opus-5",
42314122 max_tokens: 4096,
4232 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
42334123 container: {
42344124 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
42354125 },
from line 4128
42384128 });
42394129
42404130 // Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
4241 const response2 = await client.beta.messages.create({
4131 const response2 = await client.messages.create({
42424132 model: "claude-opus-5",
42434133 max_tokens: 4096,
4244 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
42454134 container: {
42464135 skills: [
42474136 { type: "anthropic", skill_id: "xlsx", version: "latest" },
from line 4150
42614150 {
42624151 Model = "claude-opus-5",
42634152 MaxTokens = 4096,
4264 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
4265 Container = new BetaContainerParams
4153 Container = new ContainerParams
42664154 {
42674155 Skills =
42684156 [
4269 new BetaSkillParams
4157 new SkillParams
42704158 {
4271 Type = BetaSkillParamsType.Anthropic,
4159 Type = SkillParamsType.Anthropic,
42724160 SkillID = "xlsx",
42734161 Version = "latest",
42744162 },
42754163 ],
42764164 },
42774165 Messages = [new() { Role = Role.User, Content = "Analyze sales data" }],
4278 Tools = [new BetaCodeExecutionTool20250825()],
4166 Tools = [new CodeExecutionTool20250825()],
42794167 };
42804168
4281 var response1 = await client.Beta.Messages.Create(parameters1);
4169 var response1 = await client.Messages.Create(parameters1);
42824170 Console.WriteLine(response1);
42834171
42844172 // Different Skill set ([xlsx] vs [xlsx, pptx]) = a different prefix: a cache miss (an identical set is a cache hit)
from line 4174
42864174 {
42874175 Model = "claude-opus-5",
42884176 MaxTokens = 4096,
4289 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
4290 Container = new BetaContainerParams
4177 Container = new ContainerParams
42914178 {
42924179 Skills =
42934180 [
4294 new BetaSkillParams
4181 new SkillParams
42954182 {
4296 Type = BetaSkillParamsType.Anthropic,
4183 Type = SkillParamsType.Anthropic,
42974184 SkillID = "xlsx",
42984185 Version = "latest",
42994186 },
4300 new BetaSkillParams
4187 new SkillParams
43014188 {
4302 Type = BetaSkillParamsType.Anthropic,
4189 Type = SkillParamsType.Anthropic,
43034190 SkillID = "pptx",
43044191 Version = "latest",
43054192 },
43064193 ],
43074194 },
43084195 Messages = [new() { Role = Role.User, Content = "Create a presentation" }],
4309 Tools = [new BetaCodeExecutionTool20250825()],
4196 Tools = [new CodeExecutionTool20250825()],
43104197 };
43114198
4312 var response2 = await client.Beta.Messages.Create(parameters2);
4199 var response2 = await client.Messages.Create(parameters2);
43134200 Console.WriteLine(response2);
43144201 ```
43154202
from line 4204
43174204 client := anthropic.NewClient()
43184205
43194206 // Skills render into the system prompt in a fixed, cache-friendly order
4320 response1, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
4207 response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
43214208 Model: "claude-opus-5",
43224209 MaxTokens: 4096,
4323 Betas: []anthropic.AnthropicBeta{
4324 "code-execution-2025-08-25",
4325 anthropic.AnthropicBetaSkills2025_10_02,
4326 },
4327 Container: anthropic.BetaMessageNewParamsContainerUnion{
4328 OfContainers: &anthropic.BetaContainerParams{
4329 Skills: []anthropic.BetaSkillParams{
4210 Container: anthropic.MessageCreateParamsContainerUnion{
4211 OfContainers: &anthropic.ContainerParams{
4212 Skills: []anthropic.SkillParams{
43304213 {
4331 Type: anthropic.BetaSkillParamsTypeAnthropic,
4214 Type: anthropic.SkillParamsTypeAnthropic,
43324215 SkillID: "xlsx",
43334216 Version: anthropic.String("latest"),
43344217 },
43354218 },
43364219 },
43374220 },
4338 Messages: []anthropic.BetaMessageParam{
4339 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Analyze sales data")),
4221 Messages: []anthropic.MessageParam{
4222 anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze sales data")),
43404223 },
4341 Tools: []anthropic.BetaToolUnionParam{
4342 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
4224 Tools: []anthropic.ToolUnionParam{
4225 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
43434226 },
43444227 })
43454228 if err != nil {
from line 4231
43484231 fmt.Println(response1)
43494232
43504233 // Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
4351 response2, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
4234 response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
43524235 Model: "claude-opus-5",
43534236 MaxTokens: 4096,
4354 Betas: []anthropic.AnthropicBeta{
4355 "code-execution-2025-08-25",
4356 anthropic.AnthropicBetaSkills2025_10_02,
4357 },
4358 Container: anthropic.BetaMessageNewParamsContainerUnion{
4359 OfContainers: &anthropic.BetaContainerParams{
4360 Skills: []anthropic.BetaSkillParams{
4237 Container: anthropic.MessageCreateParamsContainerUnion{
4238 OfContainers: &anthropic.ContainerParams{
4239 Skills: []anthropic.SkillParams{
43614240 {
4362 Type: anthropic.BetaSkillParamsTypeAnthropic,
4241 Type: anthropic.SkillParamsTypeAnthropic,
43634242 SkillID: "xlsx",
43644243 Version: anthropic.String("latest"),
43654244 },
43664245 {
4367 Type: anthropic.BetaSkillParamsTypeAnthropic,
4246 Type: anthropic.SkillParamsTypeAnthropic,
43684247 SkillID: "pptx",
43694248 Version: anthropic.String("latest"),
43704249 },
43714250 },
43724251 },
43734252 },
4374 Messages: []anthropic.BetaMessageParam{
4375 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Create a presentation")),
4253 Messages: []anthropic.MessageParam{
4254 anthropic.NewUserMessage(anthropic.NewTextBlock("Create a presentation")),
43764255 },
4377 Tools: []anthropic.BetaToolUnionParam{
4378 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
4256 Tools: []anthropic.ToolUnionParam{
4257 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
43794258 },
43804259 })
43814260 if err != nil {
from line 4264
43854264 ```
43864265
43874266 ```java Java
4388 import com.anthropic.models.beta.messages.BetaContainerParams;
4389 import com.anthropic.models.beta.messages.BetaSkillParams;
4390 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
4267 import com.anthropic.models.messages.ContainerParams;
4268 import com.anthropic.models.messages.SkillParams;
4269 import com.anthropic.models.messages.CodeExecutionTool20250825;
43914270 // ...
43924271 void main() {
43934272 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 4275
43964275 MessageCreateParams params1 = MessageCreateParams.builder()
43974276 .model(Model.CLAUDE_OPUS_5)
43984277 .maxTokens(4096L)
4399 .addBeta("code-execution-2025-08-25")
4400 .addBeta("skills-2025-10-02")
4401 .container(BetaContainerParams.builder()
4278 .container(ContainerParams.builder()
44024279 .skills(List.of(
4403 BetaSkillParams.builder()
4404 .type(BetaSkillParams.Type.ANTHROPIC)
4280 SkillParams.builder()
4281 .type(SkillParams.Type.ANTHROPIC)
44054282 .skillId("xlsx")
44064283 .version("latest")
44074284 .build()
44084285 ))
44094286 .build())
44104287 .addUserMessage("Analyze sales data")
4411 .addTool(BetaCodeExecutionTool20250825.builder().build())
4288 .addTool(CodeExecutionTool20250825.builder().build())
44124289 .build();
44134290
4414 BetaMessage response1 = client.beta().messages().create(params1);
4291 Message response1 = client.messages().create(params1);
44154292 System.out.println(response1);
44164293
44174294 // Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
44184295 MessageCreateParams params2 = MessageCreateParams.builder()
44194296 .model(Model.CLAUDE_OPUS_5)
44204297 .maxTokens(4096L)
4421 .addBeta("code-execution-2025-08-25")
4422 .addBeta("skills-2025-10-02")
4423 .container(BetaContainerParams.builder()
4298 .container(ContainerParams.builder()
44244299 .skills(List.of(
4425 BetaSkillParams.builder()
4426 .type(BetaSkillParams.Type.ANTHROPIC)
4300 SkillParams.builder()
4301 .type(SkillParams.Type.ANTHROPIC)
44274302 .skillId("xlsx")
44284303 .version("latest")
44294304 .build(),
4430 BetaSkillParams.builder()
4431 .type(BetaSkillParams.Type.ANTHROPIC)
4305 SkillParams.builder()
4306 .type(SkillParams.Type.ANTHROPIC)
44324307 .skillId("pptx")
44334308 .version("latest")
44344309 .build()
44354310 ))
44364311 .build())
44374312 .addUserMessage("Create a presentation")
4438 .addTool(BetaCodeExecutionTool20250825.builder().build())
4313 .addTool(CodeExecutionTool20250825.builder().build())
44394314 .build();
44404315
4441 BetaMessage response2 = client.beta().messages().create(params2);
4316 Message response2 = client.messages().create(params2);
44424317 System.out.println(response2);
44434318 }
44444319 ```
from line 4371
44964371 client = Anthropic::Client.new
44974372
44984373 # Skills render into the system prompt in a fixed, cache-friendly order
4499 response1 = client.beta.messages.create(
4374 response1 = client.messages.create(
45004375 model: "claude-opus-5",
45014376 max_tokens: 4096,
4502 betas: [
4503 "code-execution-2025-08-25",
4504 "skills-2025-10-02",
4505 ],
45064377 container: {
45074378 skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
45084379 },
from line 4383
45124383 puts response1
45134384
45144385 # Changing the Skills list ([xlsx] vs [xlsx, pptx]) changes the prefix: a cache miss, while an identical list is a cache hit
4515 response2 = client.beta.messages.create(
4386 response2 = client.messages.create(
45164387 model: "claude-opus-5",
45174388 max_tokens: 4096,
4518 betas: [
4519 "code-execution-2025-08-25",
4520 "skills-2025-10-02",
4521 ],
45224389 container: {
45234390 skills: [
45244391 { type: "anthropic", skill_id: "xlsx", version: "latest" },
from line 4414
45474414 ```
45484415
45494416 ```bash CLI
4550 if ! RESULT=$(ant beta:messages create \
4551 --beta code-execution-2025-08-25,skills-2025-10-02 \
4417 if ! RESULT=$(ant messages create \
45524418 --transform-error error.message \
45534419 --format-error yaml 2>&1 <<'YAML'
45544420 model: claude-opus-5
from line 4449
45834449 client = anthropic.Anthropic()
45844450
45854451 try:
4586 response = client.beta.messages.create(
4452 response = client.messages.create(
45874453 model="claude-opus-5",
45884454 max_tokens=4096,
4589 betas=["code-execution-2025-08-25", "skills-2025-10-02"],
45904455 container={
45914456 "skills": [
45924457 {
from line 4476
46114476 const client = new Anthropic();
46124477
46134478 try {
4614 const response = await client.beta.messages.create({
4479 const response = await client.messages.create({
46154480 model: "claude-opus-5",
46164481 max_tokens: 4096,
4617 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
46184482 container: {
46194483 skills: [
46204484 { type: "custom", skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv", version: "latest" }
from line 4509
46454509 {
46464510 Model = "claude-opus-5",
46474511 MaxTokens = 4096,
4648 Betas = ["code-execution-2025-08-25", "skills-2025-10-02"],
4649 Container = new BetaContainerParams
4512 Container = new ContainerParams
46504513 {
46514514 Skills =
46524515 [
4653 new BetaSkillParams
4516 new SkillParams
46544517 {
4655 Type = BetaSkillParamsType.Custom,
4518 Type = SkillParamsType.Custom,
46564519 SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
46574520 Version = "latest",
46584521 },
46594522 ],
46604523 },
46614524 Messages = [new() { Role = Role.User, Content = "Process data" }],
4662 Tools = [new BetaCodeExecutionTool20250825()],
4525 Tools = [new CodeExecutionTool20250825()],
46634526 };
46644527
4665 var response = await client.Beta.Messages.Create(parameters);
4528 var response = await client.Messages.Create(parameters);
46664529 Console.WriteLine(response);
46674530 }
46684531 catch (AnthropicBadRequestException e) when (e.Message.Contains("skill"))
from line 4537
46744537 ```go Go
46754538 client := anthropic.NewClient()
46764539
4677 response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
4540 response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
46784541 Model: "claude-opus-5",
46794542 MaxTokens: 4096,
4680 Betas: []anthropic.AnthropicBeta{"code-execution-2025-08-25", anthropic.AnthropicBetaSkills2025_10_02},
4681 Container: anthropic.BetaMessageNewParamsContainerUnion{
4682 OfContainers: &anthropic.BetaContainerParams{
4683 Skills: []anthropic.BetaSkillParams{
4543 Container: anthropic.MessageCreateParamsContainerUnion{
4544 OfContainers: &anthropic.ContainerParams{
4545 Skills: []anthropic.SkillParams{
46844546 {
4685 Type: anthropic.BetaSkillParamsTypeCustom,
4547 Type: anthropic.SkillParamsTypeCustom,
46864548 SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
46874549 Version: anthropic.String("latest"),
46884550 },
46894551 },
46904552 },
46914553 },
4692 Messages: []anthropic.BetaMessageParam{
4693 anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Process data")),
4554 Messages: []anthropic.MessageParam{
4555 anthropic.NewUserMessage(anthropic.NewTextBlock("Process data")),
46944556 },
4695 Tools: []anthropic.BetaToolUnionParam{
4696 {OfCodeExecutionTool20250825: &anthropic.BetaCodeExecutionTool20250825Param{}},
4557 Tools: []anthropic.ToolUnionParam{
4558 {OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
46974559 },
46984560 })
46994561
from line 4574
47124574
47134575 ```java Java
47144576 import com.anthropic.errors.BadRequestException;
4715 import com.anthropic.models.beta.messages.BetaContainerParams;
4716 import com.anthropic.models.beta.messages.BetaSkillParams;
4717 import com.anthropic.models.beta.messages.BetaCodeExecutionTool20250825;
4577 import com.anthropic.models.messages.ContainerParams;
4578 import com.anthropic.models.messages.SkillParams;
4579 import com.anthropic.models.messages.CodeExecutionTool20250825;
47184580 // ...
47194581 void main() {
47204582 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
from line 4585
47234585 MessageCreateParams params = MessageCreateParams.builder()
47244586 .model(Model.CLAUDE_OPUS_5)
47254587 .maxTokens(4096L)
4726 .addBeta("code-execution-2025-08-25")
4727 .addBeta("skills-2025-10-02")
4728 .container(BetaContainerParams.builder()
4729 .addSkill(BetaSkillParams.builder()
4730 .type(BetaSkillParams.Type.CUSTOM)
4588 .container(ContainerParams.builder()
4589 .addSkill(SkillParams.builder()
4590 .type(SkillParams.Type.CUSTOM)
47314591 .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
47324592 .version("latest")
47334593 .build())
47344594 .build())
47354595 .addUserMessage("Process data")
4736 .addTool(BetaCodeExecutionTool20250825.builder().build())
4596 .addTool(CodeExecutionTool20250825.builder().build())
47374597 .build();
47384598
4739 BetaMessage response = client.beta().messages().create(params);
4599 Message response = client.messages().create(params);
47404600 System.out.println(response);
47414601 } catch (BadRequestException e) {
47424602 if (e.getMessage().contains("skill")) {
from line 4648
47884648 client = Anthropic::Client.new
47894649
47904650 begin
4791 response = client.beta.messages.create(
4651 response = client.messages.create(
47924652 model: "claude-opus-5",
47934653 max_tokens: 4096,
4794 betas: ["code-execution-2025-08-25", "skills-2025-10-02"],
47954654 container: {
47964655 skills: [
47974656 {
from line 4688
48294688## Next steps
48304689
48314690<CardGroup cols={3}>
4832 <Card title="API reference" icon="book" href="https://platform.claude.com/docs/en/api/beta/skills/create">
4691 <Card title="API reference" icon="book" href="https://platform.claude.com/docs/en/api/skills/create">
48334692 Complete API reference with all endpoints
48344693 </Card>
48354694
48364695
No line in this hunk matches that.