[Verse 1]
Walking down the street at night
City lights are shining bright
Feeling free, feeling alive
This is where my dreams survive

[Chorus]
We're dancing in the moonlight
Everything feels so right
Let the music take control
Feel it deep within your soul

[Verse 2]
Hearts are beating to the sound
Magic happens all around
In this moment we belong
Living life just like a song

https://api.yourdomain.com/v1

https://eu.api.yourdomain.com/v1

https://us.api.yourdomain.com/v1

curl https://api.yourdomain.com/v1/credits \
  -H "Authorization: Bearer sk_live_abc123..."

POST /v1/imageai
Content-Type: multipart/form-data

{
  "image": [binary],
  "prompt": "Remove background",
  "webhook_url": "https://yourapp.com/webhooks/metaborg"
}

Response 202 Accepted:
{
  "job_id": "job_abc123xyz",
  "status": "queued",
  "created_at": "2025-01-24T10:30:00Z",
  "estimated_time": 15
}

GET /v1/jobs/job_abc123xyz

Response 200 OK:
{
  "job_id": "job_abc123xyz",
  "status": "processing",
  "progress": 0.65,
  "created_at": "2025-01-24T10:30:00Z",
  "started_at": "2025-01-24T10:30:02Z"
}

GET /v1/jobs/job_abc123xyz

Response 200 OK:
{
  "job_id": "job_abc123xyz",
  "status": "completed",
  "result": {
    "url": "https://cdn.metaborg.app/results/xyz.png",
    "expires_at": "2025-01-31T10:30:00Z",
    "size_bytes": 2456789,
    "width": 1024,
    "height": 768,
    "format": "png"
  },
  "credits_used": 1,
  "processing_time_ms": 12450,
  "completed_at": "2025-01-24T10:30:15Z"
}

{
  "url": "https://yourapp.com/webhooks/metaborg",
  "events": ["job.completed", "job.failed"],
  "secret": "whsec_abc123..." // Pour vérifier la signature
}

Response 201 Created:
{
  "webhook_id": "wh_xyz789",
  "url": "https://yourapp.com/webhooks/metaborg",
  "events": ["job.completed", "job.failed"],
  "created_at": "2025-01-24T10:30:00Z"
}

POST https://yourapp.com/webhooks/metaborg
Content-Type: application/json
X-Metaborg-Signature: sha256=abc123...
X-Metaborg-Event: job.completed

{
  "event": "job.completed",
  "timestamp": "2025-01-24T10:30:15Z",
  "data": {
    "job_id": "job_abc123xyz",
    "status": "completed",
    "result": {
      "url": "https://cdn.metaborg.app/results/xyz.png",
      "expires_at": "2025-01-31T10:30:00Z"
    },
    "credits_used": 1
  }
}

const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const digest = 'sha256=' + hmac.update(payload).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(digest)
  );
}

app.post('/webhooks/metaborg', (req, res) => {
  const signature = req.headers['x-metaborg-signature'];
  const payload = JSON.stringify(req.body);
  
  if (!verifyWebhook(payload, signature, WEBHOOK_SECRET)) {
    return res.status(401).send('Invalid signature');
  }
  
  // Traiter l'événement
  const { event, data } = req.body;
  if (event === 'job.completed') {
    console.log('Job completed:', data.job_id);
    // Télécharger le résultat, notifier l'utilisateur, etc.
  }
  
  res.status(200).send('OK');
});

curl -X POST https://api.yourdomain.com/v1/imageai \
  -H "Authorization: Bearer sk_live_..." \
  -H "Idempotency-Key: 550e8400-e29b-41d4-a716-446655440000" \
  -F "image=@photo.jpg"

X-RateLimit-Limit: 60          # Requêtes max par minute
X-RateLimit-Remaining: 42      # Requêtes restantes
X-RateLimit-Reset: 1706089200  # Timestamp de reset (Unix)
Retry-After: 18                # Secondes avant retry (si 429)

import time
import requests

