Threads API Errors and Rate Limits

"""threads_retry.py - call the Threads API with safe retries and backoff."""
import random
import time

import requests

BASE_URL = "https://graph.threads.net/v1.0"
RATE_LIMIT_CODES = {4, 17, 341, 613}   # throttled: the request was rejected
TRANSIENT_CODES = {1, 2}               # temporary problems on Meta's side


class ThreadsError(Exception):
    """A Threads API error with its code, subcode and trace id."""

    def __init__(self, error, status=None):
        self.code = error.get("code")
        self.subcode = error.get("error_subcode")
        self.trace_id = error.get("fbtrace_id")
        self.status = status
        super().__init__(f"[{self.code}/{self.subcode}] {error.get('message')} "
                         f"(fbtrace_id={self.trace_id})")


def _backoff(attempt):
    """Exponential backoff with jitter: ~1s, 2s, 4s, 8s, 16s... capped at 60s."""
    time.sleep(min(60, 2 ** attempt) + random.uniform(0, 1))


def call(method, path, token, max_retries=5, **params):
    """Call the API. GETs retry on temporary errors; POSTs only retry when
    throttled, so a request that may have succeeded is never sent twice."""
    params["access_token"] = token
    for attempt in range(max_retries + 1):
        last = attempt == max_retries
        try:
            if method == "GET":
                resp = requests.get(f"{BASE_URL}/{path}", params=params, timeout=30)
            else:
                resp = requests.post(f"{BASE_URL}/{path}", data=params, timeout=30)
        except (requests.ConnectionError, requests.Timeout):
            if method != "GET" or last:
                raise
            _backoff(attempt)
            continue

        try:
            data = resp.json()
        except ValueError:
            data = {"error": {"message": f"HTTP {resp.status_code}"}}
        error = data.get("error")
        if not error:
            return data

        code = error.get("code")
        throttled = code in RATE_LIMIT_CODES
        transient = code in TRANSIENT_CODES or resp.status_code >= 500
        if last or not (throttled or (transient and method == "GET")):
            raise ThreadsError(error, resp.status_code)
        _backoff(attempt)


def publish_container(user_id, container_id, token):
    """Publish a container - skipping it if an earlier attempt already did."""
    info = call("GET", container_id, token, fields="status,error_message")
    if info.get("status") == "PUBLISHED":
        return None  # already live: don't post twice
    if info.get("status") != "FINISHED":
        raise RuntimeError(f"Container not ready: {info}")
    return call("POST", f"{user_id}/threads_publish", token,
                creation_id=container_id)["id"]

// threadsRetry.mjs - Node.js 18+
const BASE_URL = "https://graph.threads.net/v1.0";
const RATE_LIMIT_CODES = new Set([4, 17, 341, 613]); // throttled: request rejected
const TRANSIENT_CODES = new Set([1, 2]);              // temporary, Meta's side

export class ThreadsError extends Error {
  constructor(error, status) {
    super(`[${error.code}/${error.error_subcode}] ${error.message} (fbtrace_id=${error.fbtrace_id})`);
    this.code = error.code;
    this.subcode = error.error_subcode;
    this.traceId = error.fbtrace_id;
    this.status = status;
  }
}

const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
// Exponential backoff with jitter: ~1s, 2s, 4s, 8s, 16s... capped at 60s
const backoff = (attempt) => sleep(Math.min(60, 2 ** attempt) * 1000 + Math.random() * 1000);

// GETs retry on temporary errors; POSTs only retry when throttled,
// so a request that may have succeeded is never sent twice.
export async function call(method, path, token, params = {}, maxRetries = 5) {
  const body = new URLSearchParams({ ...params, access_token: token });
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const last = attempt === maxRetries;
    let res;
    try {
      res = method === "GET"
        ? await fetch(`${BASE_URL}/${path}?${body}`, { signal: AbortSignal.timeout(30000) })
        : await fetch(`${BASE_URL}/${path}`, { method, body, signal: AbortSignal.timeout(30000) });
    } catch (err) {
      if (method !== "GET" || last) throw err;
      await backoff(attempt);
      continue;
    }
    const data = await res.json().catch(() => ({ error: { message: `HTTP ${res.status}` } }));
    if (!data.error) return data;
    const throttled = RATE_LIMIT_CODES.has(data.error.code);
    const transient = TRANSIENT_CODES.has(data.error.code) || res.status >= 500;
    if (last || !(throttled || (transient && method === "GET"))) {
      throw new ThreadsError(data.error, res.status);
    }
    await backoff(attempt);
  }
}