o servidor está limitando o acesso

Error message

o servidor está limitando o acesso (HTTP {}). Tente de novo daqui a pouco

What it means

get_text retries HTTP 429 (rate limit) and 5xx responses with exponential backoff up to TRIES attempts. If the final attempt still returns 429 or a server error, it surfaces a message telling the caller the server is throttling access and to retry later.

Solutions

Wait a few minutes and re-run the operation (the message suggests this)
Reduce request frequency; the client already paces calls via pace(), so slow down callers
Check the service status page for an outage (5xx is server-side)
Retry with fewer/smaller batches of lists in a single run

Defensive patterns

Strategy: retry

Try / catch

match run_fetch().await {
    Err(e) if e.to_string().contains("limitando o acesso") => {
        tokio::time::sleep(Duration::from_secs(300)).await;
        run_fetch().await
    }
    other => other,
}

Prevention

Space out list sync operations instead of running them back-to-back
Respect the provider's documented rate limits for bulk imports
Monitor for 429s and back off proactively in your own scheduling

When it happens

Trigger: The remote site (e.g. Letterboxd/Trakt/Goodreads endpoint fetched via get_text) returned HTTP 429 or 5xx on all TRIES attempts despite backoff and Retry-After honoring.

Common situations: Scraping or syncing large lists in quick succession; shared IP rate-limited by the provider; provider outage or maintenance window; other processes in the same network hammering the same API.

Related errors

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

Appendix: source

Thrown at src-tauri/omniget-core/src/core/tools/lists/mod.rs:475

                tokio::time::sleep(self.delay - since).await;
            }
        }
        *last = Some(Instant::now());
    }

    /// GET com o corpo em texto. Repete em 429 e em erro de servidor.
    pub async fn get_text(&self, url: &str) -> Result<String> {
        const TRIES: u32 = 4;
        let mut wait = Duration::from_secs(3);
        for attempt in 1..=TRIES {
            self.pace().await;
            self.requests.fetch_add(1, Ordering::Relaxed);
            let resp = self.client.get(url).send().await;
            match resp {
                Ok(r) if r.status().is_success() => return Ok(r.text().await?),
                Ok(r) if r.status().as_u16() == 429 || r.status().is_server_error() => {
                    if attempt == TRIES {
                        return Err(anyhow!(
                            "o servidor está limitando o acesso (HTTP {}). Tente de novo daqui a pouco",
                            r.status()
                        ));
                    }
                    let retry = r
                        .headers()
                        .get(reqwest::header::RETRY_AFTER)
                        .and_then(|v| v.to_str().ok())
                        .and_then(|v| v.trim().parse::<u64>().ok())
                        .map(Duration::from_secs);
                    tokio::time::sleep(retry.unwrap_or(wait)).await;
                    wait *= 2;
                }
                Ok(r) if r.status().as_u16() == 401 || r.status().as_u16() == 403 => {
                    return Err(anyhow!(
                        "o site respondeu {} — a sessão salva no gerenciador de cookies expirou ou não tem acesso a isso",
                        r.status()
                    ));

View on GitHub (pinned to 8600b91f42)