def api_call_with_retry(url, max_retries=5):
    for attempt in range(max_retries):
        response = requests.get(url, headers={'Authorization': f'Bearer {API_KEY}'})
        
        if response.status_code == 200:
            return response.json()
        
        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 60))
            wait_time = min(retry_after * (2 ** attempt), 300)  # Max 5 min
            print(f"Rate limited. Waiting {wait_time}s...")
            time.sleep(wait_time)
            continue
        
        response.raise_for_status()
    
    raise Exception('Max retries exceeded')

{
  "error": {
    "code": "insufficient_credits",
    "message": "You don't have enough credits for this operation",
    "details": {
      "required": 3,
      "available": 1
    },
    "request_id": "req_abc123xyz",
    "documentation_url": "https://docs.metaborg.app/errors/insufficient_credits"
  }
}

{
  "data": [ /* 50 jobs */ ],
  "pagination": {
    "next_cursor": "cur_xyz789",
    "has_more": true
  }
}

// Page suivante
GET /v1/jobs?limit=50&cursor=cur_xyz789

https://api.yourdomain.com/openapi.json

npm install axios form-data dotenv
# Pour TypeScript
npm install --save-dev @types/node @types/axios

import axios, { AxiosInstance, AxiosError } from 'axios';
import FormData from 'form-data';
import fs from 'fs';
import crypto from 'crypto';

interface MetaborgConfig {
  apiKey: string;
  baseURL?: string;
  timeout?: number;
  maxRetries?: number;
}

interface JobResponse {
  job_id: string;
  status: 'queued' | 'processing' | 'completed' | 'failed';
  result?: {
    url: string;
    expires_at: string;
  };
  error?: string;
  credits_used?: number;
}

class MetaborgClient {
  private client: AxiosInstance;
  private maxRetries: number;

  constructor(config: MetaborgConfig) {
    this.maxRetries = config.maxRetries || 3;
    
    this.client = axios.create({
      baseURL: config.baseURL || 'https://api.yourdomain.com/v1',
      timeout: config.timeout || 30000,
      headers: {
        'Authorization': `Bearer ${config.apiKey}`,
        'User-Agent': 'MetaborgClient/1.0'
      }
    });

    // Interceptor pour retry automatique
    this.client.interceptors.response.use(
      response => response,
      async (error: AxiosError) => {
        const config = error.config;
        if (!config || !config.headers) return Promise.reject(error);

        // Retry sur 429 (Rate Limit)
        if (error.response?.status === 429) {
          const retryAfter = parseInt(error.response.headers['retry-after'] || '60');
          const attempt = (config as any).__retryCount || 0;
          
          if (attempt < this.maxRetries) {
            (config as any).__retryCount = attempt + 1;
            await this.sleep(retryAfter * 1000);
            return this.client.request(config);
          }
        }

        // Retry sur 5xx (Erreur serveur)
        if (error.response && error.response.status >= 500) {
          const attempt = (config as any).__retryCount || 0;
          
          if (attempt < this.maxRetries) {
            (config as any).__retryCount = attempt + 1;
            const delay = Math.min(1000 * Math.pow(2, attempt), 10000);
            await this.sleep(delay);
            return this.client.request(config);
          }
        }

        return Promise.reject(error);
      }
    );
  }

