tonhowtf/omniget · error

Post not available; graphql='{}'; syndication='{}'; html='{}

Error message

Post not available; graphql='{}'; syndication='{}'; html='{}'

What it means

The sibling of error 1033: here the syndication endpoint itself fails (request_syndication returns Err rather than its extraction step), GraphQL already failed, and the HTML-scrape fallback also fails, so native_get_media_info aggregates the three channel errors ('graphql', 'syndication', 'html') and returns. It means no extraction channel could retrieve or parse any media for the tweet.

Solutions

  1. Verify the tweet is public and still exists in a browser.
  2. Set the X/Twitter auth cookie so the HTML path (and yt-dlp fallback) can authenticate and bypass anonymous rate limits.
  3. Inspect the three embedded sub-errors for HTTP status codes: 429 means back off and retry; 403/404 means the post is unavailable or blocked.
  4. Check network/proxy reachability to api.twitter.com, cdn.syndication.twimg.com, and x.com.
  5. Retry with backoff; if persistent, rely on the outer get_media_info yt-dlp fallback and ensure the yt-dlp binary is up to date.

Example fix

// before: immediate retry loop hammering rate-limited endpoints
loop { downloader.get_media_info(url).await?; }
// after: honor rate limits with exponential backoff
for delay in [1u64, 5, 30] {
    match downloader.get_media_info(url).await {
        Ok(info) => break info,
        Err(e) if e.to_string().contains("429") => {
            tokio::time::sleep(Duration::from_secs(delay)).await;
        }
        Err(e) => return Err(e),
    }
} else { anyhow::bail!("unavailable after retries") }
Defensive patterns

Strategy: retry

Validate before calling

// Probe reachability of the three endpoints before extraction
async fn endpoints_reachable(client: &reqwest::Client) -> bool {
    for u in ["https://api.twitter.com", "https://cdn.syndication.twimg.com", "https://x.com"] {
        if client.head(u).send().await.is_err() { return false; }
    }
    true
}

Try / catch

match downloader.get_media_info(url).await {
    Err(e) if e.to_string().contains("Post not available") => {
        if e.to_string().contains("429") {
            tokio::time::sleep(Duration::from_secs(60)).await;
            // retry once
        } else {
            eprintln!("post unavailable or network blocked: {e}");
        }
    }
    other => other?,
}

Prevention

When it happens

Trigger: try_graphql errors (guest token unavailable, expired refresh also failed, HTTP error), request_syndication errors outright (network failure, syndication API non-2xx, timeout), and request_html_media errors (HTTP non-success or no photo URLs in HTML).

Common situations: Deleted or protected tweets; syndication CDN endpoint down or geo-blocked; Twitter aggressively rate-limiting anonymous traffic (all three channels are unauthenticated without a cookie); corporate proxy/firewall blocking api.twitter.com, cdn.syndication.twimg.com, and x.com HTML simultaneously; guest-token issuance failing so GraphQL errors immediately.

Related errors

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

Appendix: source

Thrown at src-tauri/omniget-core/src/platforms/twitter.rs:948

                                        "Post not available; graphql='{}'; syndication_extract='{}'; html='{}'",
                                        graphql_err,
                                        syndication_extract_err,
                                        html_err
                                    ));
                                }
                            }
                        }
                    },
                    Err(syndication_err) => {
                        tracing::warn!(
                            "[twitter] syndication lookup failed for tweet_id={}: {}",
                            tweet_id,
                            syndication_err
                        );
                        match self.request_html_media(url).await {
                            Ok(items) => items,
                            Err(html_err) => {
                                return Err(anyhow!(
                                    "Post not available; graphql='{}'; syndication='{}'; html='{}'",
                                    graphql_err,
                                    syndication_err,
                                    html_err
                                ));
                            }
                        }
                    }
                }
            }
        };

        let twitter_media = Self::parse_media_items(&media_items)?;

        Ok(Self::media_info_from_twitter_media(
            filename_base,
            twitter_media,
        ))

View on GitHub (pinned to 8600b91f42)