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())
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())
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);
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);
});
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
$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);
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)
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()
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(())
}
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);
}
}