Qaynaq LABS · TOOLS

CURL → CODE · POST · API-KEY

cURL → 10 languages

POST api.anthropic.com · body: json · secrets replaced with env vars.

Source cURL
curl -X POST https://api.anthropic.com/v1/messages -H "x-api-key: sk-ant-api03-1234567890abcdefghijklmnopqrstuvwxyz" -H "anthropic-version: 2023-06-01" -H "content-type: application/json" -d '{"model":"claude-2","max_tokens":100,"messages":[{"role":"user","content":"Hello, world!"}]}'

Python · requests

import os
import requests

url = "https://api.anthropic.com/v1/messages"
headers = {
    "x-api-key": os.environ["ANTHROPIC_API_KEY"],
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}
data = {
    "model": "claude-2",
    "max_tokens": 100,
    "messages": [{"role": "user", "content": "Hello, world!"}]
}

response = requests.post(url, headers=headers, json=data)
response.raise_for_status()
print(response.json())

Python · httpx

import os
import httpx

url = "https://api.anthropic.com/v1/messages"
headers = {
    "x-api-key": os.environ["ANTHROPIC_API_KEY"],
    "anthropic-version": "2023-06-01",
    "content-type": "application/json"
}
data = {
    "model": "claude-2",
    "max_tokens": 100,
    "messages": [{"role": "user", "content": "Hello, world!"}]
}

with httpx.Client() as client:
    response = client.post(url, headers=headers, json=data)
    response.raise_for_status()
    print(response.json())

Node.js · fetch

import fetch from 'node-fetch';

const url = 'https://api.anthropic.com/v1/messages';
const headers = {
  'x-api-key': process.env.ANTHROPIC_API_KEY,
  'anthropic-version': '2023-06-01',
  'content-type': 'application/json'
};
const data = {
  model: 'claude-2',
  max_tokens: 100,
  messages: [{ role: 'user', content: 'Hello, world!' }]
};

fetch(url, {
  method: 'POST',
  headers,
  body: JSON.stringify(data)
})
  .then(res => {
    if (!res.ok) throw new Error(`HTTP error! status: ${res.status}`);
    return res.json();
  })
  .then(console.log)
  .catch(console.error);

Node.js · axios

import axios from 'axios';

const url = 'https://api.anthropic.com/v1/messages';
const headers = {
  'x-api-key': process.env.ANTHROPIC_API_KEY,
  'anthropic-version': '2023-06-01',
  'content-type': 'application/json'
};
const data = {
  model: 'claude-2',
  max_tokens: 100,
  messages: [{ role: 'user', content: 'Hello, world!' }]
};

axios.post(url, data, { headers })
  .then(res => {
    console.log(res.data);
  })
  .catch(err => {
    console.error(err);
  });

Go · net/http

package main

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

func main() {
	url := "https://api.anthropic.com/v1/messages"
	req, err := http.NewRequest("POST", url, nil)
	if err != nil {
		panic(err)
	}

	req.Header.Set("x-api-key", os.Getenv("ANTHROPIC_API_KEY"))
	req.Header.Set("anthropic-version", "2023-06-01")
	req.Header.Set("content-type", "application/json")

	data := map[string]interface{}{
		"model":      "claude-2",
		"max_tokens": 100,
		"messages": []map[string]string{
			{"role": "user", "content": "Hello, world!"},
		},
	}
	body, _ := json.Marshal(data)
	req.Body = io.NopCloser(bytes.NewBuffer(body))

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

	if resp.StatusCode != http.StatusOK {
		panic(fmt.Sprintf("HTTP error! status: %s", resp.Status))
	}

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}

PHP · cURL

<?php

