API Claude 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"
  }
}

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"
  }
}

Não misture as duas APIs: /v1/* é a API de inferência (este documento — retransmissão do upstream sem envelope); /api/* é a API de gestão (saldo/logs, etc., resposta {success, message, data}). Se vir em algum lugar que /v1/messages devolve {code, data}, este documento prevalece.

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"
  }
}

Autorizações

A autenticação suporta dois métodos, escolha um:

string

Cabeçalho de autenticação no estilo AnthropicAcesse a página de gerenciamento de chaves de API para obter sua chave de API

x-api-key: YOUR_API_KEY

string

Autenticação Bearer Token (alternativa a x-api-key)

Authorization: Bearer YOUR_API_KEY

string

Número da versão da API (opcional; a requisição funciona também sem ele)Para facilitar a migração futura para os endpoints oficiais da Anthropic, recomenda-se incluí-lo:Exemplo: 2025-10-01

Body

string

padrão:"claude-sonnet-4-6"

obrigatório

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

obrigatório

Lista de mensagensArray de mensagens para o modelo gerar a próxima resposta. Cada mensagem contém os campos role e content.💡 Preenchimento rápido (área Try it):

Clique em ”+ Add an item” para adicionar uma mensagem
Em role, informe: user (mensagem do usuário) ou assistant (resposta da IA, para múltiplas rodadas)
Em content, informe o texto da sua mensagem

Mostrar Detalhes dos campos

string

padrão:"user"

obrigatório

Tipo de papelOpções: user (mensagem do usuário), assistant (resposta da IA, para conversas em múltiplas rodadas e pré-preenchimento)Observação: a API Claude usa um parâmetro system separado para prompts do sistema, não em messages

string

obrigatório

Conteúdo da mensagemConteúdo textual da mensagem

Mensagem única do usuário:

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

Conversa em múltiplas rodadas:

[
  {"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?"}
]

Resposta do assistente pré-preenchida:

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

integer

obrigatório

Máximo de tokens a serem gerados (obrigatório, alinhado com a API oficial da Anthropic)Número máximo de tokens a serem gerados antes de parar. O modelo pode parar antes de atingir esse limite.Modelos diferentes possuem valores máximos distintos; consulte a documentação do modelo. Mínimo: 1

object

Configuração do extended thinkingQuando ativado, a resposta content pode conter blocos thinking. Recomendado: usar o nome de modelo padrão + este parâmetro, em vez de aliases de modelo -thinking no lado da plataforma, para facilitar a migração para os endpoints oficiais sem alterar o código.Em conversas multi-rodada que precisem reenviar blocos thinking, deve devolver integralmente o signature; caso contrário, o upstream rejeitará a requisição.

string | array

Prompt do sistemaOs prompts do sistema definem o papel, a personalidade, os objetivos e as instruções do Claude.Formato string:

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

Formato estruturado:

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

number

Parâmetro de temperatura, faixa 0–1Controla a aleatoriedade da saída:

Valores baixos (por exemplo, 0.2): mais determinístico, conservador
Valores altos (por exemplo, 0.8): mais aleatório, criativo

Padrão: 1.0

number

Parâmetro de amostragem por núcleo (nucleus sampling), faixa 0–1Utiliza amostragem por núcleo. Recomenda-se usar temperature OU top_p, não ambos.Padrão: 1.0

integer

Amostragem Top-KAmostra apenas a partir das K principais opções, removendo respostas de baixa probabilidade da “cauda longa”.Recomendado apenas para casos de uso avançados.

boolean

Habilitar streamingQuando true, usa Server-Sent Events (SSE) para transmitir as respostas em streaming.Padrão: false

array

Sequências de paradaSequências de texto personalizadas que fazem o modelo parar de gerar.Máximo de 4 sequências.Exemplo: ["\n\nHuman:", "\n\nAssistant:"]

object

MetadadosObjeto de metadados para a requisição.Inclui:

user_id: identificador do usuário

array

Definições de ferramentasLista de ferramentas que o modelo pode usar para concluir as tarefas.Exemplo de ferramenta de função:

{
  "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"]
      }
    }
  ]
}

Tipos de ferramentas suportadas:

Ferramentas de função personalizadas
Ferramenta de uso do computador (computer_20241022)
Ferramenta de edição de texto (text_editor_20241022)
Ferramenta Bash (bash_20241022)

object

Estratégia de escolha de ferramentaControla como o modelo usa as ferramentas:

{"type": "auto"}: decisão automática (padrão)
{"type": "any"}: deve usar uma ferramenta
{"type": "tool", "name": "tool_name"}: usar uma ferramenta específica

Resposta

string

Identificador único da mensagemExemplo: "msg_013Zva2CMHLNnXjNJJKqJ2EF"

string

Tipo do objetoSempre "message"

string

PapelSempre "assistant"

array

Array de blocos de conteúdocontent distingue os tipos de bloco por type. Uma única resposta pode conter vários blocos (por exemplo thinking + text quando thinking está ativado).Bloco text:

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

Bloco tool_use:

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

caller é um campo novo do upstream, ainda não documentado oficialmente; ignore-o na análise.

Bloco thinking (aparece quando o corpo da requisição inclui o parâmetro thinking):

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

Em conversas multi-rodada, ao reenviar blocos thinking, deve devolver integralmente o signature; caso contrário, o upstream rejeitará a requisição.

Não assuma que content[0] é texto. Com thinking ativado, content[0] pode ser um bloco thinking. Percorra e filtre:

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

string

Modelo que processou a requisiçãoExemplo: "claude-sonnet-4-6"

string

Motivo da paradaValores possíveis:

end_turn: conclusão natural
max_tokens: atingiu o limite máximo de tokens
stop_sequence: encontrou uma sequência de parada
tool_use: invocou uma ferramenta

string | null

Sequência de parada acionadaA sequência de parada gerada, se houver; caso contrário, null

object | null

Campo mais recente da Anthropic; null em requisições habituais

object

Estatísticas de uso de tokens (estrutura completa não streamada)

Mostrar Propriedades

integer

Número de tokens de entrada

integer

Número de tokens de saída (já inclui thinking tokens; não some de novo na faturação)

integer

Tokens de escrita em cache

integer

Tokens de leitura em cache (hit)

object

{ ephemeral_5m_input_tokens, ephemeral_1h_input_tokens }

string

Por exemplo "standard"

string

Por exemplo "global"

object

Pode aparecer com thinking ativado: { thinking_tokens: int }

Exemplos de uso

Conversa simples

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)

Conversa em múltiplas rodadas

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
)

Uso de prompts do sistema

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]"}
    ]
)

Resposta em 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)

Uso de ferramentas

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}")

Compreensão visual

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"
                }
            ]
        }
    ]
)

Imagem em 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"
                }
            ]
        }
    ]
)

Boas práticas

1. Engenharia de prompts

Definição clara do papel:

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."""

Saída estruturada:

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

2. Tratamento de erros

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. Otimização de tokens

# 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. Pré-preenchimento de respostas

# 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
)

Tratamento de respostas em streaming

Streaming em 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 em 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);
  }
}

Diferenças da plataforma e pontos de integração

Resposta sem envelope

Em caso de sucesso, POST /v1/messages devolve diretamente o objeto message da Anthropic, sem envelope {code, data}. Assim, os SDKs oficiais, Claude Code, Cline, etc. permanecem compatíveis 1:1.

Formato de erro (única diferença substancial em relação ao oficial)

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

Em relação à API oficial da Anthropic: o nível raiz não tem "type": "error"; error.type é fixo em apimart_error, e não tipos semânticos como invalid_request_error. Recomendação de integração: não baseie a lógica de retry em error.type; use o código de estado HTTP + error.code:

Código de estado	Significado	Ação recomendada
400	Parâmetros da requisição inválidos	Não repetir; verificar o corpo da requisição
401	Chave inválida	Não repetir
402	Saldo insuficiente	Não repetir; pedir recarga
429	Limitação de taxa	Repetir após backoff
5xx	Anomalia no upstream/gateway	Repetir com backoff exponencial

Para suporte, forneça: o request id no final de error.message, e o cabeçalho de resposta x-oneapi-request-id.

Streaming SSE

Adicione "stream": true à requisição. A sequência de eventos é idêntica à oficial: message_start → content_block_start → ping → content_block_delta (várias vezes) → content_block_stop → message_delta → message_stop ⚠️ A estrutura de usage difere entre stream e não stream: message_delta.usage normalmente tem apenas 4 campos de tokens, sem cache_creation, service_tier, inference_geo. Analise-os em separado ou trate todos os campos como opcionais.

Endpoint não implementado

POST /v1/messages/count_tokens não está implementado e devolve 404. A chamada client.messages.count_tokens() do SDK oficial falhará. Para estimar tokens, faça-o localmente ou leia usage.input_tokens na resposta.

Ignorar campos desconhecidos

Esta API retransmite o upstream tal como vem; a Anthropic pode adicionar campos a qualquer momento (p.ex. stop_details, inference_geo, caller, output_tokens_details). Não ative um esquema estrito:

Go: não use DisallowUnknownFields()
Pydantic: não use extra="forbid"
TypeScript / Zod: use .passthrough() em vez de .strict()

Recomendação de nomes de modelos

Os modelos homónimos com o sufixo -thinking são aliases de extensão da plataforma. Recomendado: usar o nome de modelo padrão sem sufixo + o parâmetro thinking no corpo da requisição, para facilitar a migração para os endpoints oficiais. Os restantes campos do corpo da requisição estão alinhados com o oficial: model, messages, max_tokens (obrigatório), system, temperature, top_p, top_k, stop_sequences, stream, tools, tool_choice, thinking, metadata. A semântica segue a Messages API da Anthropic.

Observações importantes

Segurança da chave de API:
- Armazene as chaves de API em variáveis de ambiente
- Nunca insira chaves diretamente no código-fonte
- Faça a rotação das chaves regularmente
Limite de taxa:
- Esteja atento aos limites de taxa da API
- Implemente mecanismos de retry (segundo o código de estado HTTP)
- Use exponential backoff
Gerenciamento de tokens:
- Monitore o consumo de tokens (leia usage)
- Otimize o tamanho dos prompts
- Use valores adequados de max_tokens
- Com thinking ativado, output_tokens já inclui o thinking; não fature em duplicado
Seleção de modelo:
- Opus: tarefas complexas, que exigem raciocínio profundo
- Sonnet: desempenho e custo equilibrados
- Haiku: resposta rápida, tarefas simples
Análise do conteúdo:
- Percorra content para blocos type == "text"; não fixe content[0].text
- Se o modelo devolver JSON envolvido num bloco de código Markdown, é saída do modelo e não envelope da API (veja a FAQ abaixo)
Filtragem de conteúdo:
- Valide a entrada do usuário
- Filtre informações sensíveis
- Implemente moderação de conteúdo

FAQ

O text de `content` veio como bloco de código ```json ... ``` — como remover?

Isto não é um problema de estrutura da API. O campo text contém o conteúdo bruto gerado pelo modelo: se o modelo conclui que você quer JSON, costuma envolvê-lo num bloco de código Markdown. A API não reescreve (e não deve reescrever) a saída do modelo. Para obter dados estruturados limpos, há três abordagens corretas (da mais confiável à menos):

Usar tools para forçar saída estruturada — a mais confiável; o campo input já é um objeto parseado:

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

Prefill a mensagem do assistant, para o modelo continuar a partir de {:

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

Exigir no system prompt: «emita apenas JSON, sem bloco de código Markdown».

Não se recomenda remover o code fence com regex — se o modelo ocasionalmente não incluir a cerca, o parsing falha.

Visão Geral

Modelos

Série de Texto

Série de Imagem

Série de Vídeo

Série de Áudio

Série de Moderação

Gerenciamento de Upload

Gerenciamento de Tarefas

Gerenciamento de Conta

API Claude Messages

Autorizações

Body

Resposta

Exemplos de uso

Conversa simples

Conversa em múltiplas rodadas

Uso de prompts do sistema

Resposta em streaming

Uso de ferramentas

Compreensão visual

Imagem em Base64

Boas práticas

1. Engenharia de prompts

2. Tratamento de erros

3. Otimização de tokens

4. Pré-preenchimento de respostas

Tratamento de respostas em streaming

Streaming em Python

Streaming em JavaScript

Diferenças da plataforma e pontos de integração

Resposta sem envelope

Formato de erro (única diferença substancial em relação ao oficial)

Streaming SSE

Endpoint não implementado

Ignorar campos desconhecidos

Recomendação de nomes de modelos

Observações importantes

FAQ

O text de `content` veio como bloco de código ```json ... ``` — como remover?

​Autorizações

​Body

​Resposta

​Exemplos de uso

​Conversa simples

​Conversa em múltiplas rodadas

​Uso de prompts do sistema

​Resposta em streaming

​Uso de ferramentas

​Compreensão visual

​Imagem em Base64

​Boas práticas

​1. Engenharia de prompts

​2. Tratamento de erros

​3. Otimização de tokens

​4. Pré-preenchimento de respostas

​Tratamento de respostas em streaming

​Streaming em Python

​Streaming em JavaScript

​Diferenças da plataforma e pontos de integração

​Resposta sem envelope

​Formato de erro (única diferença substancial em relação ao oficial)

​Streaming SSE

​Endpoint não implementado

​Ignorar campos desconhecidos

​Recomendação de nomes de modelos

​Observações importantes

​FAQ

​O text de content veio como bloco de código ```json ... ``` — como remover?

Autorizações

Body

Resposta

Exemplos de uso

Conversa simples

Conversa em múltiplas rodadas

Uso de prompts do sistema

Resposta em streaming

Uso de ferramentas

Compreensão visual

Imagem em Base64

Boas práticas

1. Engenharia de prompts

2. Tratamento de erros

3. Otimização de tokens

4. Pré-preenchimento de respostas

Tratamento de respostas em streaming

Streaming em Python

Streaming em JavaScript

Diferenças da plataforma e pontos de integração

Resposta sem envelope

Formato de erro (única diferença substancial em relação ao oficial)

Streaming SSE

Endpoint não implementado

Ignorar campos desconhecidos

Recomendação de nomes de modelos

Observações importantes

FAQ

O text de `content` veio como bloco de código ```json ... ``` — como remover?