Code Examples

# Python with requests
import requests

url = 'https://api.acme.com/users'
headers = {
    'Content-Type': 'application/json',
    'Authorization': f'Bearer {api_token}'
}
data = {
    'name': 'John Doe',
    'email': 'john@acme.com'
}

response = requests.post(url, json=data, headers=headers)
user = response.json()
print(f'Created user: {user}')

// Go with net/http
package main

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

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    user := User{
        Name:  "John Doe", 
        Email: "john@acme.com",
    }
    
    jsonData, _ := json.Marshal(user)
    
    req, _ := http.NewRequest("POST", "https://api.acme.com/users", 
        bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Authorization", "Bearer " + apiToken)
    
    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

# cURL command
curl -X POST https://api.acme.com/users \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "name": "John Doe",
    "email": "john@acme.com"
  }'

# Ruby - elegant and readable
class UserService
  def create_user(name:, email:)
    response = HTTParty.post(
      "#{API_BASE_URL}/users",
      body: { name: name, email: email }.to_json,
      headers: {
        'Content-Type' => 'application/json',
        'Authorization' => "Bearer #{api_token}"
      }
    )
    
    JSON.parse(response.body)
  end
end

<?php
// PHP - server-side integration
class UserService {
    private $apiToken;
    
    public function __construct($apiToken) {
        $this->apiToken = $apiToken;
    }
    
    public function createUser($name, $email) {
        $data = json_encode([
            'name' => $name,
            'email' => $email
        ]);
        
        $context = stream_context_create([
            'http' => [
                'method' => 'POST',
                'header' => "Content-Type: application/json\r
" .
                           "Authorization: Bearer {$this->apiToken}\r
",
                'content' => $data
            ]
        ]);
        
        return json_decode(
            file_get_contents('https://api.acme.com/users', false, $context),
            true
        );
    }
}
?>

// Authentication and token management  
class AuthManager {
  constructor(clientId, clientSecret) {
    this.clientId = clientId;
    this.clientSecret = clientSecret;
    this.token = null;
    this.refreshToken = null;
  }

  async authenticate() {
    const response = await fetch('/oauth/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        grant_type: 'client_credentials',
        client_id: this.clientId,
        client_secret: this.clientSecret
      })
    });

    const data = await response.json();
    this.token = data.access_token;
    this.refreshToken = data.refresh_token;
    
    return this.token;
  }
}

// Making authenticated API calls
class UserManager {
  constructor(authManager) {
    this.auth = authManager;
  }

  async getUser(userId) {
    const token = await this.auth.getValidToken();
    
    const response = await fetch(`/api/users/${userId}`, {
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new ApiError(`Failed to fetch user: ${response.status}`);
    }

    return response.json();
  }

  async updateUser(userId, updates) {
    const token = await this.auth.getValidToken();
    
    const response = await fetch(`/api/users/${userId}`, {
      method: 'PATCH',
      headers: {
        'Authorization': `Bearer ${token}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(updates)
    });

    return response.json();
  }
}

// Comprehensive error handling
class ApiError extends Error {
  constructor(message, status, response) {
    super(message);
    this.name = 'ApiError';
    this.status = status;
    this.response = response;
  }
}

async function handleApiCall(apiCall) {
  try {
    return await apiCall();
  } catch (error) {
    // Network errors
    if (!error.response) {
      console.error('Network error:', error.message);
      throw new ApiError('Network connection failed', 0, null);
    }

    // HTTP errors
    const { status, data } = error.response;
    
    switch (status) {
      case 401:
        // Token expired, try refresh
        await authManager.refreshToken();
        return apiCall(); // Retry once
        
      case 429:
        // Rate limited, wait and retry
        const retryAfter = error.response.headers['retry-after'] || 60;
        await sleep(retryAfter * 1000);
        return apiCall();
        
      case 500:
        console.error('Server error:', data);
        throw new ApiError('Server error occurred', status, data);
        
      default:
        throw new ApiError(`API error: ${data.message}`, status, data);
    }
  }
}

// Modern approach - async/await with proper error handling
async function getUserData(userId) {
  try {
    // Fetch all data in parallel for better performance
    const [user, profile, preferences] = await Promise.all([
      getUser(userId),
      getProfile(userId), 
      getPreferences(userId)
    ]);

    return {
      user,
      profile, 
      preferences
    };
  } catch (error) {
    // Centralized error handling with context
    throw new UserDataError(
      `Failed to fetch user data for ${userId}: ${error.message}`,
      { userId, originalError: error }
    );
  }
}