  private sleep(ms: number): Promise {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  private generateIdempotencyKey(): string {
    return crypto.randomUUID();
  }

  /**
   * Image IA - Retouche et modification d'images
   */
  async processImage(
    imagePath: string,
    options: {
      prompt?: string;
      webhook_url?: string;
      idempotency_key?: string;
    } = {}
  ): Promise {
    const form = new FormData();
    form.append('image', fs.createReadStream(imagePath));
    if (options.prompt) form.append('prompt', options.prompt);
    if (options.webhook_url) form.append('webhook_url', options.webhook_url);

    const response = await this.client.post('/imageai', form, {
      headers: {
        ...form.getHeaders(),
        'Idempotency-Key': options.idempotency_key || this.generateIdempotencyKey()
      }
    });

    return response.data;
  }

  /**
   * Vidéo IA - Transfert de mouvements
   */
  async processVideo(
    videoPath: string,
    imagePath: string,
    options: {
      webhook_url?: string;
      idempotency_key?: string;
    } = {}
  ): Promise {
    const form = new FormData();
    form.append('video', fs.createReadStream(videoPath));
    form.append('image', fs.createReadStream(imagePath));
    if (options.webhook_url) form.append('webhook_url', options.webhook_url);

    const response = await this.client.post('/videoai', form, {
      headers: {
        ...form.getHeaders(),
        'Idempotency-Key': options.idempotency_key || this.generateIdempotencyKey()
      }
    });

    return response.data;
  }

  /**
   * Text to Video - Génération vidéo depuis texte
   */
  async textToVideo(
    prompt: string,
    options: {
      webhook_url?: string;
      idempotency_key?: string;
    } = {}
  ): Promise {
    const response = await this.client.post('/text2video', {
      prompt,
      webhook_url: options.webhook_url
    }, {
      headers: {
        'Idempotency-Key': options.idempotency_key || this.generateIdempotencyKey()
      }
    });

    return response.data;
  }

  /**
   * Musique IA - Composition musicale
   */
  async generateMusic(
    prompt: string,
    options: {
      webhook_url?: string;
      idempotency_key?: string;
    } = {}
  ): Promise {
    const response = await this.client.post('/musicai', {
      prompt,
      webhook_url: options.webhook_url
    }, {
      headers: {
        'Idempotency-Key': options.idempotency_key || this.generateIdempotencyKey()
      }
    });

    return response.data;
  }

  /**
   * Vérifier le statut d'un job
   */
  async getJobStatus(jobId: string): Promise {
    const response = await this.client.get(`/jobs/${jobId}`);
    return response.data;
  }

  /**
   * Annuler un job en cours
   */
  async cancelJob(jobId: string): Promise {
    await this.client.post(`/jobs/${jobId}/cancel`);
  }

  /**
   * Attendre la complétion d'un job (polling)
   */
  async waitForCompletion(
    jobId: string,
    options: {
      pollInterval?: number;
      maxWaitTime?: number;
    } = {}
  ): Promise {
    const pollInterval = options.pollInterval || 5000;
    const maxWaitTime = options.maxWaitTime || 300000; // 5 min
    const startTime = Date.now();

    while (true) {
      const job = await this.getJobStatus(jobId);
      
      if (job.status === 'completed' || job.status === 'failed') {
        return job;
      }

      if (Date.now() - startTime > maxWaitTime) {
        throw new Error('Job timeout: max wait time exceeded');
      }

      await this.sleep(pollInterval);
    }
  }

  /**
   * Consulter le solde de crédits
   */
  async getCredits(): Promise<{ credits: number }> {
    const response = await this.client.get('/credits');
    return response.data;
  }

  /**
   * Vérifier la signature d'un webhook
   */
  verifyWebhookSignature(
    payload: string,
    signature: string,
    secret: string
  ): boolean {
    const hmac = crypto.createHmac('sha256', secret);
    const digest = 'sha256=' + hmac.update(payload).digest('hex');
    
    return crypto.timingSafeEqual(
      Buffer.from(signature),
      Buffer.from(digest)
    );
  }
}

export default MetaborgClient;

import MetaborgClient from './metaborg-client';
import express from 'express';

const client = new MetaborgClient({
  apiKey: process.env.METABORG_API_KEY!,
  maxRetries: 3
});

const app = express();
app.use(express.json());

// Endpoint pour déclencher une génération
app.post('/api/generate-video', async (req, res) => {
  try {
    const { videoPath, imagePath } = req.body;
    
    // Créer le job avec webhook
    const job = await client.processVideo(videoPath, imagePath, {
      webhook_url: `${process.env.BASE_URL}/webhooks/metaborg`
    });
    
    res.json({
      job_id: job.job_id,
      status: job.status,
      message: 'Job créé, vous serez notifié par webhook'
    });
  } catch (error: any) {
    console.error('Error:', error.response?.data || error.message);
    res.status(500).json({ error: error.message });
  }
});

// Webhook pour recevoir les notifications
app.post('/webhooks/metaborg', async (req, res) => {
  const signature = req.headers['x-metaborg-signature'] as string;
  const payload = JSON.stringify(req.body);
  
  // Vérifier la signature
  if (!client.verifyWebhookSignature(payload, signature, process.env.WEBHOOK_SECRET!)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }
  
  const { event, data } = req.body;
  
  if (event === 'job.completed') {
    console.log('Job completed:', data.job_id);
    console.log('Result URL:', data.result.url);
    
    // Télécharger le résultat, notifier l'utilisateur, etc.
    // await downloadResult(data.result.url);
    // await notifyUser(data.job_id, data.result.url);
  } else if (event === 'job.failed') {
    console.error('Job failed:', data.job_id, data.error);
    // Notifier l'utilisateur de l'échec
  }
  
  res.status(200).send('OK');
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

pip install requests python-dotenv tenacity

import requests
import time
import hmac
import hashlib
import uuid
from typing import Optional, Dict, Any
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type

class MetaborgAPIError(Exception):
    """Exception personnalisée pour les erreurs API"""
    def __init__(self, status_code: int, error: Dict[str, Any]):
        self.status_code = status_code
        self.error = error
        super().__init__(f"API Error {status_code}: {error.get('message', 'Unknown error')}")

class MetaborgClient:
    def __init__(
        self,
        api_key: str,
        base_url: str = "https://api.yourdomain.com/v1",
        timeout: int = 30,
        max_retries: int = 3
    ):
        self.api_key = api_key
        self.base_url = base_url
        self.timeout = timeout
        self.max_retries = max_retries
        
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'User-Agent': 'MetaborgClient-Python/1.0'
        })
    
