HTTP Client Integration
Use any HTTP client in any programming language to make direct requests to the Martian Gateway API. This is ideal for custom integrations, server-side applications, or languages without official SDKs.
Ensure you have your Martian API key from the Martian Dashboard before continuing.
Authentication
All requests to the Martian Gateway API require authentication using a bearer token in the Authorization header:
Authorization: Bearer MARTIAN_API_KEY
cURL
Chat Completions
curl https://api.withmartian.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer MARTIAN_API_KEY" \
-d '{
"model": "openai/gpt-4.1-nano",
"messages": [
{
"role": "user",
"content": "What is Olympus Mons?"
}
]
}'
Messages (Anthropic Format)
curl https://api.withmartian.com/v1/messages \
-H "Content-Type: application/json" \
-H "Authorization: Bearer MARTIAN_API_KEY" \
-d '{
"model": "anthropic/claude-sonnet-4-20250514",
"max_tokens": 1024,
"messages": [
{
"role": "user",
"content": "What is Olympus Mons?"
}
]
}'
Python
Using requests Library
import requests
url = "https://api.withmartian.com/v1/chat/completions"
headers = {
"Content-Type": "application/json",
"Authorization": "Bearer MARTIAN_API_KEY"
}
data = {
"model": "openai/gpt-4.1-nano",
"messages": [
{"role": "user", "content": "What is Olympus Mons?"}
]
}
response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result['choices'][0]['message']['content'])
Using httpx (Async)
import httpx
async def make_request():
async with httpx.AsyncClient() as client:
response = await client.post(
"https://api.withmartian.com/v1/chat/completions",
headers={
"Content-Type": "application/json",
"Authorization": "Bearer MARTIAN_API_KEY"
},
json={
"model": "openai/gpt-4.1-nano",
"messages": [
{"role": "user", "content": "Hello!"}
]
},
timeout=60.0
)
result = response.json()
return result['choices'][0]['message']['content']
JavaScript
Using fetch
const response = await fetch('https://api.withmartian.com/v1/chat/completions', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.MARTIAN_API_KEY}`
},
body: JSON.stringify({
model: 'openai/gpt-4.1-nano',
messages: [
{ role: 'user', content: 'What is Olympus Mons?' }
]
})
});
const data = await response.json();
console.log(data.choices[0].message.content);
Using axios
import axios from 'axios';
const response = await axios.post(
'https://api.withmartian.com/v1/chat/completions',
{
model: 'openai/gpt-4.1-nano',
messages: [
{ role: 'user', content: 'Hello!' }
]
},
{
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${process.env.MARTIAN_API_KEY}`
}
}
);
console.log(response.data.choices[0].message.content);
Other Languages
The Martian Gateway API follows standard REST principles and can be used with any HTTP client.
Go
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)
func main() {
url := "https://api.withmartian.com/v1/chat/completions"
requestBody := map[string]interface{}{
"model": "openai/gpt-4.1-nano",
"messages": []map[string]string{
{"role": "user", "content": "What is Olympus Mons?"},
},
}
jsonData, _ := json.Marshal(requestBody)
req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", "Bearer MARTIAN_API_KEY")
client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
Ruby
require 'net/http'
require 'json'
require 'uri'
uri = URI('https://api.withmartian.com/v1/chat/completions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request['Authorization'] = "Bearer MARTIAN_API_KEY"
request.body = {
model: 'openai/gpt-4.1-nano',
messages: [
{ role: 'user', content: 'What is Olympus Mons?' }
]
}.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
http.request(request)
end
result = JSON.parse(response.body)
puts result['choices'][0]['message']['content']
PHP
<?php
require 'vendor/autoload.php';
use GuzzleHttp\Client;
$client = new Client();
$response = $client->post('https://api.withmartian.com/v1/chat/completions', [
'headers' => [
'Content-Type' => 'application/json',
'Authorization' => 'Bearer MARTIAN_API_KEY'
],
'json' => [
'model' => 'openai/gpt-4.1-nano',
'messages' => [
['role' => 'user', 'content' => 'What is Olympus Mons?']
]
]
]);
$data = json_decode($response->getBody(), true);
echo $data['choices'][0]['message']['content'];
Java
import okhttp3.*;
import org.json.JSONObject;
import org.json.JSONArray;
public class MartianClient {
public static void main(String[] args) throws Exception {
OkHttpClient client = new OkHttpClient();
JSONObject requestBody = new JSONObject();
requestBody.put("model", "openai/gpt-4.1-nano");
JSONArray messages = new JSONArray();
JSONObject message = new JSONObject();
message.put("role", "user");
message.put("content", "What is Olympus Mons?");
messages.put(message);
requestBody.put("messages", messages);
RequestBody body = RequestBody.create(
requestBody.toString(),
MediaType.parse("application/json")
);
Request request = new Request.Builder()
.url("https://api.withmartian.com/v1/chat/completions")
.addHeader("Authorization", "Bearer MARTIAN_API_KEY")
.post(body)
.build();
Response response = client.newCall(request).execute();
System.out.println(response.body().string());
}
}
Rust
use reqwest;
use serde_json::json;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();
let response = client
.post("https://api.withmartian.com/v1/chat/completions")
.header("Content-Type", "application/json")
.header("Authorization", "Bearer MARTIAN_API_KEY")
.json(&json!({
"model": "openai/gpt-4.1-nano",
"messages": [
{
"role": "user",
"content": "What is Olympus Mons?"
}
]
}))
.send()
.await?;
let data = response.json::<serde_json::Value>().await?;
println!("{}", data);
Ok(())
}
.NET / C#
using System;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
using var client = new HttpClient();
var request = new
{
model = "openai/gpt-4.1-nano",
messages = new[]
{
new { role = "user", content = "What is Olympus Mons?" }
}
};
var json = JsonSerializer.Serialize(request);
var content = new StringContent(json, Encoding.UTF8, "application/json");
client.DefaultRequestHeaders.Add("Authorization", "Bearer MARTIAN_API_KEY");
var response = await client.PostAsync(
"https://api.withmartian.com/v1/chat/completions",
content
);
var result = await response.Content.ReadAsStringAsync();
Console.WriteLine(result);
}
}
Best Practices
Timeout Configuration
Always set appropriate timeouts for your HTTP requests:
import requests
response = requests.post(
url,
headers=headers,
json=data,
timeout=60 # 60 seconds
)
Error Handling
Always check response status codes and handle errors:
import requests
response = requests.post(url, headers=headers, json=data)
if response.status_code == 200:
result = response.json()
print(result['choices'][0]['message']['content'])
elif response.status_code == 401:
print("Authentication failed - check your API key")
elif response.status_code == 429:
print("Rate limit exceeded - retry with backoff")
elif response.status_code >= 500:
print("Server error - retry later")
else:
print(f"Error {response.status_code}: {response.text}")
Retry Logic
Implement exponential backoff for transient errors:
from tenacity import retry, stop_after_attempt, wait_exponential
import requests
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=4, max=10)
)
def make_request(url, headers, data):
response = requests.post(url, headers=headers, json=data)
response.raise_for_status()
return response.json()