클로드 API

What does your application need?

0. Are you deploying through Amazon Bedrock, Google Vertex AI, or Microsoft Foundry?
    Yes -> Claude API (+ tool use for agents) - Managed Agents is 1P only.
   No -> continue.

1. Single LLM call (classification, summarization, extraction, Q&A)
    Claude API - one request, one response

2. Do you want Anthropic to run the agent loop and host a per-session
   container where Claude executes tools (bash, file ops, code)?
    Yes -> Managed Agents - server-managed sessions, persisted agent configs,
       SSE event stream, Skills + MCP, file mounts.
       Examples: "stateful coding agent with a workspace per task",
                 "long-running research agent that streams events to a UI",
                 "agent with persisted, versioned config used across many sessions"

3. Workflow (multi-step, code-orchestrated, with your own tools)
    Claude API with tool use - you control the loop

4. Open-ended agent (model decides its own trajectory, your own tools, you host the compute)
    Claude API agentic loop (maximum flexibility)

# Message Batches API — Python

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```python
수입 인류
anthropic.types.message_create_params import MessageCreateParamsNonStreaming에서
anthropic.types.messages.batch_create_params 가져오기 요청에서

클라이언트 = Anthropic.Anthropic()

message_batch = client.messages.batches.create(
    요청=[
        요청(
            custom_id="요청-1",
            params=MessageCreateParamsNonStreaming(
                모델="claude-opus-4-7",
                max_tokens=16000,
                message=[{"role": "user", "content": "기후 변화 영향 요약"}]
            )
        ),
        요청(
            custom_id="요청-2",
            params=MessageCreateParamsNonStreaming(
                모델="claude-opus-4-7",
                max_tokens=16000,
                message=[{"role": "user", "content": "양자 컴퓨팅 기본 사항 설명"}]
            )
        ),
    ]
)

print(f"배치 ID: {message_batch.id}")
print(f"상태: {message_batch.processing_status}")

수입 시간

True인 동안:
    배치 = client.messages.batches.retrieve(message_batch.id)
    Batch.processing_status == "종료"인 경우:
        휴식
    print(f"상태: {batch.processing_status}, 처리 중: {batch.request_counts.processing}")
    시간.수면(60)

print("배치 완료!")
print(f"성공: {batch.request_counts.succeeded}")
print(f"오류 발생: {batch.request_counts.errored}")

client.messages.batches.results(message_batch.id)의 결과:
    일치 결과.결과.유형:
        사례 "성공":
            msg = 결과.결과.메시지
            text = next((b.type == "text"인 경우 msg.content의 b에 대한 b.text), "")
            print(f"[{result.custom_id}] {텍스트[:100]}")
        "오류가 발생했습니다":
            result.result.error.type == "invalid_request"인 경우:
                print(f"[{result.custom_id}] 유효성 검사 오류 - 요청을 수정하고 다시 시도하세요")
            그 외:
                print(f"[{result.custom_id}] 서버 오류 - 재시도해도 안전함")
        사례 "취소":
            print(f"[{result.custom_id}] 취소됨")
        "만료됨"인 경우:
            print(f"[{result.custom_id}] 만료됨 - 다시 제출")

취소됨 = client.messages.batches.cancel(message_batch.id)
print(f"상태: {cancelled.processing_status}") # "취소 중"

공유 시스템 = [
    {"type": "text", "text": "당신은 문학 분석가입니다."},
    {
        "유형": "텍스트",
        "text": Large_document_text, # 모든 요청에서 공유됨
        "cache_control": {"type": "임시"}
    }
]

message_batch = client.messages.batches.create(
    요청=[
        요청(
            custom_id=f"분석-{i}",
            params=MessageCreateParamsNonStreaming(
                모델="claude-opus-4-7",
                max_tokens=16000,
                시스템=shared_system,
                메시지=[{"역할": "사용자", "콘텐츠": 질문}]
            )
        )
        나는, 열거된 질문(질문)
    ]
)

수입 인류
수입 시간
anthropic.types.message_create_params import MessageCreateParamsNonStreaming에서
anthropic.types.messages.batch_create_params 가져오기 요청에서

클라이언트 = Anthropic.Anthropic()

# 1. 요청 준비
items_to_classify = [
    "제품 품질이 우수해요!",
    "끔찍한 고객 서비스, 다시는 없을 것입니다.",
    "괜찮아, 특별한 건 없어.",
]

요청 = [
    요청(
        custom_id=f"분류-{i}",
        params=MessageCreateParamsNonStreaming(
            모델="claude-haiku-4-5",
            max_tokens=50,
            메시지=[{
                "역할": "사용자",
                "content": f"긍정/부정/중립으로 분류(한 단어): {text}"
            }]
        )
    )
    i의 경우 enumerate(items_to_classify)의 텍스트
]

# 2. 배치 생성
배치 = client.messages.batches.create(요청=요청)
print(f"생성된 배치: {batch.id}")

# 3. 완료될 때까지 기다리기
True인 동안:
    배치 = client.messages.batches.retrieve(batch.id)
    Batch.processing_status == "종료"인 경우:
        휴식
    시간.수면(10)

# 4. 결과 수집
결과 = {}
client.messages.batches.results(batch.id)의 결과:
    result.result.type == "성공"인 경우:
        msg = 결과.결과.메시지
        결과[result.custom_id] = next((b.type == "text"인 경우 msg.content의 b에 대한 b.text), "")

custom_id의 경우 sorted(results.items()) 분류:
    인쇄(f"{custom_id}: {classification}")

### 파이썬/claude-api/files-api.md

[python/claude-api/files-api.md 다운로드](/skills/claude-api/python/claude-api/files-api.md)

```markdown
# Files API — Python

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas=["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```python
수입 인류

클라이언트 = Anthropic.Anthropic()

업로드됨 = client.beta.files.upload(
    file=("report.pdf", open("report.pdf", "rb"), "application/pdf"),
)
print(f"파일 ID: {uploaded.id}")
print(f"크기: {uploaded.size_bytes} 바이트")

응답 = client.beta.messages.create(
    모델="claude-opus-4-7",
    max_tokens=16000,
    메시지=[{
        "역할": "사용자",
        "콘텐츠": [
            {"type": "text", "text": "이 보고서의 주요 결과를 요약합니다."},
            {
                "유형": "문서",
                "소스": {"유형": "파일", "파일_ID": 업로드된.id},
                "title": "4분기 보고서", # 선택 사항
                "citations": {"enabled": True} # 선택 사항, 인용 활성화
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
)
response.content의 블록:
    block.type == "텍스트"인 경우:
        인쇄(블록.텍스트)

image_file = client.beta.files.upload(
    file=("photo.png", open("photo.png", "rb"), "이미지/png"),
)

응답 = client.beta.messages.create(
    모델="claude-opus-4-7",
    max_tokens=16000,
    메시지=[{
        "역할": "사용자",
        "콘텐츠": [
            {"type": "text", "text": "이 이미지에는 무엇이 있나요?"},
            {
                "유형": "이미지",
                "소스": {"유형": "파일", "파일_ID": 이미지_파일.id}
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
)

파일 = client.beta.files.list()
files.data의 f에 대해:
    print(f"{f.id}: {f.filename} ({f.size_bytes} 바이트)")

file_info = client.beta.files.retrieve_metadata("file_011CNha8iCJcU1wXNR6q4V8w")
print(f"파일명: {file_info.filename}")
print(f"MIME 유형: {file_info.mime_type}")

client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w")

file_content = client.beta.files.download("file_011CNha8iCJcU1wXNR6q4V8w")
file_content.write_to_file("output.txt")

수입 인류

클라이언트 = Anthropic.Anthropic()

# 1. 한번 업로드
업로드됨 = client.beta.files.upload(
    file=("contract.pdf", open("contract.pdf", "rb"), "application/pdf"),
)
print(f"업로드됨: {uploaded.id}")

# 2. 동일한 file_id를 사용하여 여러 질문하기
질문 = [
    "주요 이용약관은 무엇인가요?",
    "해지 조항이 무엇인가요?",
    "지불 일정을 요약합니다.",
]

질문에 대한 질문:
    응답 = client.beta.messages.create(
        모델="claude-opus-4-7",
        max_tokens=16000,
        메시지=[{
            "역할": "사용자",
            "콘텐츠": [
                {"유형": "텍스트", "텍스트": 질문},
                {
                    "유형": "문서",
                    "소스": {"유형": "파일", "파일_ID": 업로드된.id}
                }
            ]
        }],
        betas=["files-api-2025-04-14"],
    )
    print(f"\nQ: {question}")
    text = next((b.type == "text"인 경우 response.content의 b에 대한 b.text), "")
    print(f"A: {text[:200]}")

# 3. 끝나면 정리하세요
client.beta.files.delete(업로드된.id)

### 파이썬/claude-api/streaming.md

[python/claude-api/streaming.md 다운로드](/skills/claude-api/python/claude-api/streaming.md)

```markdown
# Streaming — Python

## Quick Start

```python
client.messages.stream(
    모델="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "스토리 쓰기"}]
) 스트림으로:
    stream.text_stream의 텍스트:
        인쇄(텍스트, end="", 플러시=True)

async_client.messages.stream(
    모델="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "스토리 쓰기"}]
) 스트림으로:
    stream.text_stream의 텍스트에 대한 비동기:
        인쇄(텍스트, end="", 플러시=True)

client.messages.stream(
    모델="claude-opus-4-7",
    max_tokens=64000,
    Thinking={"type": "적응형"},
    message=[{"role": "user", "content": "이 문제 분석"}]
) 스트림으로:
    스트림 내 이벤트의 경우:
        event.type == "content_block_start"인 경우:
            event.content_block.type == "생각"인 경우:
                print("\n[생각 중...]")
            elif event.content_block.type == "텍스트":
                print("\n[응답:]")

        elif event.type == "content_block_delta":
            event.delta.type == "thinking_delta"인 경우:
                인쇄(event.delta.thinking, end="", 플러시=True)
            elif event.delta.type == "text_delta":
                인쇄(event.delta.text, end="", 플러시=True)

client.messages.stream(
    모델="claude-opus-4-7",
    max_tokens=64000,
    도구=도구,
    메시지=메시지
) 스트림으로:
    stream.text_stream의 텍스트:
        인쇄(텍스트, end="", 플러시=True)

    응답 = stream.get_final_message()
    # response.stop_reason == "tool_use"인 경우 도구 실행을 계속합니다.

client.messages.stream(
    모델="claude-opus-4-7",
    max_tokens=64000,
    message=[{"role": "user", "content": "안녕하세요"}]
) 스트림으로:
    stream.text_stream의 텍스트:
        인쇄(텍스트, end="", 플러시=True)

    # 스트리밍 후 전체 메시지 받기
    final_message = stream.get_final_message()
    print(f"\n\n사용된 토큰: {final_message.usage.output_tokens}")

def stream_with_progress(클라이언트, **kwargs):
    """진행상황 업데이트에 대한 응답을 스트리밍합니다."""
    total_tokens = 0
    콘텐츠_부분 = []

    client.messages.stream(**kwargs)을 스트림으로 사용:
        스트림 내 이벤트의 경우:
            event.type == "content_block_delta"인 경우:
                event.delta.type == "text_delta"인 경우:
                    텍스트 = event.delta.text
                    content_parts.append(텍스트)
                    인쇄(텍스트, end="", 플러시=True)

            elif event.type == "message_delta":
                event.usage 및 event.usage.output_tokens가 None이 아닌 경우:
                    total_tokens = event.usage.output_tokens

        final_message = stream.get_final_message()

    print(f"\n\n[사용된 토큰: {total_tokens}]")
    반환 "".join(content_parts)

시도해 보세요:
    client.messages.stream(
        모델="claude-opus-4-7",
        max_tokens=64000,
        message=[{"role": "user", "content": "스토리 쓰기"}]
    ) 스트림으로:
        stream.text_stream의 텍스트:
            인쇄(텍스트, end="", 플러시=True)
anthropic.APIConnectionError를 제외하고:
    print("\n연결이 끊어졌습니다. 다시 시도해 주세요.")
anthropic.RateLimitError 제외:
    print("\n속도가 제한되어 있습니다. 잠시 기다렸다가 다시 시도하십시오.")
e로 anthropic.APIStatusError를 제외하고:
    print(f"\nAPI 오류: {e.status_code}")

### 파이썬/claude-api/tool-use.md

[python/claude-api/tool-use.md 다운로드](/skills/claude-api/python/claude-api/tool-use.md)

_바이너리 리소스_

### 파이썬/관리 에이전트/README.md

[python/managed-agents/README.md 다운로드](/skills/claude-api/python/managed-agents/README.md)

_바이너리 리소스_

### 루비/claude-api.md

[ruby/claude-api.md 다운로드](/skills/claude-api/ruby/claude-api.md)

```markdown
# Claude API — Ruby

> **Note:** The Ruby SDK supports the Claude API. A tool runner is available in beta via `client.beta.messages.tool_runner()`. Agent SDK is not yet available for Ruby.

## Installation

```bash
보석 설치 인류학

"인류"가 필요하다

# 기본값(ANTHROPIC_API_KEY 환경 변수 사용)
클라이언트 = Anthropic::Client.new

# 명시적 API 키
클라이언트 = Anthropic::Client.new(api_key: "your-api-key")

메시지 = client.messages.create(
  모델::"claude-opus-4-7",
  최대 토큰: 16000,
  메시지: [
    { role: "user", content: "프랑스의 수도는 어디인가요?" }
  ]
)
# 콘텐츠는 다형성 블록 객체(TextBlock, ThinkingBlock,
# ToolUseBlock,...)..type은 기호입니다. "text"가 아닌:text와 비교해 보세요.
# .text는 TextBlock이 아닌 항목에 대해 NoMethodError를 발생시킵니다.
message.content.each는 |block|
  block.type ==:text인 경우 block.text를 넣습니다.
끝

스트림 = client.messages.stream(
  모델::"claude-opus-4-7",
  최대_토큰: 64000,
  메시지: [{ 역할: "사용자", 내용: "하이쿠 쓰기" }]
)

stream.text.each { |텍스트| 인쇄(텍스트) }

클래스 GetWeatherInput < Anthropic::BaseModel
  필수:location, String, doc: "도시 및 주(예: 캘리포니아 주 샌프란시스코")
끝

클래스 GetWeather < Anthropic::BaseTool
  doc "특정 위치의 현재 날씨 가져오기"

  input_schema GetWeatherInput

  데프 호출(입력)
    "#{input.location}의 날씨는 맑고 화씨 22도입니다."
  끝
끝

client.beta.messages.tool_runner(
  모델::"claude-opus-4-7",
  최대 토큰: 16000,
  도구: [GetWeather.new],
  message: [{ role: "user", content: "샌프란시스코 날씨는 어때?" }]
).each_message 할 |메시지|
  message.content를 넣습니다.
끝

메시지 = client.messages.create(
  모델::"claude-opus-4-7",
  최대 토큰: 16000,
  시스템_: [
    { 유형: "텍스트", 텍스트: long_system_prompt, 캐시_제어: { 유형: "임시" } }
  ],
  메시지: [{ 역할: "사용자", 내용: "핵심 사항 요약" }]
)

### 루비/관리 에이전트/README.md

[ruby/managed-agents/README.md 다운로드](/skills/claude-api/ruby/managed-agents/README.md)

_바이너리 리소스_

### 공유/에이전트-design.md

[shared/agent-design.md 다운로드](/skills/claude-api/shared/agent-design.md)

_바이너리 리소스_

### 공유/오류-codes.md

[shared/error-codes.md 다운로드](/skills/claude-api/shared/error-codes.md)

_바이너리 리소스_

### 공유/live-sources.md

[shared/live-sources.md 다운로드](/skills/claude-api/shared/live-sources.md)

_바이너리 리소스_

### 공유/관리-에이전트-api-reference.md

[shared/managed-agents-api-reference.md 다운로드](/skills/claude-api/shared/managed-agents-api-reference.md)

_바이너리 리소스_

### 공유/관리-에이전트-클라이언트-patterns.md

[shared/managed-agents-client-patterns.md 다운로드](/skills/claude-api/shared/managed-agents-client-patterns.md)

_바이너리 리소스_

### 공유/관리-에이전트-core.md

[shared/managed-agents-core.md 다운로드](/skills/claude-api/shared/managed-agents-core.md)

_바이너리 리소스_

### 공유/관리-에이전트-environments.md

[shared/managed-agents-environments.md 다운로드](/skills/claude-api/shared/managed-agents-environments.md)

_바이너리 리소스_

### 공유/관리-에이전트-events.md

[shared/managed-agents-events.md 다운로드](/skills/claude-api/shared/managed-agents-events.md)

_바이너리 리소스_

### 공유/관리 에이전트-memory.md

[shared/managed-agents-memory.md 다운로드](/skills/claude-api/shared/managed-agents-memory.md)

_바이너리 리소스_

### 공유/관리-에이전트-multiagent.md

[shared/managed-agents-multiagent.md 다운로드](/skills/claude-api/shared/managed-agents-multiagent.md)

_바이너리 리소스_

### 공유/관리-에이전트-onboarding.md

[shared/managed-agents-onboarding.md 다운로드](/skills/claude-api/shared/managed-agents-onboarding.md)

_바이너리 리소스_

### 공유/관리-에이전트-outcomes.md

[shared/managed-agents-outcomes.md 다운로드](/skills/claude-api/shared/managed-agents-outcomes.md)

_바이너리 리소스_

### 공유/관리-에이전트-overview.md

[shared/managed-agents-overview.md 다운로드](/skills/claude-api/shared/managed-agents-overview.md)

_바이너리 리소스_

### 공유/관리-에이전트-tools.md

[shared/managed-agents-tools.md 다운로드](/skills/claude-api/shared/managed-agents-tools.md)

_바이너리 리소스_

### 공유/관리-에이전트-webhooks.md

[shared/managed-agents-webhooks.md 다운로드](/skills/claude-api/shared/managed-agents-webhooks.md)

```markdown
# Managed Agents — Webhooks

Anthropic can POST to your HTTPS endpoint when a Managed Agents resource changes state — an alternative to holding an SSE stream or polling. Payloads are **thin** (event type + resource IDs only); on receipt, fetch the resource for current state. Every delivery is HMAC-signed.

> **Direction matters.** This page covers *Anthropic → you* notifications about session/vault state. It does **not** cover *third-party → you* webhooks that *trigger* a session (e.g. a GitHub push handler that calls `sessions.create()`) — that's ordinary application code on your side with no Anthropic-specific wire format.

---

## Register an endpoint (Console only)

Console → **Manage → Webhooks**. There is no programmatic endpoint-management API yet. Secret rotation is supported from the same page.

| Field | Constraint |
|---|---|
| URL | HTTPS on port 443, publicly resolvable hostname |
| Event types | Subscribe per `data.type` — you only receive subscribed types (plus test events) |
| Signing secret | `whsec_`-prefixed, 32 bytes, **shown once at creation** — store it |

---

## Verify the signature

Every delivery is HMAC-signed. **Use the SDK's `client.beta.webhooks.unwrap()`** — it verifies the signature, rejects payloads more than ~5 minutes old, and returns the parsed event. It reads the `whsec_` secret from `ANTHROPIC_WEBHOOK_SIGNING_KEY`.

```python
수입 인류
플라스크 가져오기 플라스크에서 요청

client = anthropic.Anthropic() # env에서 ANTHROPIC_WEBHOOK_SIGNING_KEY를 읽습니다.
앱 = 플라스크(__name__)


@app.route("/webhook",method=["POST"])
데프 웹훅():
    시도해 보세요:
        이벤트 = client.beta.webhooks.unwrap(
            request.get_data(as_text=True),
            헤더=dict(request.headers),
        )
    예외:
        "잘못된 서명"을 반환합니다, 400

    if event.id in visible_event_ids: # 중복 제거 재시도 — ID는 전송별이 아니라 이벤트별입니다.
        "", 204 반환
    see_event_ids.add(event.id)

    event.data.type 일치:
        케이스 "session.status_idled":
            세션 = client.beta.sessions.retrieve(event.data.id)
            inform_user(세션)
        사례 "vault_credential.refresh_failed":
            Alert_oncall(event.data.id)

    "", 204 반환

{
  "유형": "이벤트",
  "id": "event_01ABC...",
  "created_at": "2026-03-18T14:05:22Z",
  "데이터": {
    "유형": "session.status_idled",
    "id": "session_01XYZ...",
    "organization_id": "8a3d2f1e-...",
    "workspace_id": "c7b0e4d9-..."
  }
}

### 공유/모델-migration.md

[shared/model-migration.md 다운로드](/skills/claude-api/shared/model-migration.md)

_바이너리 리소스_

### 공유/models.md

[shared/models.md 다운로드](/skills/claude-api/shared/models.md)

_바이너리 리소스_

### 공유/프롬프트-caching.md

[shared/prompt-caching.md 다운로드](/skills/claude-api/shared/prompt-caching.md)

_바이너리 리소스_

### 공유/도구 사용-concepts.md

[shared/tool-use-concepts.md 다운로드](/skills/claude-api/shared/tool-use-concepts.md)

_바이너리 리소스_

### 타이프스크립트/claude-api/README.md

[typescript/claude-api/README.md 다운로드](/skills/claude-api/typescript/claude-api/README.md)

_바이너리 리소스_

### 타이프스크립트/claude-api/batches.md

[typescript/claude-api/batches.md 다운로드](/skills/claude-api/typescript/claude-api/batches.md)

```markdown
# Message Batches API — TypeScript

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```typescript
"@anthropic-ai/sdk"에서 Anthropic을 가져옵니다.

const 클라이언트 = 새로운 Anthropic();

const messageBatch = client.messages.batches.create({를 기다립니다.
  요청: [
    {
      custom_id: "요청-1",
      매개변수: {
        모델: "claude-opus-4-7",
        최대 토큰: 16000,
        메시지: [
          { 역할: "사용자", 콘텐츠: "기후 변화 영향 요약" },
        ],
      },
    },
    {
      custom_id: "요청-2",
      매개변수: {
        모델: "claude-opus-4-7",
        최대 토큰: 16000,
        메시지: [
          { 역할: "사용자", 내용: "양자 컴퓨팅 기본 사항 설명" },
        ],
      },
    },
  ],
});

console.log(`Batch ID: ${messageBatch.id}`);
console.log(`Status: ${messageBatch.processing_status}`);

배치하자;
동안 (참) {
  배치 = client.messages.batches.retrieve(messageBatch.id)를 기다립니다.
  if (batch.processing_status === "종료됨") break;
  콘솔.로그(
   `Status: ${batch.processing_status}, processing: ${batch.request_counts.processing}`,
  );
  새로운 약속을 기다리십시오((resolve) => setTimeout(resolve, 60_000));
}

console.log("배치 완료!");
console.log(`Succeeded: ${batch.request_counts.succeeded}`);
console.log(`Errored: ${batch.request_counts.errored}`);

대기에 대한 (대기 client.messages.batches.results의 결과(
  messageBatch.id,
)) {
  스위치(result.result.type) {
    사례 "성공":
      콘솔.로그(
       `[${result.custom_id}] ${result.result.message.content[0].text.slice(0, 100)}`,
      );
      부서지다;
    "오류가 발생했습니다":
      if (result.result.error.type === "invalid_request") {
        console.log(`[${result.custom_id}] Validation error - fix and retry`);
      } 그렇지 않으면 {
        console.log(`[${result.custom_id}] Server error - safe to retry`);
      }
      부서지다;
    "만료됨"인 경우:
      console.log(`[${result.custom_id}] Expired - resubmit`);
      부서지다;
  }
}

const 취소됨 = client.messages.batches.cancel(messageBatch.id)를 기다립니다.
console.log(`Status: ${cancelled.processing_status}`); // "취소"

### 타이프스크립트/claude-api/files-api.md

[typescript/claude-api/files-api.md 다운로드](/skills/claude-api/typescript/claude-api/files-api.md)

```markdown
# Files API — TypeScript

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas: ["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```typescript
"@anthropic-ai/sdk"에서 Anthropic, { toFile }을 가져옵니다.
"fs"에서 fs를 가져옵니다.

const 클라이언트 = 새로운 Anthropic();

const 업로드됨 = client.beta.files.upload({
  파일: wait toFile(fs.createReadStream("report.pdf"), 정의되지 않음, {
    유형: "응용 프로그램/pdf",
  }),
  베타: ["files-api-2025-04-14"],
});

console.log(`File ID: ${uploaded.id}`);
console.log(`Size: ${uploaded.size_bytes} bytes`);

const 응답 = client.beta.messages.create({
  모델: "claude-opus-4-7",
  최대 토큰: 16000,
  메시지: [
    {
      역할: "사용자",
      내용: [
        { type: "text", text: "이 보고서의 주요 결과를 요약합니다." },
        {
          유형: "문서",
          소스: { 유형: "파일", file_id: 업로드된.id },
          title: "4분기 보고서",
          인용: { 활성화됨: true },
        },
      ],
    },
  ],
  베타: ["files-api-2025-04-14"],
});

console.log(response.content[0].text);

const 파일 = client.beta.files.list({
  베타: ["files-api-2025-04-14"],
});
for (files.data의 const f) {
  console.log(`${f.id}: ${f.filename} (${f.size_bytes} bytes)`);
}

client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w", {
  베타: ["files-api-2025-04-14"],
});

const 응답 = client.beta.files.download(
  "file_011CNha8iCJcU1wXNR6q4V8w",
  { 베타: ["files-api-2025-04-14"] },
);
const content = Buffer.from(응답을 기다리고 있습니다.arrayBuffer());
fs.promises.writeFile("output.txt", content)를 기다리십시오.

### typescript/claude-api/streaming.md

[typescript/claude-api/streaming.md 다운로드](/skills/claude-api/typescript/claude-api/streaming.md)

```markdown
# Streaming — TypeScript

## Quick Start

```typescript
const 스트림 = client.messages.stream({
  모델: "claude-opus-4-7",
  최대_토큰: 64000,
  메시지: [{ 역할: "사용자", 콘텐츠: "스토리 쓰기" }],
});

대기(스트림의 상수 이벤트) {
  만약 (
    event.type === "content_block_delta" &&
    event.delta.type === "text_delta"
  ) {
    process.stdout.write(event.delta.text);
  }
}

const 스트림 = client.messages.stream({
  모델: "claude-opus-4-7",
  최대_토큰: 64000,
  생각: { 유형: "적응형" },
  메시지: [{ 역할: "사용자", 내용: "이 문제 분석" }],
});

대기(스트림의 상수 이벤트) {
  스위치(event.type) {
    사례 "content_block_start":
      스위치(event.content_block.type) {
        "생각"의 경우:
          console.log("\n[생각중...]");
          부서지다;
        케이스 "텍스트":
          console.log("\n[응답:]");
          부서지다;
      }
      부서지다;
    사례 "content_block_delta":
      스위치(event.delta.type) {
        사례 "thinking_delta":
          process.stdout.write(event.delta.thinking);
          부서지다;
        사례 "text_delta":
          process.stdout.write(event.delta.text);
          부서지다;
      }
      부서지다;
  }
}

"@anthropic-ai/sdk"에서 Anthropic을 가져옵니다.
"@anthropic-ai/sdk/helpers/beta/zod"에서 { betaZodTool }을 가져옵니다.
"zod"에서 {z }를 가져옵니다.

const 클라이언트 = 새로운 Anthropic();

const getWeather = betaZodTool({
  이름: "get_weather",
  Description: "특정 위치의 현재 날씨 가져오기",
  inputSchema: z.object({
    위치: z.string().describe("도시 및 주(예: 캘리포니아 주 샌프란시스코"),
  }),
  실행: 비동기({ 위치 }) =>`72°F and sunny in ${location}`,
});

const 러너 = client.beta.messages.toolRunner({
  모델: "claude-opus-4-7",
  최대_토큰: 64000,
  도구: [getWeather],
  메시지: [
    { role: "user", content: "파리와 런던의 날씨는 어때?" },
  ],
  스트림: 사실,
});

// 외부 루프: 각 도구 실행기 반복
대기(실행자의 const messageStream) {
  // 내부 루프: 이 반복에 대한 스트림 이벤트
  대기(messageStream의 const 이벤트) {
    스위치(event.type) {
      사례 "content_block_delta":
        스위치(event.delta.type) {
          사례 "text_delta":
            process.stdout.write(event.delta.text);
            부서지다;
          "input_json_delta"의 경우:
            // 스트리밍되는 도구 입력
            휴식;
        }
        부서지다;
    }
  }
}

const 스트림 = client.messages.stream({
  모델: "claude-opus-4-7",
  최대_토큰: 64000,
  메시지: [{ 역할: "사용자", 콘텐츠: "안녕하세요" }],
});

대기(스트림의 상수 이벤트) {
  // 이벤트 처리...
}

const finalMessage = stream.finalMessage()를 기다립니다;
console.log(`Tokens used: ${finalMessage.usage.output_tokens}`);

이벤트: message_start
데이터: {"유형":"message_start","메시지":{"id":"msg_...","유형":"메시지",...}}

이벤트: content_block_start
데이터: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

이벤트: content_block_delta
데이터: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}

이벤트: content_block_stop
데이터: {"type":"content_block_stop","index":0}

이벤트: message_delta
데이터: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":12}}

이벤트: message_stop
데이터: {"type":"message_stop"}

### typescript/claude-api/tool-use.md

[typescript/claude-api/tool-use.md 다운로드](/skills/claude-api/typescript/claude-api/tool-use.md)

_바이너리 리소스_

### typescript/managed-agents/README.md

[typescript/managed-agents/README.md 다운로드](/skills/claude-api/typescript/managed-agents/README.md)

_바이너리 리소스_

## GitHub에서 보기

[GitHub에서 보기](https://github.com/anthropics/skills/tree/main/claude-api)