Rate & concurrency limits

import axios from "axios";

const BATCH_API = "https://api.cloro.dev/v1/async/task/batch";
const BATCH_SIZE = 500; // endpoint maximum

async function submitTasks(tasks, webhookUrl) {
  for (let start = 0; start < tasks.length; start += BATCH_SIZE) {
    const batch = tasks.slice(start, start + BATCH_SIZE).map((payload) => ({
      taskType: "CHATGPT",
      webhook: { url: webhookUrl },
      payload,
    }));

    const { data } = await axios.post(BATCH_API, batch, {
      headers: { Authorization: `Bearer ${process.env.CLORO_API_KEY}` },
    });

    // Each task is validated on its own, so check every result.
    for (const item of data.results) {
      if (!item.success) {
        console.error(`Task ${start + item.index} rejected:`, item.error.code);
      }
    }
  }
}

await submitTasks(
  [{ prompt: "Analyze market trends", country: "US" }],
  "https://your-app.com/webhook-handler"
);

import os
import requests

BATCH_API = "https://api.cloro.dev/v1/async/task/batch"
BATCH_SIZE = 500  # endpoint maximum

def submit_tasks(tasks, webhook_url):
    for start in range(0, len(tasks), BATCH_SIZE):
        batch = [
            {"taskType": "CHATGPT", "webhook": {"url": webhook_url}, "payload": task}
            for task in tasks[start : start + BATCH_SIZE]
        ]
        response = requests.post(
            BATCH_API,
            json=batch,
            headers={"Authorization": f"Bearer {os.environ['CLORO_API_KEY']}"},
        )
        response.raise_for_status()

        # Each task is validated on its own, so check every result.
        for item in response.json()["results"]:
            if not item["success"]:
                print(f"Task {start + item['index']} rejected:", item["error"]["code"])

submit_tasks(
    [{"prompt": "Analyze market trends", "country": "US"}],
    "https://your-app.com/webhook-handler",
)

import axios from "axios";

const API_URL = "https://api.cloro.dev/v1/monitor/chatgpt";
const headers = { Authorization: `Bearer ${process.env.CLORO_API_KEY}` };

async function runConcurrentRequests(prompts, concurrency) {
  const results = new Array(prompts.length);
  let next = 0;
  let rateLimited = 0;

  async function worker() {
    while (next < prompts.length) {
      const i = next++; // claim a prompt before awaiting
      try {
        const response = await makeRequestWithRetry(() =>
          axios.post(API_URL, { prompt: prompts[i], country: "US" }, { headers })
        );
        results[i] = response.data;
      } catch (error) {
        if (error.response?.status === 429) rateLimited++;
        results[i] = { error: error.response?.data?.error?.code ?? error.message };
      }
    }
  }

  await Promise.all(Array.from({ length: concurrency }, () => worker()));
  console.log(`${prompts.length} prompts, ${rateLimited} still rate limited after retries`);
  return results;
}

// Set concurrency to your plan's limit (X-Concurrency-Limit)
const results = await runConcurrentRequests(
  ["What is AI?", "Explain machine learning basics"],
  5
);

import asyncio
import os
import httpx

API_URL = "https://api.cloro.dev/v1/monitor/chatgpt"
HEADERS = {"Authorization": f"Bearer {os.environ['CLORO_API_KEY']}"}

async def run_concurrent_requests(prompts, concurrency):
    slots = asyncio.Semaphore(concurrency)

    async with httpx.AsyncClient(headers=HEADERS, timeout=300) as client:
        async def call(prompt):
            async with slots:  # at most `concurrency` requests in flight
                for attempt in range(3):
                    response = await client.post(API_URL, json={"prompt": prompt, "country": "US"})
                    if response.status_code != 429:
                        break
                    await asyncio.sleep(2**attempt)  # exponential backoff
                return response.json()

        return await asyncio.gather(*(call(p) for p in prompts))

# Set concurrency to your plan's limit (X-Concurrency-Limit)
results = asyncio.run(
    run_concurrent_requests(["What is AI?", "Explain machine learning basics"], 5)
)