Rate Limits

async function makeRequestWithRetry(url, options, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      // Check rate limit headers
      const remaining = response.headers.get('X-RateLimit-Remaining');
      const resetTime = response.headers.get('X-RateLimit-Reset');
      
      if (response.status === 429) {
        const retryAfter = response.headers.get('X-RateLimit-Retry-After');
        console.log(`Rate limited. Retrying in ${retryAfter} seconds...`);
        
        if (attempt < maxRetries) {
          await new Promise(resolve => setTimeout(resolve, retryAfter * 1000));
          continue;
        }
        throw new Error('Rate limit exceeded after max retries');
      }
      
      // Log remaining requests
      console.log(`Requests remaining: ${remaining}`);
      
      return response;
    } catch (error) {
      if (attempt === maxRetries) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000));
    }
  }
}

// Usage example
const response = await makeRequestWithRetry('https://api.veo3gen.co/v1/generate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    prompt: "A serene sunset over mountains",
    model: "veo-3.0-generate"
  })
});

import requests
import time
from typing import Dict, Any

class VEO3Client:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.veo3gen.co/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
    
    def make_request_with_retry(self, endpoint: str, data: Dict[Any, Any], max_retries: int = 3):
        url = f"{self.base_url}/{endpoint}"
        
        for attempt in range(max_retries + 1):
            try:
                response = requests.post(url, json=data, headers=self.headers)
                
                # Check rate limit headers
                remaining = response.headers.get('X-RateLimit-Remaining')
                reset_time = response.headers.get('X-RateLimit-Reset')
                
                if response.status_code == 429:
                    retry_after = int(response.headers.get('X-RateLimit-Retry-After', 60))
                    print(f"Rate limited. Retrying in {retry_after} seconds...")
                    
                    if attempt < max_retries:
                        time.sleep(retry_after)
                        continue
                    else:
                        raise Exception("Rate limit exceeded after max retries")
                
                # Log remaining requests
                print(f"Requests remaining: {remaining}")
                
                response.raise_for_status()
                return response.json()
                
            except requests.exceptions.RequestException as e:
                if attempt == max_retries:
                    raise e
                time.sleep(1)
    
    def generate_video(self, prompt: str, model: str = "veo-3.0-generate"):
        data = {
            "prompt": prompt,
            "model": model
        }
        return self.make_request_with_retry("generate", data)

# Usage
client = VEO3Client("YOUR_API_KEY")
result = client.generate_video("A serene sunset over mountains")

#!/bin/bash

API_KEY="YOUR_API_KEY"
BASE_URL="https://api.veo3gen.co/v1"
MAX_RETRIES=3

make_request() {
  local endpoint=$1
  local data=$2
  local retry_count=0
  
  while [ $retry_count -le $MAX_RETRIES ]; do
    response=$(curl -s -w "%{http_code}" -H "Authorization: Bearer $API_KEY" \
      -H "Content-Type: application/json" \
      -H "X-RateLimit-Remaining:" \
      -H "X-RateLimit-Reset:" \
      -H "X-RateLimit-Retry-After:" \
      -d "$data" \
      "$BASE_URL/$endpoint")
    
    http_code=$(echo "$response" | tail -c 4)
    body=$(echo "$response" | head -c -4)
    
    if [ "$http_code" -eq 429 ]; then
      retry_after=$(echo "$response" | grep -o 'X-RateLimit-Retry-After: [0-9]*' | cut -d' ' -f2)
      echo "Rate limited. Retrying in $retry_after seconds..."
      sleep $retry_after
      ((retry_count++))
    elif [ "$http_code" -eq 200 ]; then
      echo "$body"
      return 0
    else
      echo "Error: HTTP $http_code"
      echo "$body"
      return 1
    fi
  done
  
  echo "Max retries exceeded"
  return 1
}

# Usage
data='{"prompt": "A serene sunset over mountains", "model": "veo-3.0-generate"}'
make_request "generate" "$data"