Code Samples on APIHub - Global API Directory

Airtable API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in C#

This guide shows you how to integrate the Airtable API into your C# application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

C# installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.airtable.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.airtable.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class AirtableClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public AirtableClient(string apiKey, string baseUrl = "https://api.airtable.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Airtable API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new AirtableClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Go

This guide shows you how to integrate the Airtable API into your Go application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Go installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.airtable.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.airtable.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type AirtableClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *AirtableClient {
 return &AirtableClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *AirtableClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *AirtableClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *AirtableClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.airtable.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Java

This guide shows you how to integrate the Airtable API into your Java application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Java installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.airtable.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.airtable.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class AirtableClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public AirtableClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 AirtableClient client = new AirtableClient(
 System.getenv("API_KEY"), "https://api.airtable.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in JavaScript

This guide shows you how to integrate the Airtable API into your JavaScript application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

JavaScript installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.airtable.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class AirtableClient {
 constructor(apiKey, baseUrl = 'https://api.airtable.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new AirtableClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Kotlin

This guide shows you how to integrate the Airtable API into your Kotlin application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Kotlin installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.airtable.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.airtable.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class AirtableClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.airtable.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = AirtableClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in PHP

This guide shows you how to integrate the Airtable API into your PHP application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

PHP installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.airtable.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.airtable.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class AirtableClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.airtable.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new AirtableClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Python

This guide shows you how to integrate the Airtable API into your Python application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Python installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.airtable.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class AirtableClient:
 """Advanced client for Airtable API."""

 def __init__(self, api_key: str, base_url: str = "https://api.airtable.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Airtable API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = AirtableClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Ruby

This guide shows you how to integrate the Airtable API into your Ruby application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Ruby installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.airtable.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.airtable.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class AirtableClient
 def initialize(api_key, base_url = 'https://api.airtable.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = AirtableClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Rust

This guide shows you how to integrate the Airtable API into your Rust application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Rust installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.airtable.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.airtable.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct AirtableClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl AirtableClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = AirtableClient::new(
 env::var("API_KEY")?,
 "https://api.airtable.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Airtable API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Airtable API API in Swift

This guide shows you how to integrate the Airtable API into your Swift application. Spreadsheet-database hybrid API with CRUD on bases, records, and attachments.

Prerequisites

Swift installed on your system
An Airtable API API key (sign up at https://airtable.com/developers/web/api)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.airtable.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.airtable.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class AirtableClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.airtable.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = AirtableClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in C#

This guide shows you how to integrate the Algolia API into your C# application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

C# installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.algolia.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.algolia.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class AlgoliaClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public AlgoliaClient(string apiKey, string baseUrl = "https://api.algolia.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Algolia API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new AlgoliaClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Go

This guide shows you how to integrate the Algolia API into your Go application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Go installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.algolia.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.algolia.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type AlgoliaClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *AlgoliaClient {
 return &AlgoliaClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *AlgoliaClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *AlgoliaClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *AlgoliaClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.algolia.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Java

This guide shows you how to integrate the Algolia API into your Java application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Java installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.algolia.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.algolia.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class AlgoliaClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public AlgoliaClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 AlgoliaClient client = new AlgoliaClient(
 System.getenv("API_KEY"), "https://api.algolia.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in JavaScript

This guide shows you how to integrate the Algolia API into your JavaScript application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

JavaScript installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.algolia.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class AlgoliaClient {
 constructor(apiKey, baseUrl = 'https://api.algolia.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new AlgoliaClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Kotlin

This guide shows you how to integrate the Algolia API into your Kotlin application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Kotlin installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.algolia.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.algolia.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class AlgoliaClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.algolia.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = AlgoliaClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in PHP

This guide shows you how to integrate the Algolia API into your PHP application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

PHP installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.algolia.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.algolia.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class AlgoliaClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.algolia.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new AlgoliaClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Python

This guide shows you how to integrate the Algolia API into your Python application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Python installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.algolia.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class AlgoliaClient:
 """Advanced client for Algolia API."""

 def __init__(self, api_key: str, base_url: str = "https://api.algolia.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Algolia API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = AlgoliaClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Ruby

This guide shows you how to integrate the Algolia API into your Ruby application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Ruby installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.algolia.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.algolia.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class AlgoliaClient
 def initialize(api_key, base_url = 'https://api.algolia.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = AlgoliaClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Rust

This guide shows you how to integrate the Algolia API into your Rust application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Rust installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.algolia.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.algolia.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct AlgoliaClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl AlgoliaClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = AlgoliaClient::new(
 env::var("API_KEY")?,
 "https://api.algolia.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Algolia API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Algolia API API in Swift

This guide shows you how to integrate the Algolia API into your Swift application. Hosted search API with typo-tolerance, faceting, and instant search UI libraries.

Prerequisites

Swift installed on your system
An Algolia API API key (sign up at https://algolia.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.algolia.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.algolia.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class AlgoliaClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.algolia.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = AlgoliaClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in C#

This guide shows you how to integrate the Auth0 API into your C# application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

C# installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.auth0.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.auth0.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class Auth0Client {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public Auth0Client(string apiKey, string baseUrl = "https://api.auth0.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Auth0 API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new Auth0Client(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Go

This guide shows you how to integrate the Auth0 API into your Go application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Go installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.auth0.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.auth0.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type Auth0Client struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *Auth0Client {
 return &Auth0Client{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *Auth0Client) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *Auth0Client) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *Auth0Client) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.auth0.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Java

This guide shows you how to integrate the Auth0 API into your Java application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Java installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.auth0.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.auth0.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class Auth0Client {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public Auth0Client(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 Auth0Client client = new Auth0Client(
 System.getenv("API_KEY"), "https://api.auth0.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in JavaScript

This guide shows you how to integrate the Auth0 API into your JavaScript application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

JavaScript installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.auth0.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class Auth0Client {
 constructor(apiKey, baseUrl = 'https://api.auth0.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new Auth0Client(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Kotlin

This guide shows you how to integrate the Auth0 API into your Kotlin application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Kotlin installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.auth0.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.auth0.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class Auth0Client(
 private val apiKey: String,
 private val baseUrl: String = "https://api.auth0.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = Auth0Client(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in PHP

This guide shows you how to integrate the Auth0 API into your PHP application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

PHP installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.auth0.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.auth0.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class Auth0Client {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.auth0.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new Auth0Client(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Python

This guide shows you how to integrate the Auth0 API into your Python application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Python installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.auth0.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class Auth0Client:
 """Advanced client for Auth0 API."""

 def __init__(self, api_key: str, base_url: str = "https://api.auth0.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Auth0 API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = Auth0Client(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Ruby

This guide shows you how to integrate the Auth0 API into your Ruby application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Ruby installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.auth0.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.auth0.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class Auth0Client
 def initialize(api_key, base_url = 'https://api.auth0.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = Auth0Client.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Rust

This guide shows you how to integrate the Auth0 API into your Rust application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Rust installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.auth0.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.auth0.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct Auth0Client {
 client: Client,
 api_key: String,
 base_url: String,
}

impl Auth0Client {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = Auth0Client::new(
 env::var("API_KEY")?,
 "https://api.auth0.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Auth0 API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Auth0 API API in Swift

This guide shows you how to integrate the Auth0 API into your Swift application. Identity platform with SSO, MFA, social login, and passwordless authentication.

Prerequisites

Swift installed on your system
An Auth0 API API key (sign up at https://auth0.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.auth0.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.auth0.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class Auth0Client {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.auth0.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = Auth0Client(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in C#

This guide shows you how to integrate the Cohere API into your C# application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

C# installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.cohere.ai";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.cohere.ai/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class CohereClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public CohereClient(string apiKey, string baseUrl = "https://api.cohere.ai") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Cohere API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new CohereClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Go

This guide shows you how to integrate the Cohere API into your Go application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Go installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.cohere.ai"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.cohere.ai/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type CohereClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *CohereClient {
 return &CohereClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *CohereClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *CohereClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *CohereClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.cohere.ai")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Java

This guide shows you how to integrate the Cohere API into your Java application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Java installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.cohere.ai";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.cohere.ai/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class CohereClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public CohereClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 CohereClient client = new CohereClient(
 System.getenv("API_KEY"), "https://api.cohere.ai"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in JavaScript

This guide shows you how to integrate the Cohere API into your JavaScript application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

JavaScript installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.cohere.ai';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class CohereClient {
 constructor(apiKey, baseUrl = 'https://api.cohere.ai') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new CohereClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Kotlin

This guide shows you how to integrate the Cohere API into your Kotlin application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Kotlin installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.cohere.ai"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.cohere.ai/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class CohereClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.cohere.ai"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = CohereClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in PHP

This guide shows you how to integrate the Cohere API into your PHP application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

PHP installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.cohere.ai';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.cohere.ai';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class CohereClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.cohere.ai') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new CohereClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Python

This guide shows you how to integrate the Cohere API into your Python application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Python installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.cohere.ai"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class CohereClient:
 """Advanced client for Cohere API."""

 def __init__(self, api_key: str, base_url: str = "https://api.cohere.ai"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Cohere API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = CohereClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Ruby

This guide shows you how to integrate the Cohere API into your Ruby application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Ruby installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.cohere.ai'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.cohere.ai/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class CohereClient
 def initialize(api_key, base_url = 'https://api.cohere.ai')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = CohereClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Rust

This guide shows you how to integrate the Cohere API into your Rust application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Rust installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.cohere.ai";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.cohere.ai";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct CohereClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl CohereClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = CohereClient::new(
 env::var("API_KEY")?,
 "https://api.cohere.ai".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Cohere API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Cohere API API in Swift

This guide shows you how to integrate the Cohere API into your Swift application. NLP platform for text generation, classification, embedding, and reranking with Command R models.

Prerequisites

Swift installed on your system
An Cohere API API key (sign up at https://cohere.ai)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.cohere.ai"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.cohere.ai/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class CohereClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.cohere.ai") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = CohereClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in C#

This guide shows you how to integrate the Firebase API into your C# application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

C# installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.firebase.google.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.firebase.google.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class FirebaseClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public FirebaseClient(string apiKey, string baseUrl = "https://api.firebase.google.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Firebase API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new FirebaseClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Go

This guide shows you how to integrate the Firebase API into your Go application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Go installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.firebase.google.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.firebase.google.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type FirebaseClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *FirebaseClient {
 return &FirebaseClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *FirebaseClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *FirebaseClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *FirebaseClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.firebase.google.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Java

This guide shows you how to integrate the Firebase API into your Java application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Java installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.firebase.google.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.firebase.google.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class FirebaseClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public FirebaseClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 FirebaseClient client = new FirebaseClient(
 System.getenv("API_KEY"), "https://api.firebase.google.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in JavaScript

This guide shows you how to integrate the Firebase API into your JavaScript application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

JavaScript installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.firebase.google.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class FirebaseClient {
 constructor(apiKey, baseUrl = 'https://api.firebase.google.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new FirebaseClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Kotlin

This guide shows you how to integrate the Firebase API into your Kotlin application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Kotlin installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.firebase.google.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.firebase.google.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class FirebaseClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.firebase.google.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = FirebaseClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in PHP

This guide shows you how to integrate the Firebase API into your PHP application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

PHP installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.firebase.google.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.firebase.google.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class FirebaseClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.firebase.google.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new FirebaseClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Python

This guide shows you how to integrate the Firebase API into your Python application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Python installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.firebase.google.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class FirebaseClient:
 """Advanced client for Firebase API."""

 def __init__(self, api_key: str, base_url: str = "https://api.firebase.google.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Firebase API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = FirebaseClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Ruby

This guide shows you how to integrate the Firebase API into your Ruby application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Ruby installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.firebase.google.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.firebase.google.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class FirebaseClient
 def initialize(api_key, base_url = 'https://api.firebase.google.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = FirebaseClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Rust

This guide shows you how to integrate the Firebase API into your Rust application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Rust installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.firebase.google.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.firebase.google.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct FirebaseClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl FirebaseClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = FirebaseClient::new(
 env::var("API_KEY")?,
 "https://api.firebase.google.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Firebase API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Firebase API API in Swift

This guide shows you how to integrate the Firebase API into your Swift application. Firestore, Realtime Database, Auth, Storage, and Cloud Messaging.

Prerequisites

Swift installed on your system
An Firebase API API key (sign up at https://firebase.google.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.firebase.google.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.firebase.google.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class FirebaseClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.firebase.google.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = FirebaseClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in C#

This guide shows you how to integrate the Google Gemini API into your C# application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

C# installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://generativelanguage.googleapis.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://generativelanguage.googleapis.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class GeminiClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public GeminiClient(string apiKey, string baseUrl = "https://generativelanguage.googleapis.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Google Gemini API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new GeminiClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Go

This guide shows you how to integrate the Google Gemini API into your Go application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Go installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://generativelanguage.googleapis.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://generativelanguage.googleapis.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type GeminiClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *GeminiClient {
 return &GeminiClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *GeminiClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *GeminiClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *GeminiClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://generativelanguage.googleapis.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Java

This guide shows you how to integrate the Google Gemini API into your Java application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Java installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://generativelanguage.googleapis.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://generativelanguage.googleapis.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class GeminiClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public GeminiClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 GeminiClient client = new GeminiClient(
 System.getenv("API_KEY"), "https://generativelanguage.googleapis.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in JavaScript

This guide shows you how to integrate the Google Gemini API into your JavaScript application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

JavaScript installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://generativelanguage.googleapis.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class GeminiClient {
 constructor(apiKey, baseUrl = 'https://generativelanguage.googleapis.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new GeminiClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Kotlin

This guide shows you how to integrate the Google Gemini API into your Kotlin application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Kotlin installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://generativelanguage.googleapis.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://generativelanguage.googleapis.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class GeminiClient(
 private val apiKey: String,
 private val baseUrl: String = "https://generativelanguage.googleapis.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = GeminiClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in PHP

This guide shows you how to integrate the Google Gemini API into your PHP application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

PHP installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://generativelanguage.googleapis.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://generativelanguage.googleapis.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class GeminiClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://generativelanguage.googleapis.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new GeminiClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Python

This guide shows you how to integrate the Google Gemini API into your Python application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Python installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://generativelanguage.googleapis.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class GeminiClient:
 """Advanced client for Google Gemini API."""

 def __init__(self, api_key: str, base_url: str = "https://generativelanguage.googleapis.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Google Gemini API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = GeminiClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Ruby

This guide shows you how to integrate the Google Gemini API into your Ruby application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Ruby installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://generativelanguage.googleapis.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://generativelanguage.googleapis.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class GeminiClient
 def initialize(api_key, base_url = 'https://generativelanguage.googleapis.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = GeminiClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Rust

This guide shows you how to integrate the Google Gemini API into your Rust application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Rust installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://generativelanguage.googleapis.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://generativelanguage.googleapis.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct GeminiClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl GeminiClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = GeminiClient::new(
 env::var("API_KEY")?,
 "https://generativelanguage.googleapis.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Google Gemini API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Google Gemini API API in Swift

This guide shows you how to integrate the Google Gemini API into your Swift application. Google’s multimodal AI model for text, image, video, and audio understanding.

Prerequisites

Swift installed on your system
An Google Gemini API API key (sign up at https://ai.google.dev)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://generativelanguage.googleapis.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://generativelanguage.googleapis.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class GeminiClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://generativelanguage.googleapis.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = GeminiClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in C#

This guide shows you how to integrate the HERE API into your C# application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

C# installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.here.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.here.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class HereClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public HereClient(string apiKey, string baseUrl = "https://api.here.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "HERE API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new HereClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Go

This guide shows you how to integrate the HERE API into your Go application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Go installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.here.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.here.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type HereClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *HereClient {
 return &HereClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *HereClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *HereClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *HereClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.here.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Java

This guide shows you how to integrate the HERE API into your Java application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Java installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.here.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.here.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class HereClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public HereClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 HereClient client = new HereClient(
 System.getenv("API_KEY"), "https://api.here.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in JavaScript

This guide shows you how to integrate the HERE API into your JavaScript application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

JavaScript installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.here.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class HereClient {
 constructor(apiKey, baseUrl = 'https://api.here.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new HereClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Kotlin

This guide shows you how to integrate the HERE API into your Kotlin application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Kotlin installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.here.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.here.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class HereClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.here.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = HereClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in PHP

This guide shows you how to integrate the HERE API into your PHP application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

PHP installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.here.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.here.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class HereClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.here.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new HereClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Python

This guide shows you how to integrate the HERE API into your Python application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Python installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.here.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class HereClient:
 """Advanced client for HERE API."""

 def __init__(self, api_key: str, base_url: str = "https://api.here.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "HERE API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = HereClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Ruby

This guide shows you how to integrate the HERE API into your Ruby application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Ruby installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.here.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.here.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class HereClient
 def initialize(api_key, base_url = 'https://api.here.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = HereClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Rust

This guide shows you how to integrate the HERE API into your Rust application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Rust installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.here.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.here.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct HereClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl HereClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = HereClient::new(
 env::var("API_KEY")?,
 "https://api.here.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

HERE API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

HERE API API in Swift

This guide shows you how to integrate the HERE API into your Swift application. Location services including maps, geocoding, routing, and fleet tracking.

Prerequisites

Swift installed on your system
An HERE API API key (sign up at https://here.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.here.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.here.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class HereClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.here.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = HereClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in C#

This guide shows you how to integrate the Mapbox API into your C# application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

C# installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.mapbox.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.mapbox.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class MapboxClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public MapboxClient(string apiKey, string baseUrl = "https://api.mapbox.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "Mapbox API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new MapboxClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Go

This guide shows you how to integrate the Mapbox API into your Go application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Go installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.mapbox.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.mapbox.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type MapboxClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *MapboxClient {
 return &MapboxClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *MapboxClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *MapboxClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *MapboxClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.mapbox.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Java

This guide shows you how to integrate the Mapbox API into your Java application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Java installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.mapbox.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.mapbox.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class MapboxClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public MapboxClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 MapboxClient client = new MapboxClient(
 System.getenv("API_KEY"), "https://api.mapbox.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in JavaScript

This guide shows you how to integrate the Mapbox API into your JavaScript application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

JavaScript installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.mapbox.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class MapboxClient {
 constructor(apiKey, baseUrl = 'https://api.mapbox.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new MapboxClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Kotlin

This guide shows you how to integrate the Mapbox API into your Kotlin application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Kotlin installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.mapbox.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.mapbox.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class MapboxClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.mapbox.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = MapboxClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in PHP

This guide shows you how to integrate the Mapbox API into your PHP application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

PHP installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.mapbox.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.mapbox.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class MapboxClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.mapbox.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new MapboxClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Python

This guide shows you how to integrate the Mapbox API into your Python application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Python installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.mapbox.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MapboxClient:
 """Advanced client for Mapbox API."""

 def __init__(self, api_key: str, base_url: str = "https://api.mapbox.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "Mapbox API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = MapboxClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Ruby

This guide shows you how to integrate the Mapbox API into your Ruby application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Ruby installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.mapbox.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.mapbox.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class MapboxClient
 def initialize(api_key, base_url = 'https://api.mapbox.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = MapboxClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Rust

This guide shows you how to integrate the Mapbox API into your Rust application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Rust installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.mapbox.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.mapbox.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct MapboxClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl MapboxClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = MapboxClient::new(
 env::var("API_KEY")?,
 "https://api.mapbox.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Mapbox API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

Mapbox API API in Swift

This guide shows you how to integrate the Mapbox API into your Swift application. Custom maps, geocoding, directions, and satellite imagery with GL JS and mobile SDKs.

Prerequisites

Swift installed on your system
An Mapbox API API key (sign up at https://mapbox.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.mapbox.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.mapbox.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class MapboxClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.mapbox.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = MapboxClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

News API API in C#

This guide shows you how to integrate the News API into your C# application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

C# installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.newsapi.org";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.newsapi.org/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class NewsapiClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public NewsapiClient(string apiKey, string baseUrl = "https://api.newsapi.org") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "News API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new NewsapiClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Go

This guide shows you how to integrate the News API into your Go application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Go installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.newsapi.org"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.newsapi.org/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type NewsapiClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *NewsapiClient {
 return &NewsapiClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *NewsapiClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *NewsapiClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *NewsapiClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.newsapi.org")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Java

This guide shows you how to integrate the News API into your Java application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Java installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.newsapi.org";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.newsapi.org/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class NewsapiClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public NewsapiClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 NewsapiClient client = new NewsapiClient(
 System.getenv("API_KEY"), "https://api.newsapi.org"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

News API API in JavaScript

This guide shows you how to integrate the News API into your JavaScript application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

JavaScript installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.newsapi.org';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class NewsapiClient {
 constructor(apiKey, baseUrl = 'https://api.newsapi.org') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new NewsapiClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Kotlin

This guide shows you how to integrate the News API into your Kotlin application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Kotlin installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.newsapi.org"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.newsapi.org/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class NewsapiClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.newsapi.org"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = NewsapiClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

News API API in PHP

This guide shows you how to integrate the News API into your PHP application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

PHP installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.newsapi.org';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.newsapi.org';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class NewsapiClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.newsapi.org') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new NewsapiClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Python

This guide shows you how to integrate the News API into your Python application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Python installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.newsapi.org"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class NewsapiClient:
 """Advanced client for News API."""

 def __init__(self, api_key: str, base_url: str = "https://api.newsapi.org"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "News API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = NewsapiClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Ruby

This guide shows you how to integrate the News API into your Ruby application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Ruby installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.newsapi.org'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.newsapi.org/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class NewsapiClient
 def initialize(api_key, base_url = 'https://api.newsapi.org')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = NewsapiClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Rust

This guide shows you how to integrate the News API into your Rust application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Rust installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.newsapi.org";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.newsapi.org";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct NewsapiClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl NewsapiClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = NewsapiClient::new(
 env::var("API_KEY")?,
 "https://api.newsapi.org".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

News API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

News API API in Swift

This guide shows you how to integrate the News API into your Swift application. Headlines and articles from 80,000+ worldwide news sources.

Prerequisites

Swift installed on your system
An News API API key (sign up at https://newsapi.org)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.newsapi.org"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.newsapi.org/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class NewsapiClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.newsapi.org") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = NewsapiClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in C#

This guide shows you how to integrate the OpenAI API into your C# application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

C# installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.openai.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.openai.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class OpenaiClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public OpenaiClient(string apiKey, string baseUrl = "https://api.openai.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "OpenAI API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new OpenaiClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Go

This guide shows you how to integrate the OpenAI API into your Go application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Go installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.openai.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.openai.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type OpenaiClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *OpenaiClient {
 return &OpenaiClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *OpenaiClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *OpenaiClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *OpenaiClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.openai.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Java

This guide shows you how to integrate the OpenAI API into your Java application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Java installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.openai.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.openai.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class OpenaiClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public OpenaiClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 OpenaiClient client = new OpenaiClient(
 System.getenv("API_KEY"), "https://api.openai.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in JavaScript

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in JavaScript

This guide shows you how to integrate the OpenAI API into your JavaScript application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

JavaScript installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

npm install node-fetch
# or use built-in fetch in Node 18+

Basic Usage

const API_KEY = process.env.API_KEY || 'YOUR_API_KEY';
const BASE_URL = 'https://api.openai.com';

async function callApi() {
 const response = await fetch(`${BASE_URL}/v1/resources`, {
 headers: {
 'Authorization': `Bearer ${API_KEY}`,
 'Content-Type': 'application/json'
 }
 });
 const data = await response.json();
 console.log('Status:', response.status);
 console.log(data);
 return data;
}

callApi().catch(console.error);

Error Handling

async function callApiWithRetry(url, options, maxRetries = 3) {
 for (let attempt = 0; attempt < maxRetries; attempt++) {
 try {
 const response = await fetch(url, options);
 if (response.status === 429) {
 const retryAfter = parseInt(response.headers.get('Retry-After') || '60');
 console.log(`Rate limited. Waiting ${retryAfter}s...`);
 await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
 continue;
 }
 if (!response.ok) {
 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
 }
 return await response.json();
 } catch (error) {
 console.error(`Attempt ${attempt + 1} failed:`, error.message);
 if (attempt === maxRetries - 1) throw error;
 await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
 }
 }
}

callApiWithRetry(`${BASE_URL}/v1/resources`, {
 headers: { 'Authorization': `Bearer ${API_KEY}` }
}).then(console.log).catch(console.error);

Advanced Usage

class OpenaiClient {
 constructor(apiKey, baseUrl = 'https://api.openai.com') {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replace(/\/$/, '');
 }

 async request(method, path, options = {}) {
 const url = `${this.baseUrl}/v1${path}`;
 const response = await fetch(url, {
 method,
 headers: {
 'Authorization': `Bearer ${this.apiKey}`,
 'Content-Type': 'application/json',
 ...options.headers
 },
 body: options.body ? JSON.stringify(options.body) : undefined,
 ...options
 });
 if (!response.ok) {
 const error = await response.json().catch(() => ({}));
 throw new Error(`API Error: ${error.message || response.statusText}`);
 }
 return response.json();
 }

 async listResources(params = {}) {
 const query = new URLSearchParams(params).toString();
 return this.request('GET', `/resources${query ? '?' + query : ''}`);
 }

 async createResource(data) {
 return this.request('POST', '/resources', { body: data });
 }

 async getResource(id) {
 return this.request('GET', `/resources/${id}`);
 }
}

const client = new OpenaiClient(process.env.API_KEY);
client.listResources({ limit: 50 })
 .then(data => console.log(`Found ${data.data.length} resources`))
 .catch(console.error);

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Kotlin

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Kotlin

This guide shows you how to integrate the OpenAI API into your Kotlin application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Kotlin installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

// build.gradle.kts
dependencies {
 implementation("io.ktor:ktor-client-core:2.3.0")
 implementation("io.ktor:ktor-client-cio:2.3.0")
 implementation("io.ktor:ktor-client-content-negotiation:2.3.0")
 implementation("io.ktor:ktor-serialization-kotlinx-json:2.3.0")
}

Basic Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val baseUrl = "https://api.openai.com"

 val client = HttpClient(CIO)
 val response: HttpResponse = client.get("$baseUrl/v1/resources") {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }

 println("Status: ${response.status}")
 println(response.bodyAsText())
 client.close()
}

Error Handling

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import kotlinx.coroutines.*

suspend fun callApiWithRetry(url: String, apiKey: String, maxRetries: Int = 3): HttpResponse {
 val client = HttpClient(CIO)
 var attempt = 0
 while (true) {
 val response = client.get(url) {
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 }
 if (response.status.value != 429 && response.status.value < 500) {
 client.close()
 return response
 }
 println("Attempt $attempt failed (HTTP ${response.status}). Waiting 60s...")
 delay(60000)
 attempt++
 if (attempt >= maxRetries) {
 client.close()
 throw RuntimeException("Max retries exceeded: ${response.status}")
 }
 }
}

fun main() = runBlocking {
 val apiKey = System.getenv("API_KEY") ?: "YOUR_API_KEY"
 val response = callApiWithRetry("https://api.openai.com/v1/resources", apiKey)
 println(response.bodyAsText())
}

Advanced Usage

import io.ktor.client.*
import io.ktor.client.engine.cio.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.*
import kotlinx.serialization.json.*

class OpenaiClient(
 private val apiKey: String,
 private val baseUrl: String = "https://api.openai.com"
) {
 private val client = HttpClient(CIO)

 suspend fun request(method: HttpMethod, path: String, body: String? = null): JsonObject {
 val url = "$baseUrl/v1$path"
 val response = client.request(url) {
 this.method = method
 header("Authorization", "Bearer $apiKey")
 header("Content-Type", "application/json")
 if (body != null) setBody(body)
 }
 if (!response.status.isSuccess()) {
 throw RuntimeException("API Error: HTTP ${response.status}")
 }
 return Json.parseToJsonElement(response.bodyAsText()).jsonObject
 }

 suspend fun listResources(limit: Int = 50): JsonObject =
 request(HttpMethod.Get, "/resources?limit=$limit")

 suspend fun createResource(data: String): JsonObject =
 request(HttpMethod.Post, "/resources", data)
}

fun main() = runBlocking {
 val client = OpenaiClient(System.getenv("API_KEY") ?: "YOUR_API_KEY")
 val resources = client.listResources()
 println("Found ${resources["data"]?.jsonArray?.size ?: 0} resources")
 client.close()
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in PHP

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in PHP

This guide shows you how to integrate the OpenAI API into your PHP application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

PHP installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

composer require guzzlehttp/guzzle

Basic Usage

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.openai.com';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $baseUrl . '/v1/resources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $apiKey,
 'Content-Type: application/json',
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

echo "Status: $httpCode\n";
echo $response . "\n";
?>

Error Handling

<?php
$apiKey = getenv('API_KEY') ?: 'YOUR_API_KEY';
$baseUrl = 'https://api.openai.com';

function callApiWithRetry($url, $headers, $maxRetries = 3) {
 $ch = curl_init();
 for ($attempt = 0; $attempt <= $maxRetries; $attempt++) {
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 if ($httpCode === 429) {
 sleep(60);
 continue;
 }
 if ($httpCode < 500) {
 break;
 }
 sleep(pow(2, $attempt));
 }
 curl_close($ch);
 return [$httpCode, $response];
}

$url = $baseUrl . '/v1/resources';
$headers = ['Authorization: Bearer ' . $apiKey, 'Content-Type: application/json'];
list($code, $resp) = callApiWithRetry($url, $headers);
echo "Status: $code\n";
echo $resp . "\n";
?>

Advanced Usage

<?php
class OpenaiClient {
 private $apiKey;
 private $baseUrl;

 public function __construct($apiKey, $baseUrl = 'https://api.openai.com') {
 $this->apiKey = $apiKey;
 $this->baseUrl = rtrim($baseUrl, '/');
 }

 public function request($method, $path, $data = null) {
 $ch = curl_init();
 $url = $this->baseUrl . '/v1' . $path;
 curl_setopt($ch, CURLOPT_URL, $url);
 curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 curl_setopt($ch, CURLOPT_HTTPHEADER, [
 'Authorization: Bearer ' . $this->apiKey,
 'Content-Type: application/json',
 ]);
 curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
 if ($data !== null) {
 curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 }
 $response = curl_exec($ch);
 $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 curl_close($ch);
 if ($httpCode >= 400) {
 throw new Exception("API Error: HTTP $httpCode");
 }
 return json_decode($response, true);
 }

 public function listResources($params = []) {
 $query = http_build_query($params);
 $path = '/resources' . ($query ? '?' . $query : '');
 return $this->request('GET', $path);
 }

 public function createResource($data) {
 return $this->request('POST', '/resources', $data);
 }
}

$client = new OpenaiClient(getenv('API_KEY') ?: 'YOUR_API_KEY');
$resources = $client->listResources(['limit' => 50]);
echo "Found " . count($resources['data'] ?? []) . " resources\n";
?>

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Python

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Python

This guide shows you how to integrate the OpenAI API into your Python application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Python installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

pip install requests python-dotenv

Basic Usage

import os
import requests

API_KEY = os.environ.get("API_KEY", "YOUR_API_KEY")
BASE_URL = "https://api.openai.com"

headers = {
 "Authorization": f"Bearer {API_KEY}",
 "Content-Type": "application/json"
}

response = requests.get(f"{BASE_URL}/v1/resources", headers=headers)
print(f"Status: {response.status_code}")
print(response.json())

Error Handling

import requests
import time

def call_api_with_retry(url, headers, max_retries=3):
 for attempt in range(max_retries):
 try:
 response = requests.get(url, headers=headers, timeout=30)
 if response.status_code == 429:
 retry_after = int(response.headers.get("Retry-After", 60))
 print(f"Rate limited. Waiting {retry_after}s...")
 time.sleep(retry_after)
 continue
 response.raise_for_status()
 return response.json()
 except requests.exceptions.Timeout:
 print(f"Timeout on attempt {attempt + 1}")
 except requests.exceptions.RequestException as e:
 print(f"Error: {e}")
 if attempt == max_retries - 1:
 raise
 time.sleep(2 ** attempt)

result = call_api_with_retry(
 f"{BASE_URL}/v1/resources",
 headers={"Authorization": f"Bearer {API_KEY}"}
)

Advanced Usage

import os
import requests
from typing import Optional, Dict, List
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class OpenaiClient:
 """Advanced client for OpenAI API."""

 def __init__(self, api_key: str, base_url: str = "https://api.openai.com"):
 self.api_key = api_key
 self.base_url = base_url.rstrip("/")
 self.session = requests.Session()
 self.session.headers.update({
 "Authorization": f"Bearer {api_key}",
 "Content-Type": "application/json",
 "User-Agent": "OpenAI API/1.0"
 })

 def list_resources(self, params: Dict = None) -> List[Dict]:
 """List resources with pagination."""
 all_results = []
 cursor = None
 while True:
 if cursor:
 params = params or {}
 params["cursor"] = cursor
 response = self.session.get(
 f"{self.base_url}/v1/resources",
 params=params,
 timeout=30
 )
 response.raise_for_status()
 data = response.json()
 all_results.extend(data.get("data", []))
 cursor = data.get("next_cursor")
 if not cursor:
 break
 return all_results

 def create_resource(self, data: Dict) -> Dict:
 """Create a new resource."""
 response = self.session.post(
 f"{self.base_url}/v1/resources",
 json=data,
 timeout=30
 )
 response.raise_for_status()
 return response.json()

client = OpenaiClient(os.environ["API_KEY"])
resources = client.list_resources(params={"limit": 50})
print(f"Found {len(resources)} resources")

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Ruby

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Ruby

This guide shows you how to integrate the OpenAI API into your Ruby application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Ruby installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

gem install httparty

Basic Usage

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

api_key = ENV['API_KEY'] || 'YOUR_API_KEY'
base_url = 'https://api.openai.com'
uri = URI("#{base_url}/v1/resources")

request = Net::HTTP::Get.new(uri)
request['Authorization'] = "Bearer #{api_key}"
request['Content-Type'] = 'application/json'

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
end

puts "Status: #{response.code}"
puts response.body

Error Handling

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

def call_api_with_retry(url, headers, max_retries = 3)
 uri = URI(url)
 max_retries.times do |attempt|
 request = Net::HTTP::Get.new(uri)
 headers.each { |k, v| request[k] = v }
 response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
 http.request(request)
 end
 if response.code == '429'
 sleep(60)
 next
 end
 return response unless response.code.to_i >= 500
 sleep(2 ** attempt)
 end
 raise "Max retries exceeded"
end

url = 'https://api.openai.com/v1/resources'
headers = { 'Authorization' => "Bearer #{ENV['API_KEY']}", 'Content-Type' => 'application/json' }
response = call_api_with_retry(url, headers)
puts response.body

Advanced Usage

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

class OpenaiClient
 def initialize(api_key, base_url = 'https://api.openai.com')
 @api_key = api_key
 @base_url = base_url.chomp('/')
 end

 def request(method, path, body = nil)
 uri = URI("#{@base_url}/v1#{path}")
 http = Net::HTTP.new(uri.host, uri.port)
 http.use_ssl = uri.scheme == 'https'
 request_class = Net::HTTP.const_get(method.capitalize)
 request = request_class.new(uri)
 request['Authorization'] = "Bearer #{@api_key}"
 request['Content-Type'] = 'application/json'
 request.body = body.to_json if body
 response = http.request(request)
 raise "API Error: #{response.code}" if response.code.to_i >= 400
 JSON.parse(response.body)
 end

 def list_resources(params = {})
 query = URI.encode_www_form(params)
 path = "/resources#{query.empty? ? '' : '?' + query}"
 request('get', path)
 end

 def create_resource(data)
 request('post', '/resources', data)
 end
end

client = OpenaiClient.new(ENV['API_KEY'] || 'YOUR_API_KEY')
resources = client.list_resources(limit: 50)
puts "Found #{resources['data']&.length || 0} resources"

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Rust

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Rust

This guide shows you how to integrate the OpenAI API into your Rust application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Rust installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

cargo add reqwest --features json
cargo add tokio --features full

Basic Usage

use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.openai.com";
 let url = format!("{}/v1/resources", base_url);

 let client = reqwest::Client::new();
 let resp = client
 .get(&url)
 .bearer_auth(&api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;

 println!("Status: {}", resp.status());
 let body = resp.text().await?;
 println!("{}", body);
 Ok(())
}

Error Handling

use std::time::Duration;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
 let api_key = env::var("API_KEY").unwrap_or_else(|_| "YOUR_API_KEY".to_string());
 let base_url = "https://api.openai.com";

 let client = reqwest::Client::builder()
 .timeout(Duration::from_secs(30))
 .build()?;

 let mut attempt = 0;
 let max_retries = 3;
 loop {
 let resp = client
 .get(format!("{}/v1/resources", base_url))
 .bearer_auth(&api_key)
 .send()
 .await?;

 if resp.status().as_u16() == 429 {
 println!("Rate limited. Waiting 60s...");
 tokio::time::sleep(Duration::from_secs(60)).await;
 continue;
 }

 if resp.status().is_success() {
 let body = resp.text().await?;
 println!("{}", body);
 return Ok(());
 }

 attempt += 1;
 if attempt >= max_retries {
 return Err(format!("HTTP {}", resp.status()).into());
 }
 tokio::time::sleep(Duration::from_secs(2u64.pow(attempt))).await;
 }
}

Advanced Usage

use std::env;
use reqwest::{Client, Method};
use std::error::Error;

pub struct OpenaiClient {
 client: Client,
 api_key: String,
 base_url: String,
}

impl OpenaiClient {
 pub fn new(api_key: String, base_url: String) -> Self {
 Self {
 client: Client::new(),
 api_key,
 base_url: base_url.trim_end_matches('/').to_string(),
 }
 }

 pub async fn request(&self, method: Method, path: &str) -> Result<String, Box<dyn Error>> {
 let url = format!("{}/v1{}", self.base_url, path);
 let resp = self.client
 .request(method, &url)
 .bearer_auth(&self.api_key)
 .header("Content-Type", "application/json")
 .send()
 .await?;
 if !resp.status().is_success() {
 return Err(format!("API Error: HTTP {}", resp.status()).into());
 }
 Ok(resp.text().await?)
 }

 pub async fn list_resources(&self) -> Result<String, Box<dyn Error>> {
 self.request(Method::GET, "/resources").await
 }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
 let client = OpenaiClient::new(
 env::var("API_KEY")?,
 "https://api.openai.com".to_string(),
 );
 let resources = client.list_resources().await?;
 println!("{}", resources);
 Ok(())
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

OpenAI API API in Swift

Sat, 25 Jul 2026 00:00:00 +0000

OpenAI API API in Swift

This guide shows you how to integrate the OpenAI API into your Swift application. GPT-4, GPT-3.5, DALL-E, Whisper, and Embeddings API for natural language processing, image generation, and speech recognition.

Prerequisites

Swift installed on your system
An OpenAI API API key (sign up at https://platform.openai.com)
Basic familiarity with HTTP APIs

Installation

// Use URLSession (built-in) or Swift Package Manager:
// .package(url: "https://github.com/Alamofire/Alamofire", from: "5.0.0")

Basic Usage

import Foundation

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let baseURL = "https://api.openai.com"
let url = URL(string: "\(baseURL)/v1/resources")!

var request = URLRequest(url: url)
request.httpMethod = "GET"
request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")

let task = URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error {
 print("Error: \(error)")
 return
 }
 if let httpResponse = response as? HTTPURLResponse {
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) {
 print(body)
 }
}

task.resume()
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Error Handling

import Foundation

func callAPIWithRetry(url: URL, headers: [String: String]) {
 func attemptRequest() {
 var request = URLRequest(url: url)
 request.httpMethod = "GET"
 for (k, v) in headers { request.setValue(v, forHTTPHeaderField: k) }
 URLSession.shared.dataTask(with: request) { data, response, error in
 if let error = error { print("Error: \(error)"); return }
 if let httpResponse = response as? HTTPURLResponse {
 if httpResponse.statusCode == 429 {
 print("Rate limited. Waiting 60s...")
 DispatchQueue.global().asyncAfter(deadline: .now() + .seconds(60)) { attemptRequest() }
 return
 }
 print("Status: \(httpResponse.statusCode)")
 }
 if let data = data, let body = String(data: data, encoding: .utf8) { print(body) }
 }.resume()
 }
 attemptRequest()
 RunLoop.main.run(until: Date(timeIntervalSinceNow: 60))
}

let apiKey = ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY"
let url = URL(string: "https://api.openai.com/v1/resources")!
callAPIWithRetry(url: url, headers: ["Authorization": "Bearer \(apiKey)", "Content-Type": "application/json"])

Advanced Usage

import Foundation

class OpenaiClient {
 let apiKey: String
 let baseURL: String
 let session: URLSession

 init(apiKey: String, baseURL: String = "https://api.openai.com") {
 self.apiKey = apiKey
 self.baseURL = baseURL.hasSuffix("/") ? String(baseURL.dropLast()) : baseURL
 self.session = URLSession.shared
 }

 func request(method: String, path: String, completion: @escaping (Result<Data, Error>) -> Void) {
 let urlString = "\(baseURL)/v1\(path)"
 guard let url = URL(string: urlString) else {
 completion(.failure(NSError(domain: "InvalidURL", code: 0)))
 return
 }
 var request = URLRequest(url: url)
 request.httpMethod = method
 request.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
 request.setValue("application/json", forHTTPHeaderField: "Content-Type")
 session.dataTask(with: request) { data, response, error in
 if let error = error { completion(.failure(error)); return }
 if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode >= 400 {
 completion(.failure(NSError(domain: "APIError", code: httpResponse.statusCode))); return
 }
 completion(.success(data ?? Data()))
 }.resume()
 }

 func listResources(completion: @escaping (Result<Data, Error>) -> Void) {
 request(method: "GET", path: "/resources", completion: completion)
 }
}

let client = OpenaiClient(apiKey: ProcessInfo.processInfo.environment["API_KEY"] ?? "YOUR_API_KEY")
client.listResources { result in
 switch result {
 case .success(let data): print("Got \(data.count) bytes")
 case .failure(let error): print("Error: \(error)")
 }
}
RunLoop.main.run(until: Date(timeIntervalSinceNow: 10))

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

PayPal API API in C#

Sat, 25 Jul 2026 00:00:00 +0000

PayPal API API in C#

This guide shows you how to integrate the PayPal API into your C# application. PayPal Checkout, Subscriptions, Payouts, and Invoicing APIs for global payments.

Prerequisites

C# installed on your system
An PayPal API API key (sign up at https://developer.paypal.com)
Basic familiarity with HTTP APIs

Installation

dotnet add package RestSharp
dotnet add package Newtonsoft.Json

Basic Usage

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";
 private static readonly string BaseUrl = "https://api.paypal.com";

 static async Task Main(string[] args) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 var response = await client.GetAsync($"{BaseUrl}/v1/resources");
 Console.WriteLine($"Status: {(int)response.StatusCode}");
 var body = await response.Content.ReadAsStringAsync();
 Console.WriteLine(body);
 }
}

Error Handling

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

class Program {
 private static readonly string ApiKey = Environment.GetEnvironmentVariable("API_KEY") ?? "YOUR_API_KEY";

 static async Task<string> CallApiWithRetry(string url, int maxRetries = 3) {
 using var client = new HttpClient();
 client.DefaultRequestHeaders.Add("Authorization", $"Bearer {ApiKey}");

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 var response = await client.GetAsync(url);

 if ((int)response.StatusCode == 429) {
 Console.WriteLine("Rate limited. Waiting...");
 await Task.Delay(60000);
 continue;
 }

 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 } catch (Exception e) {
 Console.WriteLine($"Attempt {attempt + 1} failed: {e.Message}");
 if (attempt == maxRetries - 1) throw;
 await Task.Delay((int)Math.Pow(2, attempt) * 1000);
 }
 }
 throw new Exception("Max retries exceeded");
 }

 static async Task Main() {
 var result = await CallApiWithRetry("https://api.paypal.com/v1/resources");
 Console.WriteLine(result);
 }
}

Advanced Usage

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;

public class PaypalClient {
 private readonly string _apiKey;
 private readonly string _baseUrl;
 private readonly HttpClient _httpClient;

 public PaypalClient(string apiKey, string baseUrl = "https://api.paypal.com") {
 _apiKey = apiKey;
 _baseUrl = baseUrl.TrimEnd('/');
 _httpClient = new HttpClient { Timeout = TimeSpan.FromSeconds(30) };
 _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {_apiKey}");
 _httpClient.DefaultRequestHeaders.Add("User-Agent", "PayPal API/1.0");
 }

 public async Task<string> ListResourcesAsync() {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> CreateResourceAsync(object data) {
 var json = JsonSerializer.Serialize(data);
 var content = new StringContent(json, Encoding.UTF8, "application/json");
 var response = await _httpClient.PostAsync($"{_baseUrl}/v1/resources", content);
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }

 public async Task<string> GetResourceAsync(string id) {
 var response = await _httpClient.GetAsync($"{_baseUrl}/v1/resources/{id}");
 response.EnsureSuccessStatusCode();
 return await response.Content.ReadAsStringAsync();
 }
}

class Program {
 static async Task Main() {
 var client = new PaypalClient(Environment.GetEnvironmentVariable("API_KEY")!);
 var resources = await client.ListResourcesAsync();
 Console.WriteLine(resources);
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

PayPal API API in Go

Sat, 25 Jul 2026 00:00:00 +0000

PayPal API API in Go

This guide shows you how to integrate the PayPal API into your Go application. PayPal Checkout, Subscriptions, Payouts, and Invoicing APIs for global payments.

Prerequisites

Go installed on your system
An PayPal API API key (sign up at https://developer.paypal.com)
Basic familiarity with HTTP APIs

Installation

go mod init myapp
go get github.com/go-resty/resty/v2

Basic Usage

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
)

func main() {
 apiKey := os.Getenv("API_KEY")
 if apiKey == "" {
 apiKey = "YOUR_API_KEY"
 }
 baseURL := "https://api.paypal.com"

 req, _ := http.NewRequest("GET", baseURL+"/v1/resources", nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 defer resp.Body.Close()

 body, _ := io.ReadAll(resp.Body)
 fmt.Println("Status:", resp.Status)
 fmt.Println(string(body))
}

Error Handling

package main

import (
 "fmt"
 "io"
 "net/http"
 "os"
 "time"
)

func callAPIWithRetry(url, apiKey string, maxRetries int) ([]byte, error) {
 var lastErr error
 for attempt := 0; attempt < maxRetries; attempt++ {
 req, _ := http.NewRequest("GET", url, nil)
 req.Header.Set("Authorization", "Bearer "+apiKey)

 resp, err := http.DefaultClient.Do(req)
 if err != nil {
 lastErr = err
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 if resp.StatusCode == 429 {
 retryAfter := resp.Header.Get("Retry-After")
 fmt.Println("Rate limited. Retry-After:", retryAfter)
 resp.Body.Close()
 time.Sleep(60 * time.Second)
 continue
 }

 if resp.StatusCode >= 400 {
 body, _ := io.ReadAll(resp.Body)
 resp.Body.Close()
 lastErr = fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
 time.Sleep(time.Duration(1<<attempt) * time.Second)
 continue
 }

 body, err := io.ReadAll(resp.Body)
 resp.Body.Close()
 return body, err
 }
 return nil, lastErr
}

func main() {
 apiKey := os.Getenv("API_KEY")
 body, err := callAPIWithRetry("https://api.paypal.com/v1/resources", apiKey, 3)
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(body))
}

Advanced Usage

package main

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

type PaypalClient struct {
 APIKey string
 BaseURL string
 HTTP *http.Client
}

func NewClient(apiKey, baseURL string) *PaypalClient {
 return &PaypalClient{
 APIKey: apiKey,
 BaseURL: baseURL,
 HTTP: &http.Client{Timeout: 30 * time.Second},
 }
}

func (c *PaypalClient) do(method, path string, body interface{}) ([]byte, error) {
 var reqBody io.Reader
 if body != nil {
 jsonData, _ := json.Marshal(body)
 reqBody = bytes.NewBuffer(jsonData)
 }
 req, _ := http.NewRequest(method, c.BaseURL+path, reqBody)
 req.Header.Set("Authorization", "Bearer "+c.APIKey)
 req.Header.Set("Content-Type", "application/json")

 resp, err := c.HTTP.Do(req)
 if err != nil {
 return nil, err
 }
 defer resp.Body.Close()

 return io.ReadAll(resp.Body)
}

func (c *PaypalClient) ListResources() ([]byte, error) {
 return c.do("GET", "/v1/resources", nil)
}

func (c *PaypalClient) CreateResource(data map[string]interface{}) ([]byte, error) {
 return c.do("POST", "/v1/resources", data)
}

func main() {
 client := NewClient(os.Getenv("API_KEY"), "https://api.paypal.com")
 resources, err := client.ListResources()
 if err != nil {
 fmt.Println("Error:", err)
 return
 }
 fmt.Println(string(resources))
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

PayPal API API in Java

Sat, 25 Jul 2026 00:00:00 +0000

PayPal API API in Java

This guide shows you how to integrate the PayPal API into your Java application. PayPal Checkout, Subscriptions, Payouts, and Invoicing APIs for global payments.

Prerequisites

Java installed on your system
An PayPal API API key (sign up at https://developer.paypal.com)
Basic familiarity with HTTP APIs

Installation

<!-- Maven -->
<dependency>
 <groupId>com.squareup.okhttp3</groupId>
 <artifactId>okhttp</artifactId>
 <version>4.12.0</version>
</dependency>

Basic Usage

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");
 private static final String BASE_URL = "https://api.paypal.com";

 public static void main(String[] args) throws Exception {
 HttpClient client = HttpClient.newHttpClient();
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(BASE_URL + "/v1/resources"))
 .header("Authorization", "Bearer " + API_KEY)
 .header("Content-Type", "application/json")
 .GET()
 .build();

 HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
 System.out.println("Status: " + response.statusCode());
 System.out.println(response.body());
 }
}

Error Handling

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

public class Main {
 private static final String API_KEY = System.getenv().getOrDefault("API_KEY", "YOUR_API_KEY");

 public static String callApiWithRetry(String url, int maxRetries) throws Exception {
 HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

 for (int attempt = 0; attempt < maxRetries; attempt++) {
 try {
 HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create(url))
 .header("Authorization", "Bearer " + API_KEY)
 .timeout(Duration.ofSeconds(30))
 .GET()
 .build();

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

 if (response.statusCode() == 429) {
 System.out.println("Rate limited. Waiting...");
 Thread.sleep(60000);
 continue;
 }

 if (response.statusCode() >= 400) {
 throw new RuntimeException("HTTP " + response.statusCode() + ": " + response.body());
 }

 return response.body();
 } catch (Exception e) {
 System.err.println("Attempt " + (attempt + 1) + " failed: " + e.getMessage());
 if (attempt == maxRetries - 1) throw e;
 Thread.sleep((long) Math.pow(2, attempt) * 1000);
 }
 }
 throw new RuntimeException("Max retries exceeded");
 }

 public static void main(String[] args) throws Exception {
 String result = callApiWithRetry("https://api.paypal.com/v1/resources", 3);
 System.out.println(result);
 }
}

Advanced Usage

import com.google.gson.Gson;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
import java.util.Map;

public class PaypalClient {
 private final String apiKey;
 private final String baseUrl;
 private final HttpClient httpClient;
 private final Gson gson = new Gson();

 public PaypalClient(String apiKey, String baseUrl) {
 this.apiKey = apiKey;
 this.baseUrl = baseUrl.replaceAll("/$", "");
 this.httpClient = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();
 }

 public String listResources() throws Exception {
 return request("GET", "/v1/resources", null);
 }

 public String createResource(Map<String, Object> data) throws Exception {
 return request("POST", "/v1/resources", gson.toJson(data));
 }

 private String request(String method, String path, String body) throws Exception {
 HttpRequest.Builder builder = HttpRequest.newBuilder()
 .uri(URI.create(baseUrl + path))
 .header("Authorization", "Bearer " + apiKey)
 .header("Content-Type", "application/json")
 .timeout(Duration.ofSeconds(30));

 if (body != null) {
 builder.method(method, HttpRequest.BodyPublishers.ofString(body));
 } else {
 builder.method(method, HttpRequest.BodyPublishers.noBody());
 }

 HttpResponse<String> response = httpClient.send(builder.build(), HttpResponse.BodyHandlers.ofString());

 if (response.statusCode() >= 400) {
 throw new RuntimeException("API Error: " + response.statusCode() + " - " + response.body());
 }

 return response.body();
 }

 public static void main(String[] args) throws Exception {
 PaypalClient client = new PaypalClient(
 System.getenv("API_KEY"), "https://api.paypal.com"
 );
 System.out.println(client.listResources());
 }
}

Best Practices

Store your API key in an environment variable, never in source code
Implement retry logic with exponential backoff for 429 and 5xx errors
Set reasonable timeouts (10-30 seconds) for all API calls
Log request IDs from response headers for debugging
Cache responses where appropriate to reduce API calls

Code Samples on APIHub - Global API Directory

Airtable API API in C#

Airtable API API in C#

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Go

Airtable API API in Go

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Java

Airtable API API in Java

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in JavaScript

Airtable API API in JavaScript

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Kotlin

Airtable API API in Kotlin

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in PHP

Airtable API API in PHP

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Python

Airtable API API in Python

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Ruby

Airtable API API in Ruby

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage

Best Practices

Related

Airtable API API in Rust

Airtable API API in Rust

Prerequisites

Installation

Basic Usage

Error Handling

Advanced Usage