$url = 'https://api.anthropic.com/v1/messages';
$headers = [
    'x-api-key: ' . getenv('ANTHROPIC_API_KEY'),
    'anthropic-version: 2023-06-01',
    'content-type: application/json'
];
$data = [
    'model' => 'claude-2',
    'max_tokens' => 100,
    '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_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));

$response = curl_exec($ch);
if (curl_errno($ch)) {
    die('Error: ' . curl_error($ch));
}
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($httpCode !== 200) {
    die("HTTP error! status: $httpCode");
}

$decoded = json_decode($response, true);
print_r($decoded);

Ruby · net/http

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

url = URI.parse('https://api.anthropic.com/v1/messages')
headers = {
  'x-api-key' => ENV['ANTHROPIC_API_KEY'],
  'anthropic-version' => '2023-06-01',
  'content-type' => 'application/json'
}
data = {
  model: 'claude-2',
  max_tokens: 100,
  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_uri, headers)
request.body = data.to_json

response = http.request(request)
unless response.is_a?(Net::HTTPSuccess)
  raise "HTTP error! status: #{response.code}"
end

puts JSON.parse(response.body)

Swift · URLSession

import Foundation

let url = URL(string: "https://api.anthropic.com/v1/messages")!
var request = URLRequest(url: url)
request.httpMethod = "POST"
request.setValue(ProcessInfo.processInfo.environment["ANTHROPIC_API_KEY"], forHTTPHeaderField: "x-api-key")
request.setValue("2023-06-01", forHTTPHeaderField: "anthropic-version")
request.setValue("application/json", forHTTPHeaderField: "content-type")

let body: [String: Any] = [
    "model": "claude-2",
    "max_tokens": 100,
    "messages": [
        ["role": "user", "content": "Hello, world!"]
    ]
]

request.httpBody = try? JSONSerialization.data(withJSONObject: body)

let task = URLSession.shared.dataTask(with: request) { data, response, error in
    if let error = error {
        print("Error: \(error)")
        return
    }
    guard let httpResponse = response as? HTTPURLResponse else {
        print("Invalid response")
        return
    }
    guard (200...299).contains(httpResponse.statusCode) else {
        print("HTTP error! status: \(httpResponse.statusCode)")
        return
    }
    if let data = data, let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] {
        print(json)
    }
}

task.resume()
RunLoop.main.run()

Rust · reqwest

use std::env;
use reqwest::blocking::Client;
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = "https://api.anthropic.com/v1/messages";
    let api_key = env::var("ANTHROPIC_API_KEY")?;

    let client = Client::new();
    let response = client
        .post(url)
        .header("x-api-key", api_key)
        .header("anthropic-version", "2023-06-01")
        .header("content-type", "application/json")
        .json(&json!({
            "model": "claude-2",
            "max_tokens": 100,
            "messages": [{"role": "user", "content": "Hello, world!"}]
        }))
        .send()?;

    if !response.status().is_success() {
        return Err(format!("HTTP error! status: {}", response.status()).into());
    }

    let body = response.json::<serde_json::Value>()?;
    println!("{:?}", body);
    Ok(())
}

C# · HttpClient

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

class Program
{
    static async Task Main()
    {
        var url = "https://api.anthropic.com/v1/messages";
        var apiKey = Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY");

        using var client = new HttpClient();
        client.DefaultRequestHeaders.Add("x-api-key", apiKey);
        client.DefaultRequestHeaders.Add("anthropic-version", "2023-06-01");
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        var data = new
        {
            model = "claude-2",
            max_tokens = 100,
            messages = new[]
            {
                new { role = "user", content = "Hello, world!" }
            }
        };

        var response = await client.PostAsJsonAsync(url, data);
        if (!response.IsSuccessStatusCode)
        {
            throw new Exception($"HTTP error! status: {response.StatusCode}");
        }

        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}

Translation notes

  • All implementations use the idiomatic HTTP client for each language.
  • Bearer/API keys are read from environment variables (ANTHROPIC_API_KEY).
  • JSON bodies are constructed as objects/dictionaries, not raw strings.
  • Error handling checks HTTP status and reads the response body.
  • The 'redacted' flag is set to true because the API key is replaced with an environment variable.

Common pitfalls when porting

  • Forgetting to set the 'x-api-key' header will result in authentication errors.
  • Not handling HTTP errors properly may lead to unhandled exceptions or silent failures.
  • In Go, forgetting to close the response body can lead to resource leaks.
  • In Swift, the URLSession task must be started with 'resume()'.
  • In Rust, using the async reqwest client requires a runtime like tokio.

About cURL → code translation

cURL is the lingua franca of API documentation: every vendor docs page ships a cURL snippet you can paste into a terminal and immediately see the API working. Translating that into your actual application code shouldn't be a 20-minute Stack-Overflow safari, but without a good translator it usually is.

Qaynaq Labs' cURL → code tool reads the full command — method, URL, headers, query params, body type, and auth — and emits idiomatic client code in 10 languages. Authentication goes through environment variables by default, request bodies become language-native data structures (not raw JSON strings), and minimal error handling is included.

Frequently asked

Why use environment variables for secrets?

Environment variables are a secure way to handle secrets as they are not hardcoded in the source code, reducing the risk of accidental exposure.

How do I install the required dependencies for each language?

Each language has its own package manager (e.g., pip for Python, npm for Node.js, composer for PHP). Refer to the respective documentation for setup instructions.

Why is the 'redacted' flag set to true?

The 'redacted' flag is set to true because the API key in the original cURL command was replaced with an environment variable reference, which is a security best practice.