Rate limiting

# Trigger a run; on 429, the headers tell you how long to wait.
# The only run route is POST /workflows/run — pass the workflow id in the body.
curl -i -X POST "https://api.modulex.dev/workflows/run" \
  -H "Authorization: Bearer mx_live_8b1c4e9f2a7d6035c1e84f29" \
  -H "X-Organization-ID: org_3d9a1f7c52e84b06" \
  -H "Content-Type: application/json" \
  -d '{"workflow_id": "wf_8f3c2a1b", "input": {"topic": "quarterly report"}}'

# HTTP/1.1 429 Too Many Requests
# Retry-After: 60
# X-RateLimit-Limit: 150
# X-RateLimit-Remaining: 0
# X-RateLimit-Reset: 1718924400

import asyncio
from modulex import Modulex, RateLimitError, BillingError

async def main():
    async with Modulex(
        api_key="mx_live_8b1c4e9f2a7d6035c1e84f29",
        organization_id="org_3d9a1f7c52e84b06",
    ) as client:
        try:
            run = await client.executions.run(
                workflow_id="wf_8f3c2a1b",
                input={"topic": "quarterly report"},
            )
        except RateLimitError as err:
            # Header-based 429 (per-key / per-user / org limiter).
            print("retry after", err.retry_after, "seconds")
            print("limit", err.limit, "remaining", err.remaining, "reset", err.reset)
        except BillingError as err:
            # Run-rate DenialEnvelope 429 surfaces here when layer == "rate".
            if err.layer == "rate":
                print("run-rate limited:", err.code, "retry after", err.retry_after)

asyncio.run(main())

import { Modulex, RateLimitError } from 'modulex-js';

const client = new Modulex({
  apiKey: 'mx_live_8b1c4e9f2a7d6035c1e84f29',
  organizationId: 'org_3d9a1f7c52e84b06',
});

try {
  const run = await client.executions.run({
    workflowId: 'wf_8f3c2a1b',
    input: { topic: 'quarterly report' },
  });
} catch (err) {
  if (err instanceof RateLimitError) {
    // Both header-based and DenialEnvelope 429s map to RateLimitError in JS.
    console.log('retry after', err.retryAfter, 'seconds');
    console.log('limit', err.limit, 'remaining', err.remaining, 'reset', err.reset);
  }
}

import asyncio
import random
from modulex import Modulex, RateLimitError

async def run_with_backoff(client, workflow_id, *, max_attempts=5):
    for attempt in range(max_attempts):
        try:
            return await client.executions.run(
                workflow_id=workflow_id, input={"topic": "report"}
            )
        except RateLimitError as err:
            if attempt == max_attempts - 1:
                raise
            wait = (err.retry_after or 60) + random.uniform(0, 1)
            await asyncio.sleep(wait)

import { RateLimitError } from 'modulex-js';

async function runWithBackoff(client, workflowId, maxAttempts = 5) {
  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    try {
      return await client.executions.run({ workflowId, input: { topic: 'report' } });
    } catch (err) {
      if (!(err instanceof RateLimitError) || attempt === maxAttempts - 1) throw err;
      const wait = ((err.retryAfter ?? 60) + Math.random()) * 1000;
      await new Promise((resolve) => setTimeout(resolve, wait));
    }
  }
}