Claude Messages API

curl https://api.apimart.ai/v1/messages \
  -H "x-api-key: $API_KEY" \
  -H "anthropic-version: 2025-10-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, world"}
    ]
  }'

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.apimart.ai"
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, world"}
    ]
)

print(message.content)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.API_KEY,
  baseURL: 'https://api.apimart.ai'
});

const message = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, world' }
  ]
});

console.log(message.content);

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

func main() {
    url := "https://api.apimart.ai/v1/messages"

    payload := map[string]interface{}{
        "model": "claude-sonnet-4-6",
        "max_tokens": 1024,
        "messages": []map[string]string{
            {
                "role":    "user",
                "content": "Hello, world",
            },
        },
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("x-api-key", os.Getenv("API_KEY"))
    req.Header.Set("anthropic-version", "2025-10-01")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/messages";
        String apiKey = System.getenv("API_KEY");

        String payload = """
        {
          "model": "claude-sonnet-4-6",
          "max_tokens": 1024,
          "messages": [
            {
              "role": "user",
              "content": "Hello, world"
            }
          ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("x-api-key", apiKey)
            .header("anthropic-version", "2025-10-01")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/messages";
$apiKey = getenv('API_KEY');

$payload = [
    "model" => "claude-sonnet-4-6",
    "max_tokens" => 1024,
    "messages" => [
        [
            "role" => "user",
            "content" => "Hello, world"
        ]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "x-api-key: " . $apiKey,
    "anthropic-version: 2025-10-01",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/messages")
api_key = ENV['API_KEY']

payload = {
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "Hello, world"
    }
  ]
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = api_key
request["anthropic-version"] = "2025-10-01"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/messages")!
let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? ""

let payload: [String: Any] = [
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
        [
            "role": "user",
            "content": "Hello, world"
        ]
    ]
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
request.setValue("2025-10-01", forHTTPHeaderField: "anthropic-version")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    
    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/messages";
        var apiKey = Environment.GetEnvironmentVariable("API_KEY");

        var payload = @"{
            ""model"": ""claude-sonnet-4-6"",
            ""max_tokens"": 1024,
            ""messages"": [
                {
                    ""role"": ""user"",
                    ""content"": ""Hello, world""
                }
            ]
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("x-api-key", apiKey);
        client.DefaultRequestHeaders.Add("anthropic-version", "2025-10-01");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

#include <stdio.h>
#include <curl/curl.h>
#include <stdlib.h>

int main(void) {
    CURL *curl;
    CURLcode res;
    const char *api_key = getenv("API_KEY");

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://api.apimart.ai/v1/messages";
        const char *payload = "{"
            "\"model\":\"claude-sonnet-4-6\","
            "\"max_tokens\":1024,"
            "\"messages\":[{\"role\":\"user\",\"content\":\"Hello, world\"}]"
        "}";

        char auth_header[256];
        snprintf(auth_header, sizeof(auth_header), "x-api-key: %s", api_key);

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "anthropic-version: 2025-10-01");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://api.apimart.ai/v1/messages"];
        NSString *apiKey = [NSProcessInfo processInfo].environment[@"API_KEY"];
        
        NSDictionary *payload = @{
            @"model": @"claude-sonnet-4-6",
            @"max_tokens": @1024,
            @"messages": @[
                @{
                    @"role": @"user",
                    @"content": @"Hello, world"
                }
            ]
        };
        
        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];
        
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:apiKey forHTTPHeaderField:@"x-api-key"];
        [request setValue:@"2025-10-01" forHTTPHeaderField:@"anthropic-version"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];
        
        NSURLSessionDataTask *task = [[NSURLSession sharedSession] 
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data 
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];
        
        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}

(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://api.apimart.ai/v1/messages"
let api_key = Sys.getenv "API_KEY"

let payload = {|{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Hello, world"
    }
  ]
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "x-api-key" api_key
    |> fun h -> Header.add h "anthropic-version" "2025-10-01"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in
  
  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://api.apimart.ai/v1/messages');
  final apiKey = Platform.environment['API_KEY'];
  
  final payload = {
    'model': 'claude-sonnet-4-6',
    'max_tokens': 1024,
    'messages': [
      {
        'role': 'user',
        'content': 'Hello, world'
      }
    ]
  };
  
  final response = await http.post(
    url,
    headers: {
      'x-api-key': apiKey!,
      'anthropic-version': '2025-10-01',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );
  
  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://api.apimart.ai/v1/messages"
api_key <- Sys.getenv("API_KEY")

payload <- list(
  model = "claude-sonnet-4-6",
  max_tokens = 1024,
  messages = list(
    list(
      role = "user",
      content = "Hello, world"
    )
  )
)

response <- POST(
  url,
  add_headers(
    `x-api-key` = api_key,
    `anthropic-version` = "2025-10-01",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "model": "claude-sonnet-4-6",
  "id": "msg_011CdfeHuC728oxqaLrRNbcB",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello! I'm Claude. Nice to meet you."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "stop_details": null,
  "usage": {
    "input_tokens": 12,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation": {
      "ephemeral_5m_input_tokens": 0,
      "ephemeral_1h_input_tokens": 0
    },
    "output_tokens": 18,
    "service_tier": "standard",
    "inference_geo": "global"
  }
}

{
  "error": {
    "code": "model_not_found",
    "message": "model not found (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Invalid API key (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Insufficient balance (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Too many requests (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Internal server error (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

POST

messages

curl https://api.apimart.ai/v1/messages \
  -H "x-api-key: $API_KEY" \
  -H "anthropic-version: 2025-10-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, world"}
    ]
  }'

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.apimart.ai"
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, world"}
    ]
)

print(message.content)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.API_KEY,
  baseURL: 'https://api.apimart.ai'
});

const message = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, world' }
  ]
});

console.log(message.content);

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

func main() {
    url := "https://api.apimart.ai/v1/messages"

    payload := map[string]interface{}{
        "model": "claude-sonnet-4-6",
        "max_tokens": 1024,
        "messages": []map[string]string{
            {
                "role":    "user",
                "content": "Hello, world",
            },
        },
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("x-api-key", os.Getenv("API_KEY"))
    req.Header.Set("anthropic-version", "2025-10-01")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/messages";
        String apiKey = System.getenv("API_KEY");

        String payload = """
        {
          "model": "claude-sonnet-4-6",
          "max_tokens": 1024,
          "messages": [
            {
              "role": "user",
              "content": "Hello, world"
            }
          ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("x-api-key", apiKey)
            .header("anthropic-version", "2025-10-01")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/messages";
$apiKey = getenv('API_KEY');

$payload = [
    "model" => "claude-sonnet-4-6",
    "max_tokens" => 1024,
    "messages" => [
        [
            "role" => "user",
            "content" => "Hello, world"
        ]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "x-api-key: " . $apiKey,
    "anthropic-version: 2025-10-01",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/messages")
api_key = ENV['API_KEY']

payload = {
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "Hello, world"
    }
  ]
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = api_key
request["anthropic-version"] = "2025-10-01"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/messages")!
let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? ""

let payload: [String: Any] = [
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
        [
            "role": "user",
            "content": "Hello, world"
        ]
    ]
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
request.setValue("2025-10-01", forHTTPHeaderField: "anthropic-version")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    
    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/messages";
        var apiKey = Environment.GetEnvironmentVariable("API_KEY");

        var payload = @"{
            ""model"": ""claude-sonnet-4-6"",
            ""max_tokens"": 1024,
            ""messages"": [
                {
                    ""role"": ""user"",
                    ""content"": ""Hello, world""
                }
            ]
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("x-api-key", apiKey);
        client.DefaultRequestHeaders.Add("anthropic-version", "2025-10-01");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

#include <stdio.h>
#include <curl/curl.h>
#include <stdlib.h>

int main(void) {
    CURL *curl;
    CURLcode res;
    const char *api_key = getenv("API_KEY");

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://api.apimart.ai/v1/messages";
        const char *payload = "{"
            "\"model\":\"claude-sonnet-4-6\","
            "\"max_tokens\":1024,"
            "\"messages\":[{\"role\":\"user\",\"content\":\"Hello, world\"}]"
        "}";

        char auth_header[256];
        snprintf(auth_header, sizeof(auth_header), "x-api-key: %s", api_key);

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "anthropic-version: 2025-10-01");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://api.apimart.ai/v1/messages"];
        NSString *apiKey = [NSProcessInfo processInfo].environment[@"API_KEY"];
        
        NSDictionary *payload = @{
            @"model": @"claude-sonnet-4-6",
            @"max_tokens": @1024,
            @"messages": @[
                @{
                    @"role": @"user",
                    @"content": @"Hello, world"
                }
            ]
        };
        
        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];
        
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:apiKey forHTTPHeaderField:@"x-api-key"];
        [request setValue:@"2025-10-01" forHTTPHeaderField:@"anthropic-version"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];
        
        NSURLSessionDataTask *task = [[NSURLSession sharedSession] 
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data 
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];
        
        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}

(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://api.apimart.ai/v1/messages"
let api_key = Sys.getenv "API_KEY"

let payload = {|{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Hello, world"
    }
  ]
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "x-api-key" api_key
    |> fun h -> Header.add h "anthropic-version" "2025-10-01"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in
  
  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://api.apimart.ai/v1/messages');
  final apiKey = Platform.environment['API_KEY'];
  
  final payload = {
    'model': 'claude-sonnet-4-6',
    'max_tokens': 1024,
    'messages': [
      {
        'role': 'user',
        'content': 'Hello, world'
      }
    ]
  };
  
  final response = await http.post(
    url,
    headers: {
      'x-api-key': apiKey!,
      'anthropic-version': '2025-10-01',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );
  
  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://api.apimart.ai/v1/messages"
api_key <- Sys.getenv("API_KEY")

payload <- list(
  model = "claude-sonnet-4-6",
  max_tokens = 1024,
  messages = list(
    list(
      role = "user",
      content = "Hello, world"
    )
  )
)

response <- POST(
  url,
  add_headers(
    `x-api-key` = api_key,
    `anthropic-version` = "2025-10-01",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "model": "claude-sonnet-4-6",
  "id": "msg_011CdfeHuC728oxqaLrRNbcB",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello! I'm Claude. Nice to meet you."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "stop_details": null,
  "usage": {
    "input_tokens": 12,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation": {
      "ephemeral_5m_input_tokens": 0,
      "ephemeral_1h_input_tokens": 0
    },
    "output_tokens": 18,
    "service_tier": "standard",
    "inference_geo": "global"
  }
}

{
  "error": {
    "code": "model_not_found",
    "message": "model not found (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Invalid API key (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Insufficient balance (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Too many requests (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Internal server error (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

Jangan mencampur kedua API: /v1/* adalah API inferensi (dokumen ini — diteruskan apa adanya dari upstream, tanpa wrapper); /api/* adalah API manajemen (saldo/log, dll., respons {success, message, data}). Jika Anda melihat di suatu tempat bahwa /v1/messages mengembalikan {code, data}, dokumen ini yang berlaku.

curl https://api.apimart.ai/v1/messages \
  -H "x-api-key: $API_KEY" \
  -H "anthropic-version: 2025-10-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
      {"role": "user", "content": "Hello, world"}
    ]
  }'

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.apimart.ai"
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, world"}
    ]
)

print(message.content)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.API_KEY,
  baseURL: 'https://api.apimart.ai'
});

const message = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Hello, world' }
  ]
});

console.log(message.content);

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "os"
)

func main() {
    url := "https://api.apimart.ai/v1/messages"

    payload := map[string]interface{}{
        "model": "claude-sonnet-4-6",
        "max_tokens": 1024,
        "messages": []map[string]string{
            {
                "role":    "user",
                "content": "Hello, world",
            },
        },
    }

    jsonData, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("x-api-key", os.Getenv("API_KEY"))
    req.Header.Set("anthropic-version", "2025-10-01")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class Main {
    public static void main(String[] args) throws Exception {
        String url = "https://api.apimart.ai/v1/messages";
        String apiKey = System.getenv("API_KEY");

        String payload = """
        {
          "model": "claude-sonnet-4-6",
          "max_tokens": 1024,
          "messages": [
            {
              "role": "user",
              "content": "Hello, world"
            }
          ]
        }
        """;

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("x-api-key", apiKey)
            .header("anthropic-version", "2025-10-01")
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

<?php

$url = "https://api.apimart.ai/v1/messages";
$apiKey = getenv('API_KEY');

$payload = [
    "model" => "claude-sonnet-4-6",
    "max_tokens" => 1024,
    "messages" => [
        [
            "role" => "user",
            "content" => "Hello, world"
        ]
    ]
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "x-api-key: " . $apiKey,
    "anthropic-version: 2025-10-01",
    "Content-Type: application/json"
]);

$response = curl_exec($ch);
curl_close($ch);

echo $response;
?>

require 'net/http'
require 'json'
require 'uri'

url = URI("https://api.apimart.ai/v1/messages")
api_key = ENV['API_KEY']

payload = {
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: "Hello, world"
    }
  ]
}

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = api_key
request["anthropic-version"] = "2025-10-01"
request["Content-Type"] = "application/json"
request.body = payload.to_json

response = http.request(request)
puts response.body

import Foundation

let url = URL(string: "https://api.apimart.ai/v1/messages")!
let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? ""

let payload: [String: Any] = [
    "model": "claude-sonnet-4-6",
    "max_tokens": 1024,
    "messages": [
        [
            "role": "user",
            "content": "Hello, world"
        ]
    ]
]

var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
request.setValue("2025-10-01", forHTTPHeaderField: "anthropic-version")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
request.httpBody = try? JSONSerialization.data(withJSONObject: payload)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    
    if let data = data, let responseString = String(data: data, encoding: .utf8) {
        print(responseString)
    }
}

task.resume()

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var url = "https://api.apimart.ai/v1/messages";
        var apiKey = Environment.GetEnvironmentVariable("API_KEY");

        var payload = @"{
            ""model"": ""claude-sonnet-4-6"",
            ""max_tokens"": 1024,
            ""messages"": [
                {
                    ""role"": ""user"",
                    ""content"": ""Hello, world""
                }
            ]
        }";

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("x-api-key", apiKey);
        client.DefaultRequestHeaders.Add("anthropic-version", "2025-10-01");

        var content = new StringContent(payload, Encoding.UTF8, "application/json");
        var response = await client.PostAsync(url, content);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
    }
}

#include <stdio.h>
#include <curl/curl.h>
#include <stdlib.h>

int main(void) {
    CURL *curl;
    CURLcode res;
    const char *api_key = getenv("API_KEY");

    curl_global_init(CURL_GLOBAL_DEFAULT);
    curl = curl_easy_init();

    if(curl) {
        const char *url = "https://api.apimart.ai/v1/messages";
        const char *payload = "{"
            "\"model\":\"claude-sonnet-4-6\","
            "\"max_tokens\":1024,"
            "\"messages\":[{\"role\":\"user\",\"content\":\"Hello, world\"}]"
        "}";

        char auth_header[256];
        snprintf(auth_header, sizeof(auth_header), "x-api-key: %s", api_key);

        struct curl_slist *headers = NULL;
        headers = curl_slist_append(headers, auth_header);
        headers = curl_slist_append(headers, "anthropic-version: 2025-10-01");
        headers = curl_slist_append(headers, "Content-Type: application/json");

        curl_easy_setopt(curl, CURLOPT_URL, url);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, payload);
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        res = curl_easy_perform(curl);

        if(res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n",
                    curl_easy_strerror(res));
        }

        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
    }

    curl_global_cleanup();
    return 0;
}

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        NSURL *url = [NSURL URLWithString:@"https://api.apimart.ai/v1/messages"];
        NSString *apiKey = [NSProcessInfo processInfo].environment[@"API_KEY"];
        
        NSDictionary *payload = @{
            @"model": @"claude-sonnet-4-6",
            @"max_tokens": @1024,
            @"messages": @[
                @{
                    @"role": @"user",
                    @"content": @"Hello, world"
                }
            ]
        };
        
        NSError *error;
        NSData *jsonData = [NSJSONSerialization dataWithJSONObject:payload
                                                          options:0
                                                            error:&error];
        
        NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url];
        [request setHTTPMethod:@"POST"];
        [request setValue:apiKey forHTTPHeaderField:@"x-api-key"];
        [request setValue:@"2025-10-01" forHTTPHeaderField:@"anthropic-version"];
        [request setValue:@"application/json" forHTTPHeaderField:@"Content-Type"];
        [request setHTTPBody:jsonData];
        
        NSURLSessionDataTask *task = [[NSURLSession sharedSession] 
            dataTaskWithRequest:request
            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                if (error) {
                    NSLog(@"Error: %@", error);
                    return;
                }
                NSString *result = [[NSString alloc] initWithData:data 
                                                        encoding:NSUTF8StringEncoding];
                NSLog(@"%@", result);
            }];
        
        [task resume];
        [[NSRunLoop mainRunLoop] run];
    }
    return 0;
}

(* Requires cohttp and yojson libraries *)
open Lwt
open Cohttp
open Cohttp_lwt_unix

let url = "https://api.apimart.ai/v1/messages"
let api_key = Sys.getenv "API_KEY"

let payload = {|{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {
      "role": "user",
      "content": "Hello, world"
    }
  ]
}|}

let () =
  let headers = Header.init ()
    |> fun h -> Header.add h "x-api-key" api_key
    |> fun h -> Header.add h "anthropic-version" "2025-10-01"
    |> fun h -> Header.add h "Content-Type" "application/json"
  in
  let body = Cohttp_lwt.Body.of_string payload in
  
  let response = Client.post ~headers ~body (Uri.of_string url) >>= fun (resp, body) ->
    body |> Cohttp_lwt.Body.to_string >|= fun body_str ->
    print_endline body_str
  in
  Lwt_main.run response

import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;

void main() async {
  final url = Uri.parse('https://api.apimart.ai/v1/messages');
  final apiKey = Platform.environment['API_KEY'];
  
  final payload = {
    'model': 'claude-sonnet-4-6',
    'max_tokens': 1024,
    'messages': [
      {
        'role': 'user',
        'content': 'Hello, world'
      }
    ]
  };
  
  final response = await http.post(
    url,
    headers: {
      'x-api-key': apiKey!,
      'anthropic-version': '2025-10-01',
      'Content-Type': 'application/json',
    },
    body: jsonEncode(payload),
  );
  
  print(response.body);
}

library(httr)
library(jsonlite)

url <- "https://api.apimart.ai/v1/messages"
api_key <- Sys.getenv("API_KEY")

payload <- list(
  model = "claude-sonnet-4-6",
  max_tokens = 1024,
  messages = list(
    list(
      role = "user",
      content = "Hello, world"
    )
  )
)

response <- POST(
  url,
  add_headers(
    `x-api-key` = api_key,
    `anthropic-version` = "2025-10-01",
    `Content-Type` = "application/json"
  ),
  body = toJSON(payload, auto_unbox = TRUE),
  encode = "raw"
)

cat(content(response, "text"))

{
  "model": "claude-sonnet-4-6",
  "id": "msg_011CdfeHuC728oxqaLrRNbcB",
  "type": "message",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "Hello! I'm Claude. Nice to meet you."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "stop_details": null,
  "usage": {
    "input_tokens": 12,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation": {
      "ephemeral_5m_input_tokens": 0,
      "ephemeral_1h_input_tokens": 0
    },
    "output_tokens": 18,
    "service_tier": "standard",
    "inference_geo": "global"
  }
}

{
  "error": {
    "code": "model_not_found",
    "message": "model not found (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Invalid API key (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Insufficient balance (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Too many requests (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

{
  "error": {
    "code": "",
    "message": "Internal server error (request id: 20260803181903172761862QzohKPXF)",
    "param": "",
    "type": "apimart_error"
  }
}

Otorisasi

Autentikasi mendukung dua metode, pilih salah satu:

string

Header autentikasi gaya AnthropicKunjungi Halaman Manajemen API Key untuk mendapatkan API Key Anda

x-api-key: YOUR_API_KEY

string

Autentikasi Bearer Token (alternatif untuk x-api-key)

Authorization: Bearer YOUR_API_KEY

string

Nomor versi API (opsional; request tetap berfungsi tanpa header ini)Untuk memudahkan migrasi ke endpoint resmi Anthropic di kemudian hari, disarankan untuk tetap menyertakannya:Contoh: 2025-10-01

Body

string

default:"claude-sonnet-4-6"

wajib

Model name

claude-opus-4-8 - Claude Opus 4.8 flagship model
claude-opus-4-7 - Claude Opus 4.7 flagship model
claude-opus-4-6 - Claude Opus 4.6 flagship model
claude-sonnet-4-6 - Claude Sonnet 4.6 balanced version
claude-opus-4-5-20251101 - Claude Opus 4.5 model

array

wajib

Daftar pesanArray pesan yang digunakan model untuk menghasilkan respons berikutnya. Setiap pesan berisi field role dan content.💡 Pengisian cepat (area Try it):

Klik ”+ Add an item” untuk menambahkan pesan
Input role: user (pesan pengguna) atau assistant (respons AI, untuk multi-giliran)
Input content: teks pesan Anda

Tampilkan Detail field

string

default:"user"

wajib

Jenis roleOpsi: user (pesan pengguna), assistant (respons AI, untuk percakapan multi-giliran dan pengisian awal)Catatan: Claude API menggunakan parameter system terpisah untuk prompt sistem, bukan di dalam messages

string

wajib

Konten pesanKonten teks of the message

Pesan pengguna tunggal:

[{"role": "user", "content": "Hello, Claude"}]

Percakapan multi-giliran:

[
  {"role": "user", "content": "Hello there."},
  {"role": "assistant", "content": "Hi, I'm Claude. How can I help you?"},
  {"role": "user", "content": "Can you explain LLMs in plain English?"}
]

Respons assistant yang sudah diisi sebelumnya:

[
  {"role": "user", "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"},
  {"role": "assistant", "content": "The best answer is ("}
]

integer

wajib

Token maksimum yang akan dibuat (wajib, selaras dengan API resmi Anthropic)Jumlah maksimum token yang akan dibuat sebelum berhenti. Model dapat berhenti sebelum mencapai batas ini.Setiap model memiliki nilai maksimum yang berbeda; lihat dokumentasi model. Minimum: 1

object

Konfigurasi extended thinkingSetelah diaktifkan, respons content dapat berisi blok thinking. Disarankan menggunakan nama model standar + parameter ini, bukan mengandalkan alias model -thinking di sisi platform, agar migrasi ke endpoint resmi tanpa mengubah kode lebih mudah.Untuk percakapan multi-giliran yang perlu mengembalikan blok thinking, Anda harus mengembalikan signature apa adanya; jika tidak, upstream akan menolak.

string | array

Prompt sistemPrompt sistems set Claude’s role, personality, goals, and instructions.Format string:

{
  "system": "You are a professional Python programming tutor"
}

Format terstruktur:

{
  "system": [
    {
      "type": "text",
      "text": "You are a professional Python programming tutor"
    }
  ]
}

number

Parameter temperature, rentang 0-1Mengontrol keacakan output:

Nilai rendah (misalnya 0,2): lebih deterministik dan konservatif
Nilai tinggi (misalnya 0,8): lebih acak dan kreatif

Default: 1.0

number

Parameter nucleus sampling, rentang 0-1Menggunakan nucleus sampling. Sebaiknya gunakan salah satu dari temperature atau top_p, bukan keduanya.Default: 1.0

integer

Sampling Top-KHanya sampling dari K opsi teratas, sehingga menghapus respons probabilitas rendah di “long tail”.Disarankan hanya untuk kasus penggunaan lanjutan.

boolean

Aktifkan streamingJika true, menggunakan Server-Sent Events (SSE) untuk mengalirkan respons.Default: false

array

Urutan penghentiUrutan teks khusus yang membuat model berhenti menghasilkan output.Maksimum 4 urutan.Contoh: ["\n\nHuman:", "\n\nAssistant:"]

object

MetadataObjek metadata untuk request.Mencakup:

user_id: Pengidentifikasi pengguna

array

Definisi toolDaftar tool yang dapat digunakan model untuk menyelesaikan tugas.Contoh function tool:

{
  "tools": [
    {
      "name": "get_weather",
      "description": "Get the current weather in a given location",
      "input_schema": {
        "type": "object",
        "properties": {
          "location": {
            "type": "string",
            "description": "The city and state, e.g. San Francisco, CA"
          },
          "unit": {
            "type": "string",
            "enum": ["celsius", "fahrenheit"],
            "description": "Temperature unit"
          }
        },
        "required": ["location"]
      }
    }
  ]
}

Jenis tool yang didukung:

Tool fungsi kustom
Tool penggunaan komputer (computer_20241022)
Tool editor teks (text_editor_20241022)
Tool Bash (bash_20241022)

object

Strategi pemilihan toolMengontrol cara model menggunakan tool:

{"type": "auto"}: Menentukan otomatis (default)
{"type": "any"}: Harus menggunakan tool
{"type": "tool", "name": "tool_name"}: Gunakan tool tertentu

Respons

string

Pengidentifikasi pesan unikContoh: "msg_013Zva2CMHLNnXjNJJKqJ2EF"

string

Jenis objekSelalu "message"

string

RoleSelalu "assistant"

array

Array blok kontencontent membedakan jenis blok lewat type. Satu respons dapat berisi beberapa blok (misalnya thinking + text saat thinking diaktifkan).Blok text:

{ "type": "text", "text": "OK" }

Blok tool_use:

{
  "type": "tool_use",
  "id": "toolu_01QgsazxKXSfQVj9Q1XxjYXo",
  "name": "get_weather",
  "input": { "city": "Beijing" },
  "caller": { "type": "direct" }
}

caller adalah field baru dari upstream, belum tercantum di dokumentasi resmi; abaikan saat parsing.

Blok thinking (muncul saat body request menyertakan parameter thinking):

{
  "type": "thinking",
  "thinking": "推理过程文本...",
  "signature": "<约 500+ 字符的签名串>"
}

Pada percakapan multi-giliran, jika Anda mengembalikan blok thinking, harus mengembalikan signature apa adanya; jika tidak, upstream akan menolak.

Jangan mengasumsikan content[0] adalah teks. Saat thinking diaktifkan, content[0] bisa berupa blok thinking. Iterasikan dan saring:

text = "".join(b.text for b in resp.content if b.type == "text")

string

Model yang menangani requestContoh: "claude-sonnet-4-6"

string

Alasan berhentiNilai yang mungkin:

end_turn: Selesai secara alami
max_tokens: Mencapai token maksimum
stop_sequence: Mengenai urutan penghenti
tool_use: Memanggil tool

string | null

Urutan penghenti yang terpicuUrutan penghenti yang dihasilkan, jika ada; jika tidak, bernilai null

object | null

Field Anthropic yang lebih baru; null untuk request biasa

object

Statistik penggunaan token (struktur lengkap non-stream)

Tampilkan Properti

integer

Jumlah token input

integer

Jumlah token output (sudah mencakup thinking tokens; jangan dijumlahkan ulang untuk penagihan)

integer

Token penulisan cache

integer

Token hit cache

object

{ ephemeral_5m_input_tokens, ephemeral_1h_input_tokens }

string

Misalnya "standard"

string

Misalnya "global"

object

Dapat muncul saat thinking diaktifkan: { thinking_tokens: int }

Contoh Penggunaan

Percakapan Dasar

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.apimart.ai"
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain quantum computing basics"}
    ]
)

print(message.content[0].text)

Percakapan Multi-Giliran

messages = [
    {"role": "user", "content": "What is machine learning?"},
    {"role": "assistant", "content": "Machine learning is a branch of AI..."},
    {"role": "user", "content": "Can you give a practical example?"}
]

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=messages
)

Menggunakan Prompt Sistem

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="You are a senior Python developer expert in code review and optimization.",
    messages=[
        {"role": "user", "content": "How to optimize this code?\n\n[code]"}
    ]
)

Respons Streaming

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Write a short essay about AI"}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Penggunaan Tool

tools = [
    {
        "name": "get_stock_price",
        "description": "Get real-time stock price",
        "input_schema": {
            "type": "object",
            "properties": {
                "ticker": {
                    "type": "string",
                    "description": "Stock ticker symbol, e.g., AAPL"
                }
            },
            "required": ["ticker"]
        }
    }
]

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=tools,
    messages=[
        {"role": "user", "content": "What's Tesla's stock price?"}
    ]
)

# Handle tool calls
if message.stop_reason == "tool_use":
    tool_use = next(block for block in message.content if block.type == "tool_use")
    print(f"Calling tool: {tool_use.name}")
    print(f"Arguments: {tool_use.input}")

Pemahaman Vision

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://example.com/image.jpg"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe this image"
                }
            ]
        }
    ]
)

Gambar Base64

import base64

with open("image.jpg", "rb") as image_file:
    image_data = base64.b64encode(image_file.read()).decode("utf-8")

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": image_data
                    }
                },
                {
                    "type": "text",
                    "text": "Analyze this image"
                }
            ]
        }
    ]
)

Praktik Terbaik

1. Rekayasa Prompt

Definisi role yang jelas:

system = """You are an experienced data scientist specializing in:
- Statistical analysis and data visualization
- Machine learning model development
- Python and R programming
Provide professional, accurate advice."""

Output terstruktur:

message = "Please return the analysis results in JSON format with summary, key_findings, and recommendations fields."

2. Penanganan Error

from anthropic import APIError, RateLimitError

try:
    message = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello"}]
    )
except RateLimitError:
    print("Rate limit exceeded, please retry later")
except APIError as e:
    print(f"API error: {e}")

3. Optimasi Token

# Use shorter prompts
messages = [
    {"role": "user", "content": "Summarize key points:\n\n[long text]"}
]

# Limit output length
message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=500,  # Limit output
    messages=messages
)

4. Pengisian Awal Respons

# Guide model to specific format
messages = [
    {"role": "user", "content": "List 5 Python best practices"},
    {"role": "assistant", "content": "Here are 5 Python best practices:\n\n1."}
]

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=messages
)

Penanganan Respons Streaming

Streaming Python

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_API_KEY",
    base_url="https://api.apimart.ai"
)

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Write a Python decorator example"}
    ]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Streaming JavaScript

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: process.env.API_KEY,
  baseURL: 'https://api.apimart.ai'
});

const stream = await client.messages.stream({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Write a React component example' }
  ]
});

for await (const chunk of stream) {
  if (chunk.type === 'content_block_delta' && 
      chunk.delta.type === 'text_delta') {
    process.stdout.write(chunk.delta.text);
  }
}

Perbedaan platform dan catatan integrasi

Respons tanpa wrapper

Saat berhasil, POST /v1/messages langsung mengembalikan objek message Anthropic, tanpa wrapper {code, data}. Dengan demikian SDK resmi, Claude Code, Cline, dll. tetap kompatibel 1:1.

Format error (satu-satunya perbedaan substansial dibanding resmi)

{
  "error": {
    "code": "model_not_found",
    "message": "... (request id: ...)",
    "param": "",
    "type": "apimart_error"
  }
}

Dibanding API resmi Anthropic: level root tidak memiliki "type": "error"; error.type selalu apimart_error, bukan tipe semantik seperti invalid_request_error. Saran integrasi: jangan mengandalkan error.type untuk cabang retry; gunakan kode status HTTP + error.code:

Kode status	Arti	Tindakan yang disarankan
400	Parameter request salah	Jangan retry; periksa body request
401	Key tidak valid	Jangan retry
402	Saldo tidak cukup	Jangan retry; minta top-up
429	Rate limit	Retry setelah backoff
5xx	Anomali upstream/gateway	Retry dengan backoff eksponensial

Untuk dukungan, sediakan: request id di akhir error.message, serta header respons x-oneapi-request-id.

Streaming SSE

Tambahkan "stream": true pada request. Urutan event sama dengan resmi: message_start → content_block_start → ping → content_block_delta (berulang) → content_block_stop → message_delta → message_stop ⚠️ Struktur usage berbeda antara stream dan non-stream: message_delta.usage biasanya hanya memiliki 4 field token, tanpa cache_creation, service_tier, inference_geo. Parse secara terpisah atau anggap semua field opsional.

Endpoint belum diimplementasikan

POST /v1/messages/count_tokens belum diimplementasikan dan mengembalikan 404. Panggilan client.messages.count_tokens() pada SDK resmi akan gagal. Untuk memperkirakan token, hitung di lokal atau baca usage.input_tokens pada respons.

Harus mengabaikan field yang tidak dikenal

API ini meneruskan upstream apa adanya; Anthropic dapat menambahkan field kapan saja (mis. stop_details, inference_geo, caller, output_tokens_details). Jangan aktifkan skema ketat:

Go: jangan gunakan DisallowUnknownFields()
Pydantic: jangan gunakan extra="forbid"
TypeScript / Zod: gunakan .passthrough() bukan .strict()

Saran penamaan model

Model sejenis dengan sufiks -thinking adalah alias ekstensi platform. Disarankan menggunakan nama model standar tanpa sufiks + parameter thinking di body request, agar migrasi ke endpoint resmi lebih mudah. Field body request lainnya selaras dengan resmi: model, messages, max_tokens (wajib), system, temperature, top_p, top_k, stop_sequences, stream, tools, tool_choice, thinking, metadata. Semantik mengikuti Anthropic Messages API.

Catatan Penting

Keamanan API Key:
- Simpan API key dalam variabel lingkungan
- Jangan pernah menulis key secara hardcode di kode sumber
- Rotasi key secara berkala
Rate Limiting:
- Perhatikan batas rate API
- Terapkan mekanisme retry (berdasarkan kode status HTTP)
- Gunakan backoff eksponensial
Manajemen Token:
- Pantau penggunaan token (baca usage)
- Optimalkan panjang prompt
- Gunakan nilai max_tokens yang sesuai
- Saat thinking diaktifkan, output_tokens sudah mencakup thinking; jangan menagih dua kali
Pemilihan Model:
- Opus: tugas kompleks yang membutuhkan penalaran mendalam
- Sonnet: performa dan biaya yang seimbang
- Haiku: respons cepat untuk tugas sederhana
Parsing konten:
- Iterasikan content untuk blok type == "text"; jangan hardcode content[0].text
- Jika model mengembalikan JSON yang dibungkus blok kode Markdown, itu adalah keluaran model bukan wrapper API (lihat FAQ di bawah)
Penyaringan Konten:
- Validasi input pengguna
- Saring informasi sensitif
- Terapkan moderasi konten

FAQ

Text di `content` berupa blok kode ```json ... ``` — bagaimana menghapusnya?

Ini bukan masalah struktur API. Field text berisi konten mentah yang dihasilkan model: jika model menyimpulkan Anda ingin JSON, biasanya membungkusnya dalam blok kode Markdown. API tidak akan (dan tidak seharusnya) menulis ulang keluaran model. Untuk mendapatkan data terstruktur yang bersih, ada tiga pendekatan yang benar (dari yang paling andal ke yang kurang andal):

Gunakan tools untuk memaksa output terstruktur — paling andal; field input sudah berupa objek yang ter-parse:

{
  "tools": [{
    "name": "emit_result",
    "input_schema": {
      "type": "object",
      "properties": { "answer": { "type": "string" } }
    }
  }],
  "tool_choice": { "type": "tool", "name": "emit_result" }
}

Prefill pesan assistant, agar model melanjutkan dari {:

{
  "messages": [
    { "role": "user", "content": "..." },
    { "role": "assistant", "content": "{" }
  ]
}

Minta secara eksplisit di system prompt: «hanya keluarkan JSON, tanpa blok kode Markdown».

Tidak disarankan mengupas code fence dengan regex — jika model sesekali tidak menambahkan pagar, parsing akan gagal.

Ikhtisar

Model

Seri Teks

Seri Gambar

Seri Video

Seri Audio

Seri Moderasi

Manajemen Unggahan

Manajemen Tugas

Manajemen Akun

Claude Messages API

Otorisasi

Body

Respons

Contoh Penggunaan

Percakapan Dasar

Percakapan Multi-Giliran

Menggunakan Prompt Sistem

Respons Streaming

Penggunaan Tool

Pemahaman Vision

Gambar Base64

Praktik Terbaik

1. Rekayasa Prompt

2. Penanganan Error

3. Optimasi Token

4. Pengisian Awal Respons

Penanganan Respons Streaming

Streaming Python

Streaming JavaScript

Perbedaan platform dan catatan integrasi

Respons tanpa wrapper

Format error (satu-satunya perbedaan substansial dibanding resmi)

Streaming SSE

Endpoint belum diimplementasikan

Harus mengabaikan field yang tidak dikenal

Saran penamaan model

Catatan Penting

FAQ

Text di `content` berupa blok kode ```json ... ``` — bagaimana menghapusnya?

​Otorisasi

​Body

​Respons

​Contoh Penggunaan

​Percakapan Dasar

​Percakapan Multi-Giliran

​Menggunakan Prompt Sistem

​Respons Streaming

​Penggunaan Tool

​Pemahaman Vision

​Gambar Base64

​Praktik Terbaik

​1. Rekayasa Prompt

​2. Penanganan Error

​3. Optimasi Token

​4. Pengisian Awal Respons

​Penanganan Respons Streaming

​Streaming Python

​Streaming JavaScript

​Perbedaan platform dan catatan integrasi

​Respons tanpa wrapper

​Format error (satu-satunya perbedaan substansial dibanding resmi)

​Streaming SSE

​Endpoint belum diimplementasikan

​Harus mengabaikan field yang tidak dikenal

​Saran penamaan model

​Catatan Penting

​FAQ

​Text di content berupa blok kode ```json ... ``` — bagaimana menghapusnya?

Otorisasi

Body

Respons

Contoh Penggunaan

Percakapan Dasar

Percakapan Multi-Giliran

Menggunakan Prompt Sistem

Respons Streaming

Penggunaan Tool

Pemahaman Vision

Gambar Base64

Praktik Terbaik

1. Rekayasa Prompt

2. Penanganan Error

3. Optimasi Token

4. Pengisian Awal Respons

Penanganan Respons Streaming

Streaming Python

Streaming JavaScript

Perbedaan platform dan catatan integrasi

Respons tanpa wrapper

Format error (satu-satunya perbedaan substansial dibanding resmi)

Streaming SSE

Endpoint belum diimplementasikan

Harus mengabaikan field yang tidak dikenal

Saran penamaan model

Catatan Penting

FAQ

Text di `content` berupa blok kode ```json ... ``` — bagaimana menghapusnya?