FxTwitter: limite de requisicoes atingido, tente de novo em…

Error message

FxTwitter: limite de requisicoes atingido, tente de novo em instantes

What it means

FxTwitter returned code 429, meaning the rate limit for the shared FxTwitter service was exhausted. fx.rs surfaces a retry-hint message because the limit belongs to the public shared API, not this client's own quota.

Solutions

Wait and retry with exponential backoff and jitter.
Add caching/deduplication so the same post or profile is fetched only once per run.
Throttle request rate (e.g. limit concurrency to 1-2 and add delay between calls).
Fall back to the authenticated native X client when FxTwitter is rate-limited.

Example fix

// before
for id in ids {
    let post = fx::status(&id).await?;
}
// after
for id in ids {
    let post = loop {
        match fx::status(&id).await {
            Ok(p) => break p,
            Err(e) if e.to_string().contains("limite de requisicoes") => {
                tokio::time::sleep(Duration::from_secs(backoff)).await;
                backoff = (backoff * 2).min(60);
            }
            Err(e) => return Err(e),
        }
    };
    tokio::time::sleep(Duration::from_millis(500)).await;
}

Defensive patterns

Strategy: retry

Try / catch

async fn with_retry<T>(f: impl Fn() -> impl Future<Output = anyhow::Result<T>>) -> anyhow::Result<T> {
    let mut delay = Duration::from_secs(2);
    loop {
        match f().await {
            Ok(v) => return Ok(v),
            Err(e) if e.to_string().contains("limite de requisicoes") && delay <= Duration::from_secs(60) => {
                tokio::time::sleep(delay).await;
                delay *= 2;
            }
            Err(e) => return Err(e),
        }
    }
}

Prevention

Add exponential backoff with jitter on 429-style errors
Cache FxTwitter responses so repeated IDs are fetched once
Limit concurrency and pace requests (e.g. >=500ms between calls)
Prefer the authenticated native client for bulk operations

When it happens

Trigger: Bursting many get()-backed calls (status, thread, conversation, profile, profile_statuses, profile_media) in a short window, especially when scraping many IDs or polling in a loop.

Common situations: Bulk downloads of media from many posts; a retry loop without backoff hammering the endpoint after earlier failures; multiple users of the shared FxTwitter API exhausting its global quota.

Related errors

AI-assisted analysis of tonhowtf/omniget@8600b91f42 (2026-09-12). Data as JSON: /api/errors/4db94fa66b80327f. Report an issue: GitHub.

Appendix: source

Thrown at src-tauri/omniget-core/src/core/tools/x/fx.rs:58

    }
    let resp = req.send().await?;
    let status = resp.status();
    let body: Value = resp
        .json()
        .await
        .map_err(|e| anyhow!("FxTwitter: resposta invalida ({})", e))?;
    let code = body
        .get("code")
        .and_then(|c| c.as_u64())
        .unwrap_or(status.as_u16() as u64);
    if code == 404 {
        return Err(anyhow!("nao encontrado no X (ou o post e privado)"));
    }
    if code == 401 {
        return Err(anyhow!("post ou perfil privado"));
    }
    if code == 429 {
        return Err(anyhow!(
            "FxTwitter: limite de requisicoes atingido, tente de novo em instantes"
        ));
    }
    if code >= 400 {
        let msg = body
            .get("message")
            .and_then(|m| m.as_str())
            .unwrap_or("erro");
        return Err(anyhow!("FxTwitter: {} ({})", msg, code));
    }
    Ok(body)
}

fn s(v: &Value, k: &str) -> String {
    v.get(k).and_then(|x| x.as_str()).unwrap_or("").to_string()
}

fn n(v: &Value, k: &str) -> u64 {

View on GitHub (pinned to 8600b91f42)