# Advanced Examples

## Error Handling

### Python with Error Handling

```python
import requests
from requests.exceptions import RequestException, Timeout

def api_request(method, endpoint, data=None, timeout=5):
    """Make API request with comprehensive error handling."""
    url = f"{BASE_URL}{endpoint}"
    
    try:
        if method == "GET":
            response = requests.get(url, headers=headers, timeout=timeout)
        elif method == "POST":
            response = requests.post(url, json=data, headers=headers, timeout=timeout)
        
        response.raise_for_status()
        return response.json()
    
    except Timeout:
        print("Error: Request timed out")
        return None
    except requests.HTTPError as e:
        print(f"HTTP Error: {e.response.status_code}")
        return None
    except RequestException as e:
        print(f"Request Error: {e}")
        return None

# Usage
result = api_request("GET", "/resources")
```

## Pagination

### Handling Large Result Sets

```python
def list_all_resources(page_size=100):
    """Fetch all resources with pagination."""
    page = 1
    all_resources = []
    
    while True:
        response = requests.get(
            f"{BASE_URL}/resources",
            params={
                "page": page,
                "limit": page_size
            },
            headers=headers
        )
        
        data = response.json()["data"]
        if not data:
            break
        
        all_resources.extend(data)
        page += 1
    
    return all_resources

# Usage
resources = list_all_resources()
print(f"Total resources: {len(resources)}")
```

## Batch Operations

```python
def batch_create_resources(resource_list):
    """Create multiple resources efficiently."""
    created = []
    failed = []
    
    for resource in resource_list:
        try:
            response = requests.post(
                f"{BASE_URL}/resources",
                json=resource,
                headers=headers
            )
            response.raise_for_status()
            created.append(response.json()["data"])
        except requests.HTTPError as e:
            failed.append({
                "resource": resource,
                "error": str(e)
            })
    
    return {
        "created": created,
        "failed": failed
    }

# Usage
resources_to_create = [
    {"name": "Resource 1", "type": "doc"},
    {"name": "Resource 2", "type": "api"}
]

result = batch_create_resources(resources_to_create)
```

## Async Operations (JavaScript)

```javascript
// Concurrent API calls
async function fetchMultipleResources(ids) {
  const promises = ids.map(id =>
    fetch(`${BASE_URL}/resources/${id}`, {
      headers: { "Authorization": `Bearer ${API_KEY}` }
    }).then(r => r.json())
  );

  return Promise.all(promises);
}

// Usage
const ids = ["res_123", "res_124", "res_125"];
const resources = await fetchMultipleResources(ids);
```