tonhowtf/omniget · error

Post not available; graphql='{}'; syndication_extract='{}';

Error message

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

What it means

In native_get_media_info, when the GraphQL lookup fails, the syndication endpoint succeeds but extract_syndication_media cannot pull media out of its payload, and the final HTML-scrape fallback (request_html_media) also fails, the library aggregates all three failures into this single error. It means every extraction channel for the tweet was exhausted without finding media.

Solutions

  1. Check the tweet in a browser — if it's deleted, protected, or age-gated, both extraction paths will legitimately fail.
  2. Configure the X/Twitter auth cookie so request_html_media (and downstream yt-dlp) can see restricted media.
  3. Read the three embedded sub-errors: fix the GraphQL/syndication root causes (guest token fetching, schema drift in extract_syndication_media).
  4. Retry after a delay if the embedded errors suggest rate limiting or transient 4xx/5xx responses.
  5. If syndication_extract indicates a parsing error, update extract_syndication_media for the current syndication API JSON shape.

Example fix

// before: calling with no credentials for a sensitive post
let info = downloader.get_media_info(url).await?;
// after: supply auth cookie and retry once on aggregate failure
set_twitter_cookie(env::var("X_AUTH_COOKIE")?);
let info = match downloader.get_media_info(url).await {
    Ok(i) => i,
    Err(e) if e.to_string().contains("Post not available") => {
        tokio::time::sleep(Duration::from_secs(5)).await;
        downloader.get_media_info(url).await?
    }
    Err(e) => return Err(e),
};
Defensive patterns

Strategy: fallback

Validate before calling

// Confirm accessibility expectations before calling: permalink + cookie configured
fn precheck(url: &str, has_cookie: bool) -> Result<(), String> {
    if !url.contains("/status/") { return Err("not a permalink".into()); }
    if !has_cookie { println!("warning: sensitive/age-restricted posts will fail without an X cookie"); }
    Ok(())
}

Try / catch

match downloader.get_media_info(url).await {
    Err(e) if e.to_string().contains("Post not available") => {
        // all three channels failed; check embedded graphql/syndication/html causes
        eprintln!("tweet unavailable via all channels: {e}");
        // surface a user-facing 'post deleted or private' message
    }
    other => other?,
}

Prevention

When it happens

Trigger: try_graphql fails (guest token/HTTP error), request_syndication returns JSON whose extraction errors (unexpected/empty syndication payload), and request_html_media fails (non-2xx HTML response or no photo URLs found in HTML) — all for the same tweet_id.

Common situations: Deleted, protected, or age-restricted/sensitive-media posts; Twitter rate-limiting or blocking guest tokens and anonymous HTML requests; cookie missing so sensitive media is hidden; syndication API schema change breaking extract_syndication_media while GraphQL is also down (e.g. token endpoint blocked in some regions); bot-detection on anonymous requests.

Understand the failure class

Background: "Not found" and "does not exist" errors: why "Task not found", "No such folder", and "Can't find" fire when a lookup comes back empty — this error's family across 14 libraries.

Related errors

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

Appendix: source

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

            Err(graphql_err) => {
                tracing::warn!(
                    "[twitter] graphql lookup failed for tweet_id={}: {}",
                    tweet_id,
                    graphql_err
                );
                match self.request_syndication(&tweet_id).await {
                    Ok(syndication) => match Self::extract_syndication_media(&syndication) {
                        Ok(items) => items,
                        Err(syndication_extract_err) => {
                            tracing::warn!(
                                "[twitter] syndication media extraction failed for tweet_id={}: {}",
                                tweet_id,
                                syndication_extract_err
                            );
                            match self.request_html_media(url).await {
                                Ok(items) => items,
                                Err(html_err) => {
                                    return Err(anyhow!(
                                        "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) => {

View on GitHub (pinned to 8600b91f42)