    def _generate_idempotency_key(self) -> str:
        return str(uuid.uuid4())
    
    @retry(
        stop=stop_after_attempt(3),
        wait=wait_exponential(multiplier=1, min=1, max=60),
        retry=retry_if_exception_type((requests.exceptions.RequestException, MetaborgAPIError))
    )
    def _make_request(
        self,
        method: str,
        endpoint: str,
        **kwargs
    ) -> Dict[str, Any]:
        url = f"{self.base_url}{endpoint}"
        
        try:
            response = self.session.request(
                method,
                url,
                timeout=self.timeout,
                **kwargs
            )
            
            # Handle rate limiting
            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)
                raise MetaborgAPIError(429, {'message': 'Rate limited'})
            
            # Handle client errors
            if 400 <= response.status_code < 500:
                raise MetaborgAPIError(response.status_code, response.json().get('error', {}))
            
            # Handle server errors (will retry)
            if response.status_code >= 500:
                raise MetaborgAPIError(response.status_code, {'message': 'Server error'})
            
            response.raise_for_status()
            return response.json()
            
        except requests.exceptions.RequestException as e:
            print(f"Request error: {e}")
            raise
    
    def process_image(
        self,
        image_path: str,
        prompt: Optional[str] = None,
        webhook_url: Optional[str] = None,
        idempotency_key: Optional[str] = None
    ) -> Dict[str, Any]:
        """Image IA - Retouche et modification d'images"""
        files = {'image': open(image_path, 'rb')}
        data = {}
        
        if prompt:
            data['prompt'] = prompt
        if webhook_url:
            data['webhook_url'] = webhook_url
        
        headers = {
            'Idempotency-Key': idempotency_key or self._generate_idempotency_key()
        }
        
        return self._make_request('POST', '/imageai', files=files, data=data, headers=headers)
    
    def process_video(
        self,
        video_path: str,
        image_path: str,
        webhook_url: Optional[str] = None,
        idempotency_key: Optional[str] = None
    ) -> Dict[str, Any]:
        """Vidéo IA - Transfert de mouvements"""
        files = {
            'video': open(video_path, 'rb'),
            'image': open(image_path, 'rb')
        }
        data = {}
        
        if webhook_url:
            data['webhook_url'] = webhook_url
        
        headers = {
            'Idempotency-Key': idempotency_key or self._generate_idempotency_key()
        }
        
        return self._make_request('POST', '/videoai', files=files, data=data, headers=headers)
    
    def text_to_video(
        self,
        prompt: str,
        webhook_url: Optional[str] = None,
        idempotency_key: Optional[str] = None
    ) -> Dict[str, Any]:
        """Text to Video - Génération vidéo depuis texte"""
        json_data = {'prompt': prompt}
        
        if webhook_url:
            json_data['webhook_url'] = webhook_url
        
        headers = {
            'Idempotency-Key': idempotency_key or self._generate_idempotency_key()
        }
        
        return self._make_request('POST', '/text2video', json=json_data, headers=headers)
    
    def generate_music(
        self,
        prompt: str,
        webhook_url: Optional[str] = None,
        idempotency_key: Optional[str] = None
    ) -> Dict[str, Any]:
        """Musique IA - Composition musicale"""
        json_data = {'prompt': prompt}
        
        if webhook_url:
            json_data['webhook_url'] = webhook_url
        
        headers = {
            'Idempotency-Key': idempotency_key or self._generate_idempotency_key()
        }
        
        return self._make_request('POST', '/musicai', json=json_data, headers=headers)
    
    def get_job_status(self, job_id: str) -> Dict[str, Any]:
        """Vérifier le statut d'un job"""
        return self._make_request('GET', f'/jobs/{job_id}')
    
    def cancel_job(self, job_id: str) -> None:
        """Annuler un job en cours"""
        self._make_request('POST', f'/jobs/{job_id}/cancel')
    
    def wait_for_completion(
        self,
        job_id: str,
        poll_interval: int = 5,
        max_wait_time: int = 300
    ) -> Dict[str, Any]:
        """Attendre la complétion d'un job (polling)"""
        start_time = time.time()
        
        while True:
            job = self.get_job_status(job_id)
            
            if job['status'] in ('completed', 'failed'):
                return job
            
            if time.time() - start_time > max_wait_time:
                raise TimeoutError(f'Job {job_id} timeout: max wait time exceeded')
            
            time.sleep(poll_interval)
    
    def get_credits(self) -> Dict[str, Any]:
        """Consulter le solde de crédits"""
        return self._make_request('GET', '/credits')
    
    @staticmethod
    def verify_webhook_signature(
        payload: str,
        signature: str,
        secret: str
    ) -> bool:
        """Vérifier la signature d'un webhook"""
        expected = 'sha256=' + hmac.new(
            secret.encode(),
            payload.encode(),
            hashlib.sha256
        ).hexdigest()
        
        return hmac.compare_digest(signature, expected)

from flask import Flask, request, jsonify
from metaborg_client import MetaborgClient
import os

app = Flask(__name__)
client = MetaborgClient(api_key=os.getenv('METABORG_API_KEY'))

@app.route('/api/generate-video', methods=['POST'])
def generate_video():
    try:
        data = request.json
        video_path = data['video_path']
        image_path = data['image_path']
        
        # Créer le job avec webhook
        job = client.process_video(
            video_path,
            image_path,
            webhook_url=f"{os.getenv('BASE_URL')}/webhooks/metaborg"
        )
        
        return jsonify({
            'job_id': job['job_id'],
            'status': job['status'],
            'message': 'Job créé, vous serez notifié par webhook'
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/webhooks/metaborg', methods=['POST'])
def metaborg_webhook():
    signature = request.headers.get('X-Metaborg-Signature')
    payload = request.get_data(as_text=True)
    
    # Vérifier la signature
    if not client.verify_webhook_signature(
        payload,
        signature,
        os.getenv('WEBHOOK_SECRET')
    ):
        return jsonify({'error': 'Invalid signature'}), 401
    
    data = request.json
    event = data['event']
    job_data = data['data']
    
    if event == 'job.completed':
        print(f"Job completed: {job_data['job_id']}")
        print(f"Result URL: {job_data['result']['url']}")
        # Traiter le résultat
    elif event == 'job.failed':
        print(f"Job failed: {job_data['job_id']}, Error: {job_data.get('error')}")
    
    return 'OK', 200

if __name__ == '__main__':
    app.run(port=3000)