ads_get_ad
ChatGPTOne ad from a platform's public library, with its creative text, where it sends people, and who it was aimed at and reached. Use when: reading the offer and the call to action behind an ad you found in a list. Not for: a set of ads, use ads_search_ads or ads_get_advertiser_ads. What is said in an ad video, use the platform's transcript tool. Returns: Record. advertiser, headline, body, format, first_shown, last_shown, active, versions (near-identical copies Meta groups, a sign the advertiser scaled it), impressions, spend, countries, placements, targeting[], cta, destination_url, media_url, plus variations[] (carousel cards on facebook, text variants on google), reach, reach_by_country[], reach_by_age_gender[] and payers[] (payer, beneficiary). Impressions and spend are the ranges the library publishes, so they are text. Reach, its age split and payers come from Meta's EU and UK disclosure, so only facebook ads that ran there have them. On google, first_shown falls back to the earliest region's date and is null when the library dates neither; the ads_get_advertiser_ads row for the same ad carries it. Cost: 1 credit. Cached 7 days. Example: {"platform": "facebook", "id": "1185617869915074"}
ads_get_advertiser_ads
ChatGPTEvery ad one advertiser is running, from a platform's public library. Use when: a competitor teardown: what they are running, since when, and with what offer. Not for: a keyword sweep across advertisers, use ads_search_ads. One creative in full, use ads_get_ad. Returns: List. rows[]: one ad each: advertiser, headline, body, format, first_shown, last_shown, active, versions (near-identical copies Meta groups, a sign the advertiser scaled it), impressions, spend, countries, placements, targeting[], cta, destination_url, media_url. Impressions and spend are the ranges the library publishes, so they are text. Cost: 1 credit per page, or 25 on google with details. Cached 24 hours. Example: {"platform": "google", "advertiser": "lululemon.com"}
ads_search_ads
ChatGPTAds running on a platform's public library, by keyword or brand. Use when: "what ads is this category running", finding the angles and offers competitors are paying for. Not for: one advertiser's whole set, use ads_get_advertiser_ads. Google, whose library is keyed by advertiser: use ads_search_advertisers first. Organic posts, use the platform's own search tool. Returns: List. rows[]: one ad each: advertiser, headline, body, format, first_shown, last_shown, active, versions (near-identical copies Meta groups, a sign the advertiser scaled it), impressions, spend, countries, placements, targeting[], cta, destination_url, media_url. Impressions and spend are the ranges the library publishes, so they are text. Cost: 1 credit per page. Cached 24 hours. Example: {"platform": "facebook", "query": "creatine gummies", "active_only": true}
ads_search_advertisers
ChatGPTThe advertisers matching a brand name in Google's ad library, with their ids. Use when: before ads_get_advertiser_ads on Google, because that library is keyed by advertiser id and one brand has one entry per region. Not for: the ads themselves, use ads_get_advertiser_ads with the id this returns. The other libraries, which search their ads directly with ads_search_ads. Returns: List. rows[]: platform, id, name, region, ads_estimate, website. Cost: 1 credit. Cached 7 days. Example: {"platform": "google", "query": "lululemon", "region": "US"}
aeo_get_site_readiness
ChatGPTWhether a site is set up for AI answer engines, from about seventeen live fetches of its origin, free. Checks what the engines document as gating their answers: robots.txt access for every known AI crawler (search, user fetch, training), CDN or WAF rules that turn away the answer crawlers' user agents before robots.txt is read, content present in the raw HTML without JavaScript on the homepage and on one page sampled from the sitemap, noindex and snippet directives, then freshness signals, redirect chains, sitemap, title and description, structured data, and llms.txt. Use when: "is our site ready for AI search", "do we block GPTBot", "are we blocking ChatGPT at Cloudflare", "do we have an llms.txt", before an AI visibility push. Not for: what the engines answer, use aeo_run_ai_answers. A full technical audit, use seo_run_technical_crawl. One page's on-page tags, use seo_get_page. Returns: Record. checks[] (check, ok, tier, detail, source), failing checks first. tier says how much a check is worth: blocks_citations is documented by an engine, evidence_backed is measured, hygiene is standard practice, policy is a legitimate choice that never fails, unproven is reported but never fails on absence (llms.txt, schema presence). Plus the findings behind them: robots_txt (ai_bots[], sitemaps, content_signal), edge (probes[] per answer crawler user agent), homepage and sample_page (status, word_count and js_shell from the raw HTML, canonical, robots and schema tags, dates; sample_page is the first content URL in the sitemap, null when there is none), markdown (whether the origin answers Accept: text/markdown, which passes the JavaScript check), redirects[], sitemap, llms_txt and llms_full_txt. No crawl, no LLM call. Cost: 0 credits, rate limited. Cached 1 hour. Example: {"target": "example.com"}
aeo_run_ai_answers
ChatGPTWhat AI engines answer for a prompt, with the brands they mention and the sources they cite. Slow: returns a task_id, then read the result with get_task. Use when: "does ChatGPT recommend us for X", "who do AI engines cite for X", an AI visibility baseline for a brand across engines. Not for: which prompts people ask, use aeo_search_prompts. Google's ten blue links, use seo_get_serp (ai_overview: true adds the overview to it at 1 credit). Whether a site is ready for AI crawlers, use aeo_get_site_readiness. Returns: Task. task_id now; get_task returns rows[] per prompt and engine (answer, mentions[] (brand, mentioned, position, cited), citations[] (position, url, domain, title), search_results[] (pages retrieved, cited or not), search_queries[] (the web searches the engine ran), named_brands[] (brands ChatGPT tagged in the answer, not only yours)) and errors[] for cells that failed. answer null = the engine showed no AI answer. search_results[] and named_brands[] are filled for chatgpt only, search_queries[] for chatgpt and claude. named_brands[] drops a tag ChatGPT gives as a description instead of the brand, so it can miss brands; read the answer for a full list. chatgpt and gemini are what their apps show a person, model chosen by the app; claude and perplexity come from their model APIs. Answers are live and non-deterministic; results are kept 30 days and never cached. Cost: per prompt, 15 credits for claude, 6 for perplexity, 2 each for chatgpt, gemini, ai_overview and ai_mode. Default 1 prompt on the five default engines = 27 credits. A cell that fails is not charged. Example: {"prompts": ["best crm for startups"], "brands": ["HubSpot", "pipedrive.com"]}
aeo_search_prompts
ChatGPTPrompts people ask an AI engine (ChatGPT or Google AI Overview) about a topic or brand, from the provider's index of observed answers. Not keywords. Use when: "what do people ask ChatGPT about X", "which prompts mention our brand", building an AI visibility baseline. Not for: Google keywords and volumes, use seo_search_keywords. What the AI engines answer right now, use aeo_run_ai_answers. Returns: List. rows[]: prompt, ai_search_volume (a People Also Ask proxy, not query logs), engines[], mentions_brand (a domain input is cited, a keyword input appears in the answer), cited_domains[], retrieved_domains[] (read while answering but not cited), search_queries[] (the web searches the engine ran), named_brands[], answer_preview, first_seen, last_seen. Give exactly one of keyword or domain. Cost: 31 + 31 per 100 rows. Default 50 rows = 47 credits. Cached 7 days. Example: {"domain": "example.com", "limit": 50}
amazon_get_competitors
ChatGPTAmazon products that compete with one product for the same searches, with how many they share and how each ranks. Use when: "which products compete with ours on Amazon", "who shows up beside this ASIN", building a competitor set for a listing. Not for: the results for one search, use amazon_search_products. Web competitors, use seo_get_serp_competitors. Returns: List. rows[]: asin, shared_keywords, avg_position, organic_keywords, organic_volume, sponsored_keywords. ASINs only: call amazon_get_product for a title. The product itself is left out. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"asin": "B0B41YH9B6", "limit": 20}
amazon_get_keyword_metrics
ChatGPTMonthly Amazon search volume for up to 1,000 keywords you already have, in the order given. Use when: "how many people search Amazon for X", comparing Amazon demand with Google demand, sizing a product idea on Amazon. Not for: Google volume, use seo_get_keyword_metrics. Finding keywords, use amazon_search_keywords. Returns: List. rows[]: keyword, volume (monthly Amazon searches; null = no data). Cost: 5 + 5 per 100 keywords. 10 keywords = 6 credits. Cached 7 days. Example: {"keywords": ["standing desk", "desk converter"]}
amazon_get_keywords
ChatGPTAmazon searches one product ranks for, with monthly Amazon search volume and its position, organic or sponsored. Use when: "what does this ASIN rank for on Amazon", "which searches bring competitor's product its sales", choosing keywords for a listing title. Not for: Google rankings, use seo_get_ranked_keywords. New keyword ideas, use amazon_search_keywords. Returns: List. rows[]: keyword, volume (monthly Amazon searches), rank (position on the results page, counting organic and sponsored rows), type (organic | sponsored), results_count. Sorted by volume, biggest first. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"asin": "B0B41YH9B6", "limit": 50}
amazon_get_product
ChatGPTOne Amazon product by ASIN: title, price and discount, rating, availability, category path, the About-this-item text, spec table, variations and images. Use when: "tear down this Amazon listing", "what does competitor's product page say", "how is this product priced and rated". Not for: who else sells it and at what price, use amazon_get_sellers. The searches it ranks for, use amazon_get_keywords. Customer reviews: not available for Amazon. Returns: Record. asin, parent_asin, title, url, byline, price, regular_price (the struck-through list price; null with no discount), discount_percent, currency, rating, ratings_count, is_amazon_choice, is_available, categories[] (broadest first), description, specs[] (group, name, value), variation_asins[], images[]. Cost: 2 credits. Cached 1 day. Example: {"asin": "B0B41YH9B6"}
amazon_get_sellers
ChatGPTEvery seller offering one Amazon product, with price, condition, where it ships from and delivery: who holds the Buy Box and who undercuts it. Use when: "who sells this ASIN", "are resellers undercutting our price", "is Amazon itself selling this". Not for: the listing, use amazon_get_product. Prices across other stores, use shopping_get_sellers. Returns: Record. asin, title, has_featured_offer (false when no seller holds the Buy Box; rows then start at rank 2), rows[]: rank (1 holds the Buy Box), seller, seller_url (null for Amazon itself), ships_from, price, regular_price, currency, discount_percent, condition, delivery. Cost: 2 credits. Cached 6 hours. Example: {"asin": "B0B41YH9B6"}
amazon_search_keywords
ChatGPTAmazon search ideas around a seed, from Amazon's related searches, with monthly Amazon search volume. Use when: "what else do people search on Amazon around X", building an Amazon keyword list for a listing or ads. Not for: Google keyword ideas, use seo_search_keywords. Volume for keywords you already have, use amazon_get_keyword_metrics. Returns: List. rows[]: keyword, volume. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"seed": "standing desk", "limit": 50}
amazon_search_products
ChatGPTAmazon's results page for a search: organic and sponsored products in order, with price, rating, reviews, bought-past-month and badges. Use when: "who ranks on Amazon for standing desk", "which brands buy Amazon ads for this search", "what do top products in this category cost". Not for: one product's full listing, use amazon_get_product. Google Shopping, use shopping_search_products. Amazon search volume, use amazon_get_keyword_metrics. Returns: Record. keyword, results_count, rows[]: rank, type (organic | sponsored), asin, title, url, image_url, price, price_to, currency, rating, ratings_count, bought_past_month, is_amazon_choice, is_best_seller, offers[] (badges). related_searches[] (can be empty). Cost: 2 credits per 100 results. Default 100 = 2 credits. Cached 1 day. Example: {"keyword": "standing desk", "depth": 100}
analytics_get_fields
ChatGPTEvery dimension and metric one Google Analytics 4 property reports, with the api_name analytics_get_report takes, custom dimensions and metrics included. Use when: a report needs a field outside the common ones, "what custom dimensions do we track", checking a conversion or event-scoped field's name before asking for it, or after analytics_get_report rejected a field name. Not for: the numbers themselves, use analytics_get_report. Returns: List, dimensions then metrics, in Google's order. rows[]: kind (dimension | metric), api_name, ui_name, description, category, custom (defined on this property: customEvent:x, customUser:x), metric_type (metrics only: TYPE_INTEGER, TYPE_FLOAT, TYPE_SECONDS, TYPE_CURRENCY and so on). Several hundred rows; filter with custom or category. Cost: 0 credits. Cached 1 day. Example: {"property": "properties/123456789", "limit": 1000}
analytics_get_report
ChatGPTA Google Analytics 4 report from the user's own property: any metrics by any dimensions over a date range, optionally against a second range. Use when: "how much traffic did we get last month", sessions or conversions by channel, landing page or campaign, "which pages convert", revenue by source, a traffic drop by channel against the period before, organic sessions next to Search Console clicks. Not for: Google search queries, use console_get_search_analytics. A site the user does not own, use seo_get_traffic_estimates. Returns: List. rows[]: one object per row keyed by api_name, dimensions as strings and metrics as numbers; with a comparison each row also carries dateRange (current | previous). metric_types (TYPE_SECONDS is seconds, TYPE_CURRENCY is in currency_code), currency_code, time_zone, subject_to_thresholding (Google withheld small rows for privacy), data_loss_from_other_row (rows folded into (other)). meta.rows_available is Google's row count. Rates such as engagementRate are 0 to 1. Data settles within about a day. Give compare_start_date and compare_end_date together, or neither. Cost: 0 credits. Cached 1 hour. Example: {"property": "properties/123456789", "metrics": ["sessions", "keyEvents"], "dimensions": ["sessionDefaultChannelGroup"], "start_date": "2026-09-01", "end_date": "2026-09-30", "compare_start_date": "2026-08-01", "compare_end_date": "2026-08-31"}
analytics_list_properties
ChatGPTThe Google Analytics 4 properties the workspace's connected Google account can read, with the account each sits under. The first analytics call; the other analytics tools take a property from here. Use when: "what's in my Google Analytics", "which GA4 property is example.com", before any analytics_get_* call. Not for: Search Console sites, use console_list_properties. Traffic to a site the user does not own, use seo_get_traffic_estimates. Returns: List. rows[]: property (the id to pass on: properties/123456789), property_name, property_type (PROPERTY_TYPE_ORDINARY, SUBPROPERTY or ROLLUP), account (accounts/123), account_name. NotConnected when no Google account is connected, or when the connected one has not granted Analytics; its connect_url is where the user connects or reconnects. Cost: 0 credits. The user's own data is free; it shares the console's 60 calls per minute per workspace. Cached 1 hour. Example: {}
apps_get_app
ChatGPTOne app's store listing: rating, installs, version, release notes, description, screenshots and the developer's contact details. Use when: "tell me about this app", "how is competitor's app rated", "who makes this app and how do I reach them", "when did they last ship an update". Not for: what users say, use apps_get_reviews. Store searches the app ranks for, use apps_get_keywords. Finding apps, use apps_search_apps or apps_get_top_charts. Returns: Record. title, subtitle (App Store only), description, category, genres[], rating (out of 5), ratings_count, installs (Google Play only), price (0 when free), content_rating, version, released_at, updated_at, update_notes, developer with its website, email and address (those three Google Play only), screenshots[], similar_apps[] and more_by_developer[] (app_id, title). null = the store does not show it. On the App Store, description starts with the promotional text when the app has one, category is sometimes null, and currency is null on free apps. On Google Play, version is often null. Cost: 1 credit. Cached 1 day. Can take up to a minute. Example: {"store": "google_play", "app_id": "com.Slack"}
apps_get_competitors
ChatGPTApps that compete with one app for the same store searches, with how many searches they share and how strongly each ranks. Use when: "who competes with our app in the App Store", "which apps take our store searches", building a competitor set for an app. Not for: business competitors on the web, use seo_get_serp_competitors. The keywords two apps share, use apps_get_shared_keywords. Returns: List. rows[]: app_id, shared_keywords, avg_position, keywords (every store search it ranks for), top_3, keywords_volume. Ids only: call apps_get_app for a name. The app itself is left out. United States and English only. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"store": "app_store", "app_id": "618783545", "limit": 20}
apps_get_keywords
ChatGPTStore searches an app ranks for, with monthly search volume in the store and the app's position: the core of app store optimisation. Use when: "what does competitor's app rank for in the App Store", "which store keywords bring installs", picking keywords for an app title or subtitle. Not for: Google web searches, use seo_get_ranked_keywords. Keywords two apps share, use apps_get_shared_keywords. Returns: List. rows[]: keyword, volume (monthly store searches), rank (the app's position), results_count (apps in the store's results: the App Store counts at most about 250, so only a lower figure means a thin search; null on Google Play). Best rank first, then volume. United States and English only; Google Play covers fewer apps than the App Store, and NoData means the store has no keyword data for that app. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"store": "google_play", "app_id": "com.microsoft.teams", "limit": 50}
apps_get_reviews
ChatGPTUser reviews of one app, newest or most relevant first, with stars, text, app version and any developer reply. Use when: "what do users complain about in X's app", "recent 1-star reviews", "did the last release annoy people", mining pain points for positioning. Not for: the listing itself, use apps_get_app. Reviews of a physical product, use shopping_get_reviews. Returns: Record. store, app_id, title, rating, ratings_count (every star rating, most without text: not the reviews you can fetch), rows[]: id, rating, title (App Store only), text, author, published_at, app_version, helpful_count and developer_reply (Google Play only). meta.rows_available is set only when the call reached the end of what can be fetched, else null. Cost: 1 credit per 100 reviews. Default 100 = 1 credit. Cached 6 hours. Can take up to a minute. Example: {"store": "app_store", "app_id": "618783545", "sort": "newest", "limit": 200}
apps_get_shared_keywords
ChatGPTStore searches that two to twenty apps all rank for, with each app's position side by side. Use when: "where do we and competitor both rank", "which store keywords does Teams beat Slack on", comparing apps keyword by keyword. Not for: every keyword one app ranks for, use apps_get_keywords. Finding the competitors first, use apps_get_competitors. Returns: List. rows[]: keyword, volume, ranks[] (app_id, rank) in the order the apps were given. Sorted by volume. United States and English only. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"store": "google_play", "app_ids": ["com.Slack", "com.microsoft.teams"]}
apps_get_top_charts
ChatGPTA store's top chart (free, paid, grossing or new) overall or in one category, in chart order. Use when: "top free business apps", "what is grossing in the App Store's finance chart", spotting rising apps in a category. Not for: apps matching a word, use apps_search_apps. One app's details, use apps_get_app. Returns: List. rows[]: rank, app_id, title, url, developer (Google Play only), rating, ratings_count (App Store only), is_free, price, currency. Cost: 1 credit per 100 rows. Default 100 rows = 1 credit. Cached 1 day. Can take up to a minute. Example: {"store": "app_store", "chart": "top_free", "category": "health_and_fitness"}
apps_search_apps
ChatGPTApps whose title matches a query, from an index of every app in a store, with the full listing and the developer's contact details on each row. Use when: "find CRM apps", "every app with invoice in its name", building a list of app makers to contact, sizing a category. Not for: the store's own ranking for a search or a chart, use apps_get_top_charts. One app you already have, use apps_get_app (much cheaper). Returns: List. rows[]: app_id, title, subtitle, description (first 500 characters), category, rating, ratings_count, installs, price, developer and the other apps_get_app fields, with the same gaps. A title matches when it holds any one word of the query, so "habit monitor" also brings back flight monitors; search one distinctive word, with category. Biggest first: most installs on Google Play, most ratings on the App Store. Not the store's own search ranking. Cost: 31 + 31 per 100 rows. Default 100 rows = 62 credits. Cached 7 days. Example: {"store": "google_play", "query": "crm", "limit": 50}
console_get_crawl_issues
ChatGPTURLs Bing had trouble crawling on the user's property: HTTP errors, redirects, robots.txt blocks, DNS and timeouts, with the inbound link count of each. Use when: "what is Bing failing to crawl", "which of my pages 404", a Bing-side health check. Not for: Google, which exposes nothing equivalent outside console_inspect_url. A crawl of the whole site with our crawler, use seo_run_technical_crawl. Returns: List, one row per URL and issue. rows[]: url, issue (Code301, Code302, Code4xx, Code5xx, BlockedByRobotsTxt, ContainsMalware, ImportantUrlBlockedByRobotsTxt, DnsErrors, TimeOutErrors), http_status, inlinks, seen_at. Fixed issues stay listed a few days. Cost: 0 credits, Bing only. Cached 6 hours. Example: {"property": "https://example.com"}
console_get_search_analytics
ChatGPTClicks, impressions, CTR and average position from the user's own Search Console or Bing data, grouped by query, page, country, device or date. Use when: "which queries bring traffic to my site", "how did page X do last month", "impressions by country", finding queries that rank on page two, a rank check on the user's own site. Not for: a site the user does not own, use seo_get_ranked_keywords. Search volume or difficulty, use seo_get_keyword_metrics. Why a page is not indexed, use console_inspect_url. Returns: List, most clicks first, ties broken by impressions descending. rows[]: query, page, country (ISO alpha-3), device, date (the dimensions asked for; null otherwise), clicks, impressions, ctr (0 to 1), position (average, 1-based). Google data lags about two days and keeps 16 months; Bing query and page rows are the last weeks with no date range, its date rows are daily totals. Totals (sum of clicks, impressions) differ by grouping due to Google's aggregation; this is normal Google behaviour. Cost: 0 credits. Cached 6 hours. Example: {"property": "sc-domain:example.com", "dimensions": ["query", "page"], "start_date": "2026-08-01", "end_date": "2026-08-31"}
console_get_sitemaps
ChatGPTThe sitemaps submitted for one of the user's properties, with when they were read, how many URLs they carry and their errors. Use when: "is my sitemap picked up", "how many URLs did Google read from the sitemap", checking a submission after a site change. Not for: submitting or resubmitting one, use console_submit_sitemap. Whether one URL is indexed, use console_inspect_url. Finding pages a sitemap misses, use seo_run_technical_crawl. Returns: List. rows[]: path, type, submitted_at, last_read_at, pending, is_index, urls_submitted, urls_indexed (Google reports 0 today), warnings, errors. null = the engine does not say. Cost: 0 credits. Cached 10 minutes. Example: {"property": "https://www.example.com/"}
console_inspect_url
ChatGPTGoogle's index status for one URL of the user's property: indexed or not and why, last crawl, canonical, mobile usability and rich results. Use when: "why is this page not in Google", "when was this page last crawled", "which canonical did Google pick", checking a page after a fix. Not for: many URLs at once (Google allows 2,000 inspections per property per day, shared by everyone on the property), use console_get_search_analytics with dimension page to find which pages get impressions. The page's own HTML, use seo_get_page. Bing, which has no inspection. Returns: Record. verdict (PASS | PARTIAL | FAIL | NEUTRAL), coverage_state (Google's sentence, for example Submitted and indexed), indexing_state, robots_txt_state, page_fetch_state, last_crawl_at, crawled_as, google_canonical, user_canonical, referring_urls[], sitemaps[], mobile_usability and rich_results (each a verdict with its issues), inspection_link. null = Google did not report it. Cost: 0 credits, Google only. Cached 24 hours. Example: {"property": "sc-domain:example.com", "url": "https://www.example.com/pricing"}
console_list_properties
ChatGPTThe Search Console and Bing Webmaster properties the workspace's connected accounts can read. The first console call; every other console tool takes a property from here. Use when: "what sites are in my Search Console", before any console_get_* call, or to check which engine is connected. Not for: third-party sites the user does not own, use seo_get_domain_overview. Live rankings, use seo_get_serp. Returns: List. rows[]: engine (google | bing), property (the id to pass on: sc-domain:example.com, https://example.com/ or a Bing site URL), permission (Google: siteOwner, siteFullUser, siteRestrictedUser, siteUnverifiedUser; Bing: null), verified. NotConnected when no account of that engine is connected; its connect_url is where the user connects one. Cost: 0 credits. The user's own data is free; 60 console calls per minute per workspace. Cached 1 hour. Example: {"engine": "all"}
console_submit_sitemap
ChatGPTSubmits or resubmits a sitemap for one of the user's properties, asking Google or Bing to read it again. A write to the user's own account. Use when: "get my new pages indexed", "I just published", "tell Google about the sitemap", after a site change or migration. Resubmitting the same sitemap is how to say it changed. Not for: specific URLs on Bing now, use console_submit_urls. Whether a page is indexed, use console_inspect_url. Google has no API to request indexing of one URL; the sitemap is the way. Returns: Record. engine, property, sitemap_url, submitted_at (when Manifold sent it). The engine reads it later, usually within hours; console_get_sitemaps shows when. Cost: 0 credits. Never cached. A connection made with read access only answers NotConnected; the user reconnects to grant submit access. Example: {"property": "sc-domain:example.com", "sitemap_url": "https://www.example.com/sitemap.xml"}
console_submit_urls
ChatGPTAsks Bing to crawl specific URLs of the user's site now, within Bing's daily quota for the site. A write to the user's own account. Use when: "get these pages into Bing", "I just published this post", a page Bing has not crawled yet, a fixed page that should be recrawled. Not for: Google, which has no API for this; use console_submit_sitemap with engine google. A whole site, use console_submit_sitemap. Pages Bing failed to crawl, use console_get_crawl_issues first. Returns: List. rows[]: url (sent to Bing). quota: daily_remaining, monthly_remaining, left after this call. errors[]: URLs not under the site (InvalidTarget) and URLs over the quota, not sent (ProviderUnavailable). Cost: 0 credits, Bing only. Never cached. Bing's quota starts near 10 URLs a day for a new site and grows with its age. Example: {"property": "https://www.example.com/", "urls": ["https://www.example.com/blog/new-post"]}
facebook_get_group_posts
ChatGPTThe posts in one Facebook group, newest first. Use when: watching a community you sell into, the way reddit_get_new_posts watches a subreddit. Not for: a page's own posts, use facebook_get_posts. A complete window since a moment, which Facebook does not offer: page with the cursor and dedupe on id. Returns: List. rows[]: posts with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. top_comments are the comments Facebook shows under the post, with each commenter's profile URL. null or empty = the platform does not publish it. Give the group's url. Cost: 1 credit per page. Cached 6 hours. Example: {"url": "https://www.facebook.com/groups/742354120555345"}
facebook_get_post
ChatGPTOne Facebook post with its reactions, comments, shares and views. Use when: a row is worth the detail, or you have a URL and nothing else. Not for: the comments themselves, use facebook_get_comments. What is said in a video, use facebook_get_transcript. Returns: Record. rows[]: the one post, with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. null or empty = the platform does not publish it. Cost: 1 credit. Cached 6 hours. Example: {"url": "https://www.facebook.com/reel/1535656380759655"}
facebook_get_posts
ChatGPTThe posts on one Facebook page, newest first. Use when: watching what a business page publishes, judging cadence and reactions. Not for: a group's posts, use facebook_get_group_posts. One post in full, use facebook_get_post. Returns: List. rows[]: posts with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. top_comments are the comments Facebook shows under the post, with each commenter's profile URL. null or empty = the platform does not publish it. Facebook publishes no share count, so shares is null. Give one of handle (a page name) or url. Cost: 1 credit per page. Cached 6 hours. Example: {"url": "https://www.facebook.com/gymshark"}
facebook_get_profile
ChatGPTOne Facebook page: its followers, its category, its address and its website. Use when: checking a business page is real and current, reading its category and contact details. Not for: its posts, use facebook_get_posts. Its ads, use ads_get_advertiser_ads with platform facebook. Returns: Record. The page's handle, name, bio, followers, likes, website, links, email and phone (its public contact details), running_ads (whether it is advertising now) and ad_library_id (what ads_get_advertiser_ads takes for it), with other profile fields where Facebook fills them. null or empty = the platform does not publish it. kind is company, because these are pages rather than people. Give one of handle (a page name) or url. Cost: 1 credit. Cached 24 hours. Example: {"url": "https://www.facebook.com/gymshark"}
facebook_get_transcript
ChatGPTWhat is said out loud in one Facebook video or reel, as text. Use when: reading a video without watching it, pulling the claims out of a page's ad or clip. Not for: the post's text, which facebook_get_post already returns. Returns: Record. platform, url, language, text (the full transcript, uncut). NoData when the post carries no speech. Cost: 1 credit. Cached 30 days. Example: {"url": "https://www.facebook.com/reel/1535656380759655"}
get_task
ChatGPTThe result of a run_ tool, or TaskPending while it runs. Use when: you hold a task_id from seo_run_technical_crawl or aeo_run_ai_answers. Not for: starting work; call the run_ tool first. Returns: Record. The same shape the synchronous tool would return, under result, with meta.credits_charged as settled. A task still running holds the call up to 25 seconds, then answers TaskPending: call get_task again at once, with no wait first. TaskFailed carries the reason. Cost: 0 credits. Example: {"task_id": "task_01J..."}
instagram_get_post
ChatGPTOne Instagram post or reel with its caption and its engagement. Use when: a row is worth the detail, or you have a URL and nothing else. Not for: the comments, use instagram_get_comments. What is said in a reel, use instagram_get_transcript. Returns: Record. rows[]: the one post, with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. top_comments are the first comments, author_followers the owner's following, and is_ad is true for a paid partnership. null or empty = the platform does not publish it. likes is null when the owner hides like counts. Cost: 10 credits when the vendor has to fetch the media, 1 when it does not. The estimate is the higher one. Cached 6 hours. Example: {"url": "https://www.instagram.com/p/DKSMEpKRd6h/"}
instagram_get_posts
ChatGPTThe posts on one Instagram account, newest first. Use when: "what has this account been posting", judging cadence and engagement before a partnership. Not for: reels only, use instagram_get_reels. One post in full, use instagram_get_post. Posts by hashtag, use instagram_search_posts. Returns: List. rows[]: posts with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[], plus collaborators (co-authors) and tagged (the accounts tagged in the media). null or empty = the platform does not publish it. likes is null when the owner hides like counts. Cost: 1 credit per page. Cached 6 hours. Example: {"handle": "gymshark"}
instagram_get_profile
ChatGPTOne Instagram account: followers, posts and whether it is a business account. Use when: sizing a creator or a brand, checking a handle, reading a bio and its link before outreach. Not for: the account's posts, use instagram_get_posts or instagram_get_reels. Posts by topic, use instagram_search_posts. Returns: Record. The account's handle, name, bio, verified, followers, following, website, links (its other bio links), email and phone (a business account's public contact buttons) and related (accounts Instagram suggests beside it), with other profile fields where Instagram fills them. null or empty = the platform does not publish it. posts_count is null: a signed-out visitor is shown 12 posts whatever the account has, so count posts from instagram_get_posts. kind is company only when Instagram flags a business account; many brands use a creator-style professional account and read person, so judge a brand by industry and bio. Cost: 1 credit. Cached 24 hours. Example: {"handle": "gymshark"}
instagram_get_reels
ChatGPTThe reels on one Instagram account, newest first. Use when: video is what matters: watching a brand's reel cadence, pulling a creator's recent reels. Not for: every post type, use instagram_get_posts. What is said in a reel, use instagram_get_transcript. Returns: List. rows[]: reels with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[], plus collaborators (co-authors), tagged (the accounts tagged in the media) and music (the audio). null or empty = the platform does not publish it. likes is null when the owner hides like counts. Cost: 1 credit per page. Cached 6 hours. Example: {"handle": "gymshark"}
instagram_get_transcript
ChatGPTWhat is said out loud in one Instagram reel, as text. Use when: reading a reel without watching it, pulling the claims out of a creator's video. Not for: the caption, which instagram_get_post already returns. The numbers, use instagram_get_post. Returns: Record. platform, url, language, text (the full transcript, uncut). NoData when the reel carries no speech. The vendor transcribes reels up to two minutes long; a longer one is refused as InvalidTarget with the reason. Cost: 1 credit. Cached 30 days. Example: {"url": "https://www.instagram.com/reel/DKSMEpKRd6h/"}
instagram_search_posts
ChatGPTInstagram posts under one hashtag. Use when: "who is posting about X on Instagram", watching a campaign hashtag or a product tag. Not for: free-text search (Instagram search is by hashtag here: a phrase is run together into one tag, "gym wear" searches #gymwear). One account's posts, use instagram_get_posts. Returns: List, ranked by Instagram. rows[]: posts with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[], plus music (the audio); top_comments are the first comments, where Instagram sends them. null or empty = the platform does not publish it. Search does not say when an owner hides like counts, which then read exactly 3: leave those rows out of engagement rates. Cost: 1 credit per page. Cached 6 hours. Example: {"query": "#gymshark", "since": "week"}
leads_get_company
ChatGPTThe full firmographic record of one company, by domain. Use when: "tell me about acme.com", sizing a company, the industry, revenue range and headcount growth behind a domain, filling in a search row. Not for: search traffic and rankings, use seo_get_domain_overview. Who works there, use leads_search_people. Email addresses, use leads_get_domain_emails. Returns: Record. id, name, domain, website, linkedin_url, industry, industries[], employees, headcount_range, headcount_growth[] (months, percent), location, founded_year, company_type, description, keywords[], revenue (USD, where disclosed), revenue_min and revenue_max (the estimated range, USD), total_funding, funding_stage, technologies[], phone, ticker. null = the provider does not hold it; total_funding, funding_stage, technologies and ticker are always empty. NoData when the provider does not know the domain. Cost: 1 credit. Cached 30 days. Example: {"domain": "acme.com"}
leads_get_domain_emails
ChatGPTEmail addresses known for a website's domain, with name, role, confidence and where each was seen. The contact-finding tool for link outreach. Use when: "find someone to email at these sites about a backlink", "who runs content at example.com", "get contacts for the referring domains of X". Not for: one named person, use leads_get_email. People by title across many companies, use leads_search_people. Checking an address works, use leads_get_email_status. Choosing which sites to contact, use seo_get_referring_domains, seo_get_backlinks, seo_get_domain_ratings. Returns: List, highest confidence first. rows[]: domain, email, first_name, last_name, position, department, seniority, decision_maker, type (personal | generic), confidence (0 to 100), verification_status, sources[] (url, last_seen_at; empty = inferred from the domain's pattern), linkedin_url, twitter, phone. domains[]: domain, pattern (the address format, for example {first}.{last}), organization, accept_all (true = the server takes any address, so no address there can be proven), webmail, disposable, linked_domains[], rows_available. errors[] lists domains that failed. Addresses come back unverified for the most part; verify the shortlist with leads_get_email_status, not the whole list. Cost: 1 credit per domain + 30 per domain that returns addresses, whatever the limit. Default one domain with 30 addresses = 31 credits. Cached 30 days. Example: {"domains": ["example.com"], "department": ["marketing", "communication"], "type": "all"}
leads_get_email
ChatGPTFind and verify the work email of one named person. The only paid reveal keyed by a person; it runs a waterfall of sources (findymail, then icypeas) and stops at the first verified hit. Use when: you have a person and their company and need an address to send to, "get me the email of Jordan Blake at acme.com", after leads_search_people found the person. Not for: anyone at a website (no name), use leads_get_domain_emails. Checking an address you already hold, use leads_get_email_status. The person's role and history, use leads_get_person. Returns: Record. first_name, last_name, domain, email, confidence (0 to 100, null when the source gives none), verification_status (valid | accept_all | invalid | unknown), found_by (the source that hit), position, linkedin_url, twitter, phone, sources[] (url, last_seen_at: where the address was seen). verification_status is the verdict of the source that hit: findymail returns only addresses it verified itself, catch-all domains included, so its hits read valid with null confidence and no sources; only a hit with no verdict is checked by the verifier before it is returned. leads_get_email_status asks that other verifier, which can call the same address accept_all. position, linkedin_url, twitter, phone and sources are null or empty unless the source that hit reports them. NoData when no source finds one; do not retry. meta.providers_tried lists the sources asked, in order; with an id and no name the first is the people source that turns the profile into a name and domain, not a finder that missed. A source that does not answer in time is skipped; when none answers, ProviderUnavailable at no charge. Give id, or first_name + last_name + domain, or both: the name and domain beside an id skip the paid profile lookup. Cost: 7 credits on a hit, 31 when provider is hunter, plus 9 for an id given without a name; nothing on NoData. Cached 90 days. Example: {"first_name": "Jordan", "last_name": "Blake", "domain": "acme.com"}
leads_get_email_status
ChatGPTWhether an email address the user already has will deliver. Use when: "is jane@acme.com still valid", cleaning a list before a send, checking a shortlist from leads_get_domain_emails. Not for: finding an address, use leads_get_email or leads_get_domain_emails. Returns: Record. email, status (valid | invalid | accept_all | unknown; accept_all means the server takes anything, so the address is unproven), result (deliverable | undeliverable | risky | unknown), score (0 to 100), mx_records, mail_provider (who runs the mail servers: google, microsoft, or a filter such as mimecast). disposable, webmail and smtp_check are null: the verifier does not report them, so judge free-mail and throwaway domains by the domain. Cost: 1 credit. Cached 30 days. Example: {"email": "jane@acme.com"}
leads_get_person
ChatGPTThe full record of one person: real name, title, company, location, LinkedIn, employment history and education. No email. Use when: filling in a search row by id, "who is the head of growth at acme.com", checking a person's current role before outreach. Not for: the email, use leads_get_email (the paid reveal). Many people at once, use leads_search_people. Returns: Record. id, first_name, last_name, headline, title, title_start, seniority, company, company_domain, company_id, company_linkedin_url, company_employees, company_industry, location, linkedin_url, has_email, summary, employment_history[] (company, title, start, end, current; newest first), education[] (school, degree, field, start, end), skills[], languages[]. Dates are YYYY-MM. null or empty = the provider does not hold it; looked up by name and domain, the history is the current role only and education, skills and languages are empty. NoData when nobody matches. Give id, or first_name + last_name + domain, or linkedin_url. Cost: 9 credits by id or linkedin_url, 3 by name and domain, nothing on NoData. Cached 30 days. Example: {"first_name": "Jordan", "last_name": "Blake", "domain": "northstaranalytics.io"}
leads_search_companies
ChatGPTCompanies matching a name, keywords, location or headcount. Use when: "find fintech companies in London with 50 to 200 staff", "companies that do X", building an account list by firmographics. Not for: one known company, use leads_get_company (by domain). People at companies, use leads_search_people. A site's traffic, use seo_get_domain_overview. Local shops and services in an area, use maps_search_businesses. Returns: List. rows[]: id, name, domain, website, linkedin_url, industry, employees, headcount_range, headcount_growth[] (months, percent), location, founded_year, company_type, description, keywords[], revenue_min and revenue_max (the estimated annual revenue range, USD), phone. rows_available is the provider's total before the keyword check. A row is kept only when one of the keywords or unlisted industries appears in its name, industry, description or specialties, so a page can return fewer rows than limit; the charge counts the rows fetched. Give at least one of name, keywords, industries, locations or employee_ranges. Cost: 12 credits per 100 rows asked for (limit), rounded up. Default 12 credits. Cached 30 days. Example: {"keywords": ["payments"], "locations": ["London"], "employee_ranges": ["51,200"]}
leads_search_people
ChatGPTPeople matching title, seniority and company filters. No email. Use when: "find heads of marketing at fintech startups", building a target list by role, prospecting by ICP. Not for: someone to email at a specific website about a link, use leads_get_domain_emails (keyed by domain). One person's full record, use leads_get_person. An email for a named person, use leads_get_email. Returns: List. rows[]: id (the LinkedIn profile URL; null when the person has no profile, so look them up by name and domain), first_name, last_name, headline, title, title_start (YYYY-MM, so time in the role), company, company_domain, company_id, company_linkedin_url, company_employees, company_industry, location, linkedin_url. rows_available is the provider's total. Give at least one of titles, seniority, company_domains, industries, locations or keywords. Cost: 12 credits per 100 rows asked for (limit), rounded up. Default 12 credits. Cached 7 days. Example: {"titles": ["head of marketing"], "industries": ["fintech"], "locations": ["London"], "limit": 50}
linkedin_get_company
ChatGPTOne LinkedIn company page: headcount, industry, location and website. Use when: sizing a company from its own page, confirming an industry and a headcount band before outreach. Not for: a company's own posts, use linkedin_get_company_posts. A richer firmographic record, use leads_get_company. A person, use linkedin_get_profile. Returns: Record. The page's handle, name, bio, followers, website, location, industry, employees (LinkedIn's own headcount), founded, company_type, topics (its specialties), people (the few employees the page shows, with profile URLs and usually no title) and related (similar pages), with other profile fields where LinkedIn fills them. null or empty = the platform does not publish it. kind is company. running_ads and ad_library_id are always null here: the page does not say whether the company advertises; ads_get_advertiser_ads with platform linkedin and the company name does. Give one of handle (the company slug) or url. Cost: 1 credit. Cached 24 hours. Example: {"handle": "shopify"}
linkedin_get_company_posts
ChatGPTThe posts on one LinkedIn company page, newest first. Use when: watching what a competitor publishes, judging cadence and engagement. Not for: posts by topic across LinkedIn, use linkedin_search_posts. One post in full, use linkedin_get_post. Returns: List. rows[]: posts with author, created_at, text (cut at 2000 characters) and transcript. The listing carries no engagement, views or media, so those are null; linkedin_get_post has likes, comments and media for one post. created_at is approximate: the platform shows an age such as "3 weeks ago", so it is exact only to that unit. Give one of handle (the company slug) or url. Cost: 1 credit per page. Cached 6 hours. Example: {"handle": "shopify"}
linkedin_get_post
ChatGPTOne LinkedIn post with its text, its author, its engagement and its first commenters. Use when: a row from a search is worth the detail, or you have a URL and nothing else. Not for: the commenters as rows to page or export, use linkedin_get_comments. A company's whole feed, use linkedin_get_company_posts. Returns: Record. rows[]: the one post, with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. top_comments are up to 10 commenters with their profile URLs, the same people linkedin_get_comments returns as rows. null or empty = the platform does not publish it. media is video only for a video stream; a photo, a document carousel or a GIF reads image. Cost: 1 credit. Cached 6 hours. Example: {"url": "https://www.linkedin.com/posts/aagupta_what-you-need-to-know-ai-agents-activity-7354600338621906944-RvXR"}
linkedin_get_profile
ChatGPTOne LinkedIn person: their about text, location, followers, companies and latest posts. Use when: checking a person before outreach, reading how they describe themselves. Not for: a company page, use linkedin_get_company. An email address, use leads_get_email. A person's full employment record, use leads_get_person. Returns: Record. The profile's handle, name, bio, followers, location, experience[] (the companies and schools on the profile, with dates but no titles), recent_posts[] (their latest posts, for linkedin_get_comments) and related (similar profiles), with other profile fields where LinkedIn fills them. null or empty = the platform does not publish it. Give one of url or handle (the part after /in/). Cost: 1 credit. Cached 24 hours. Example: {"url": "https://www.linkedin.com/in/williamhgates"}
linkedin_search_posts
ChatGPTLinkedIn posts matching a keyword, ranked by LinkedIn's own search. Use when: "what is being said about X on LinkedIn", finding the people posting about a category. Not for: one company's posts, use linkedin_get_company_posts. Finding people to contact, use leads_search_people. Returns: List, ranked. rows[]: posts with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. top_comments are up to 10 commenters per post with their profile URLs, so one page names the people engaging with a topic; transcript is what a video post says. media is video only for a video stream; a photo, a document carousel or a GIF reads image. null or empty = the platform does not publish it. created_at is approximate: the platform shows an age such as "3 weeks ago", so it is exact only to that unit. Cost: 1 credit per page. Cached 6 hours. Example: {"query": "rfp automation", "since": "week"}
maps_get_place
ChatGPTOne business's full Google Business Profile: categories, hours, description, rating breakdown and the topics its reviews mention. Use when: "audit this business's Google profile", "what do reviews of this clinic talk about", "what is this practice's primary category", checking a prospect before outreach. Not for: finding businesses or a business's local rivals, use maps_search_places (by search) or maps_search_businesses (by area and filters). The review text itself is not returned. A company's firmographics, use leads_get_company. Returns: Record. place_id, cid, name, category, additional_categories[], address, phone, website, domain, rating, reviews, is_claimed, status, maps_url, description, rating_counts[] (1 star first), hours[] (day, open, close as HH:MM; a day with no row is closed), attributes[], topics[] (topic, mentions), services[], people_also_search[], book_online_url. services[] and people_also_search[] come back empty upstream, and attributes[] holds little beyond accessibility: an empty list is not a gap in the profile. NoData when Google has no profile for the lookup. Give exactly one of place_id, cid or name. Cost: 2 credits. Cached 7 days. Example: {"place_id": "ChIJP0warDDowokRfvXMkBqL5Cg"}
maps_search_businesses
ChatGPTBusinesses on Google Maps within a radius of a point, filtered by category, rating, review count or claimed profile. Not ranked. Use when: "dentists within 10 km of Manchester with fewer than 20 reviews", "unclaimed restaurants in Leeds", local prospect lists for an agency, counting a category in a town. Not for: who ranks on Maps for a search, use maps_search_places. One business in full, use maps_get_place. Companies by industry or headcount (larger firms, not storefronts), use leads_search_companies. Returns: List. rows[]: place_id, cid, name, category, address, phone, website, domain, rating (stars out of 5), reviews, is_claimed, status (open, closed, temporarily_closed, closed_forever), maps_url and the other Maps profile fields. website null = the profile lists none, a prospect for web work. rows_available is the total matching. Cost: 4 credits, plus 12 per 100 rows. Default 100 rows = 16 credits. Cached 7 days. Example: {"latitude": 53.4808, "longitude": -2.2426, "radius_km": 10, "categories": ["dentist"], "max_reviews": 20}
maps_search_places
ChatGPTThe places Google Maps shows for a search in an area, in Maps' order. Use when: "who shows up on Maps for plumber in Austin", "where does our clinic rank on Maps for dentist near me", local competitors for a service in a town, a spot check of local rankings at one point. Not for: a filtered list of every business of a type in an area (unclaimed, few reviews, low rating), use maps_search_businesses. One business's hours, primary category and review topics, use maps_get_place. The organic results and local pack on Google search, use seo_get_serp. Companies by industry or headcount, use leads_search_companies. Returns: List. rows[]: rank, place_id, cid, name, category, address, phone, website, domain, rating (stars out of 5), reviews, is_claimed, status (open, closed, temporarily_closed, closed_forever), maps_url and the other Maps profile fields. website null = the profile lists none. Give latitude and longitude together to search around a point instead of location. Rankings differ by point: for a rank grid, call once per point. Cost: 1 credit. Cached 24 hours. Example: {"keyword": "emergency plumber", "location": "Austin,Texas,United States"}
reddit_get_new_posts
ChatGPTEvery post created in the given subreddits inside a time window, oldest first. The check-in tool: complete for the window it reports, unlike search. Use when: "anything new in r/startups since yesterday", "watch these subreddits for mentions of our category", any repeated look at the same communities. Not for: keyword search across all of Reddit, use reddit_search_posts (ranked, not complete). Reading a thread, use reddit_get_post and reddit_get_comments. Choosing which subreddits to watch, use reddit_search_subreddits. Returns: List, oldest first. rows[]: id, subreddit, title, author, created_at, score, comments, upvote_ratio, url, link_url, body, flair, over_18, is_video. coverage[] per subreddit: covered_from, complete, pages_fetched. covered_from later than since, or complete false, means the window was cut: raise pages, shorten since, or pass meta.cursor. next_since is the value to send as since next time; it overlaps by two minutes, so dedupe rows on id. Cost: 1 credit per subreddit per page. Three subreddits at the default is 3 credits. Never cached. Example: {"subreddits": ["startups", "SaaS"], "since": "24h", "match": ["crm", "pipeline"]}
reddit_get_post
ChatGPTOne Reddit thread in full: the whole post body, its score, its flair and how big the community is. Use when: a row from a search or a check-in is worth reading properly, or you need the full text a row cut at 2000 characters. Not for: the replies, use reddit_get_comments. Finding threads in the first place, use reddit_search_posts or reddit_get_new_posts. Returns: Record. id, subreddit, title, author, created_at, score, comments, upvote_ratio, url, link_url, body (full), flair, over_18, is_video, locked, archived. Cost: 1 credit. Cached 1 hour. Example: {"url": "https://www.reddit.com/r/startups/comments/1lfbo7u/what_crm_do_you_use/"}
reddit_get_subreddit
ChatGPTOne community: how big it is, how busy it is, and the rules it posts, as the moderators wrote them. Use when: before you post or reply anywhere, to read the rules on self promotion; sizing a community found by reddit_search_subreddits. Not for: the posts in the community, use reddit_get_new_posts or reddit_search_posts. Finding communities, use reddit_search_subreddits. Returns: Record. name, url, weekly_active_users (visitors in a week, Reddit's measure of size; it publishes no member count), weekly_contributions (posts and comments in a week), description, rules (the text as written; read it, it is not parsed into flags), submit_text, created_at. Cost: 1 credit. Cached 7 days. Example: {"subreddit": "SaaS"}
reddit_search_posts
ChatGPTReddit posts matching a query, ranked by the search, across all of Reddit or inside one community. Use when: "what do people on Reddit say about X", "find threads complaining about Y", "who is asking for a tool like ours". Not for: everything new in a community since you last looked, use reddit_get_new_posts (ranked search is never complete). Reading one thread, use reddit_get_post and reddit_get_comments. Choosing communities to watch, use reddit_search_subreddits. Returns: List, ranked, not exhaustive. rows[]: id, subreddit, title, author, created_at, score, comments, upvote_ratio, url, link_url, body (cut at 2000 characters), flair, over_18, is_video. Cost: 1 credit per call, up to about 25 posts; nothing on NoData. Cached 1 hour. Example: {"query": "hubspot alternative", "sort": "new", "time_range": "month"}
reddit_search_subreddits
ChatGPTThe communities that discuss a topic, counted from one page of search results. Use when: "which subreddits talk about X", picking the communities to pass to reddit_get_new_posts, sizing where a conversation happens. Not for: a full directory of subreddits about a topic (this counts a sample of posts, so a quiet community can be missing). One community's rules and size, use reddit_get_subreddit. The posts themselves, use reddit_search_posts. Returns: List, most posts in the sample first. rows[]: name, url, posts_in_sample, example_post_url. Search carries no community size; reddit_get_subreddit gives weekly visitors. Cost: 1 credit. Cached 1 hour. Example: {"query": "cold email deliverability", "time_range": "year"}
seo_get_backlink_summary
ChatGPTLink totals for a domain or page: backlinks, referring domains, dofollow share, link types and domain rank. Use when: "how many links does X have", "what is X's link profile like", a quick authority check alongside seo_get_domain_overview. Not for: the individual links or their anchor text, use seo_get_backlinks. The sites linking, use seo_get_referring_domains. Domain rank for many domains, use seo_get_domain_ratings. Returns: Record. domain_rank (equals seo_get_domain_overview's domain_rank), backlinks, referring_domains, referring_main_domains, referring_ips, dofollow_share (0 to 1), broken_backlinks (links to a page of the target that answers 4xx or 5xx), broken_pages (such pages), spam_score (backlinks' average, 0 to 100), target_spam_score, first_seen, and counts by link type, attribute, placement, platform, TLD and country (top 10). null = provider has no data. Cost: 10 credits flat. Cached 7 days. Example: {"target": "competitor.com"}
seo_get_backlinks
ChatGPTIndividual backlinks pointing at a domain or page, strongest referring domain first. Use when: "show me the links to this page", "which pages link to competitor.com", finding link sources to replicate, "which links did we lose" (status lost). Not for: totals only, use seo_get_backlink_summary. One row per linking site, use seo_get_referring_domains. Rating the linking sites, use seo_get_domain_ratings. Returns: List. rows[]: url_from, url_to, domain_from, dr_from, page_title, anchor, dofollow, rel[] (nofollow, sponsored, ugc and other rel values), type, spam_score (0 to 100), url_to_status (HTTP status of url_to), broken (url_to answers 4xx or 5xx), first_seen, last_seen (for a lost link, about when it went), lost (only with status lost or all). dr_from is the linking domain's own rank, 0 to 1000. Cost: 10 + 1.5 per 100 rows. Default 100 rows = 12 credits. Cached 7 days. Example: {"target": "https://competitor.com/blog/best-crm", "limit": 50}
seo_get_domain_overview
ChatGPTTraffic estimate, ranked keyword count, position spread, top pages and domain rank for one domain. The canonical source of domain rank. Use when: "how strong is competitor.com", "how much traffic does X get", sizing a site before a deeper look. Not for: the keywords behind the traffic, use seo_get_ranked_keywords. Link counts, use seo_get_backlink_summary (its domain_rank equals this one). Many domains at once, use seo_get_domain_ratings for domain rank or seo_get_traffic_estimates for traffic. Returns: Record. domain_rank (0 to 1000 on DataForSEO, the same kind of number as Ahrefs DR or Moz DA but not the same scale), organic_traffic, organic_keywords, organic_traffic_cost (USD), positions (top_3, top_10, top_100), keyword_changes (new, up, down, lost since the provider's previous update), paid_traffic, paid_keywords, top_pages[] (url, organic_traffic, organic_keywords), history[] (12 months: month, organic_traffic, organic_keywords) only with history true. null = provider has no data. A traffic figure saved before 1 November 2026 may be on DataForSEO's older traffic model: take a new baseline rather than compare across that date. history[] may keep the older model, so compare its months with each other, not with organic_traffic. Cost: 15 credits; +56 with history. Cached 7 days. Example: {"target": "competitor.com"}
seo_get_domain_ratings
ChatGPTDomain rank and Ahrefs DR only, for up to 1,000 domains in one call. The cheap way to rate a list. Use when: "rate these domains", "which of these sites are worth a link", filtering a prospect list by authority. Not for: traffic numbers, use seo_get_traffic_estimates (10x the cost). A full profile of one domain, use seo_get_domain_overview or seo_get_backlink_summary. Returns: List. rows[]: domain, domain_rank (0 to 1000 on DataForSEO, for the host as given; 0 for a domain the index does not know), ahrefs_dr (Ahrefs Domain Rating, 0 to 100, always for the registered domain, so www.github.com and gist.github.com both get github.com's; 0 for a domain Ahrefs does not know, null when it did not answer). One row per distinct domain, in the order first given: duplicates and case variants are merged, and a full URL is rated by its host. ahrefs_status says what a null ahrefs_dr means: ok (Ahrefs has no rating), partial (the domains in ahrefs_unanswered got no answer), failed or not_configured (Ahrefs did not answer; the null says nothing). ahrefs_attribution: wherever you show ahrefs_dr, show its text linked to its url next to it. errors[] lists inputs that were not valid domains. Cost: 7 + 2.5 per 100 domains, for domain_rank; ahrefs_dr adds nothing. Default 100 domains = 10 credits. Cached 7 days, or 1 hour when ahrefs_status is not ok. Example: {"targets": ["example.com", "competitor.com", "blog.example.net"]}
seo_get_keyword_gap
ChatGPTKeywords one competitor ranks for in the top 100 that the target does not rank for at all. Use when: "what does competitor.com rank for that we do not", "find gaps against X", content opportunities from a rival. Not for: everything a domain ranks for, use seo_get_ranked_keywords. Finding who the competitors are, use seo_get_serp_competitors. Fresh ideas around a topic, use seo_search_keywords. Returns: List. rows[]: keyword, competitor, competitor_rank, competitor_url, volume, kd, cpc, intent. Sorted by volume. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"target": "example.com", "competitor": "competitor.com", "limit": 100}
seo_get_keyword_metrics
ChatGPTVolume, difficulty, intent, CPC and 12-month trend for keywords you already have, with AI-engine prompt volume on request. Use when: the user supplies keywords, or you need numbers for a list from elsewhere. ai_volume true when the question is how often AI engines see the keyword. Not for: discovering keywords, use seo_search_keywords (it already includes these metrics, do not call this after it). AI-engine prompts, use aeo_search_prompts. Checking rankings, use seo_get_position. Returns: List. rows[]: keyword, volume, kd, intent, cpc, competition, bid_low, bid_high (Google Ads top-of-page bid range, USD), trend[12], ai_volume, ai_trend[12]. One row per input keyword in the order given. volume/kd null = provider has no data; 0 = measured zero. With source google_ads, kd and intent are always null and keywords over 80 characters come back all null. ai_volume and ai_trend are null unless ai_volume is true. Cost: 5 + 5 per 100 keywords with source labs; 24 flat with source google_ads; ai_volume adds 4 + 4 per 100 keywords. Default 100 keywords = 10 credits. Cached 7 days. Example: {"keywords": ["crm for startups", "hubspot alternative"], "ai_volume": true}
seo_get_page
ChatGPTAn on-page snapshot of one URL: title, meta description, canonical, robots, headings, word count, schema types and link counts. Fetched live, free. Use when: "check the on-page SEO of this URL", "what schema does this page use", "what jobs are on their careers page", a quick look before a crawl. Not for: a whole site, use seo_run_technical_crawl. Rankings for the page, use seo_get_ranked_keywords with the URL. What the page ranks against, use seo_get_serp. Returns: Record. url, final_url, status, title, meta_description, canonical, robots_meta, lang, h1[], h2[], word_count, schema_types[], links_internal, links_external, images, images_without_alt; with include, links[] (text, url) and text (without nav, header and footer). null = the tag is absent. Cost: 0 credits, rate limited. Cached 1 hour. Example: {"url": "https://example.com/pricing"}
seo_get_position
ChatGPTWhere one target ranks for one keyword, scanning the top 100 server-side. Use when: "where does example.com rank for X", "did we make page one for X", a rank check for a handful of keywords. Not for: every keyword a domain ranks for, use seo_get_ranked_keywords. The full page-one list, use seo_get_serp. Tracking over time: monitoring_create_monitor with google_rankings. Returns: Record. keyword, target, rank (absolute, null when not in the top 100), organic_rank, url, title, scanned_depth, above[] (rank, domain, url of the organic results ahead, at most 10). For a local business, location does not localise the organic rank of a bare service search ("dentist"); put the town in the keyword ("dentist columbus ohio"), or use maps_search_places for the Maps rank. Cost: 6 credits flat, also when the target is not in the top 100. NoData (free) only when the keyword has no organic results. Cached 24 hours. Example: {"keyword": "hubspot alternative", "target": "example.com"}
seo_get_ranked_keywords
ChatGPTKeywords a domain or one page ranks for in the top 100, with position, URL and metrics. Use when: "what does competitor.com rank for", "which keywords send traffic to this page", building a list of a site's topics. Not for: keywords a competitor has that you do not, use seo_get_keyword_gap. One keyword's position, use seo_get_position. New keyword ideas, use seo_search_keywords. Returns: List. rows[]: keyword, rank, type (organic, featured_snippet or local_pack; ads excluded), previous_rank (null = did not rank at the provider's previous update), is_new, url, volume, kd, cpc, intent, traffic (estimated monthly visits from this keyword), serp_features[] (SERP feature types on the keyword's page). A keyword can appear once per type. Sorted by traffic, highest first. rank counts every element on the page, ads and features included, so a keyword in the organic top 100 can read rank 104. null = provider has no data. A traffic figure saved before 1 November 2026 may be on DataForSEO's older traffic model: take a new baseline rather than compare across that date. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"target": "competitor.com", "limit": 200}
seo_get_referring_domains
ChatGPTDomains linking to a target, one row per domain, with the rank each passes, link counts and spam score. Use when: "who links to competitor.com", "build a list of sites to pitch for links", link prospecting from a rival's profile, "which sites stopped linking to us" (status lost). Not for: every individual link, use seo_get_backlinks. Totals, use seo_get_backlink_summary. Rating your own list of domains, use seo_get_domain_ratings. Returns: List. rows[]: domain, rank_passed (0 to 1000: the rank this domain's links pass to the target, not the domain's own rank, which seo_get_domain_ratings gives), backlinks, referring_pages, dofollow_backlinks, broken_backlinks (its links to a page of the target that answers 4xx or 5xx), spam_score, first_seen, lost (a link from it was lost; only with status lost or all). Sorted by rank_passed, so the strongest linking sites are not necessarily first: rate the domains before filtering by authority. Cost: 10 + 1.5 per 100 rows. Default 100 rows = 12 credits. Cached 7 days. Example: {"target": "competitor.com", "limit": 200}
seo_get_serp
ChatGPTThe top organic results and SERP features Google shows for one query. Use when: "what ranks for X", "who is on page one for X", "is there a featured snippet or AI overview for X". Not for: where one site ranks for a keyword, use seo_get_position (it scans the top 100 for you). Keyword ideas, use seo_search_keywords. The businesses Google Maps ranks for a local search, use maps_search_places. Returns: Record. features[] (featured_snippet, people_also_ask, video, ai_overview and others), results[] (rank, organic_rank, type, url, domain, title, snippet, published_at, rating), related_searches[], ai_overview (text, references[]) or null, results_count, check_url. depth counts organic rows: the default returns 10 organic results whenever Google has them, with the features ranked among them on top. Each People Also Ask question and each forum thread is its own row at its block's rank; for a question, title is the question and snippet the answer, url null when Google's answer is an AI overview. location localises the local pack, not the organic rows of a bare service search: put the town in the keyword ("dentist columbus ohio") for local organic results. Paid ads seldom come back, so the page says nothing about who bids on the query; a named rival's search ads are in ads_get_advertiser_ads with platform google. Cost: 1 credit per 10 results, +1 with ai_overview. Default top 10 = 1 credit. Cached 24 hours. Example: {"keyword": "hubspot alternative", "depth": 10, "ai_overview": true}
seo_get_serp_competitors
ChatGPTDomains that share search results with a target, with how many keywords overlap. SERP competitors, not business competitors. Use when: "who competes with example.com in search", "which sites show up for the same queries as X", choosing competitors for a keyword gap. Not for: the keywords themselves, use seo_get_keyword_gap. A single domain's strength, use seo_get_domain_overview. Returns: List. rows[]: domain, shared_keywords, avg_position, organic_traffic, organic_keywords, paid_traffic, paid_keywords. Sorted by shared keywords. The target itself is excluded. A traffic figure saved before 1 November 2026 may be on DataForSEO's older traffic model: take a new baseline rather than compare across that date. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"target": "example.com", "limit": 20}
seo_get_traffic_estimates
ChatGPTEstimated monthly organic and paid traffic for up to 1,000 domains in one call. Use when: "how much traffic do these sites get", comparing a list of domains by size, checking a prospect list for reach. Not for: authority, use seo_get_domain_ratings (a tenth of the cost). One domain in depth, use seo_get_domain_overview. Returns: List. rows[]: domain, organic_traffic, organic_keywords, paid_traffic. One row per input domain in the order given. null = provider has no data. A traffic figure saved before 1 November 2026 may be on DataForSEO's older traffic model: take a new baseline rather than compare across that date. errors[] lists inputs that were not valid domains. Cost: 50 + 50 per 100 domains. Default 100 domains = 100 credits. Cached 7 days. Example: {"targets": ["example.com", "competitor.com"]}
seo_run_technical_crawl
ChatGPTCrawl a site for technical SEO issues. Slow: returns a task_id, then read the result with get_task. Use when: "audit example.com", "crawl the site for broken links and duplicate titles", a technical health check. Not for: one page, use seo_get_page. Rankings or traffic, use seo_get_domain_overview. Lighthouse scores, which it does not run. Returns: Task. task_id now; get_task returns target, pages_requested, pages_crawled, rendered, onpage_score, status_codes (crawled pages per HTTP status), broken_links (links, not pages: one broken link in a template counts once per page), broken_resources, non_indexable (URLs blocked from indexing by robots.txt, headers or meta tags, counting linked URLs robots.txt kept the crawler from, so it can exceed pages_crawled), duplicate_titles, duplicate_descriptions, issues[] (check, pages, sample_urls[]). Results expire after 30 days. Cost: 5 credits per 100 pages; 50 per 100 pages rendered. The charge is on max_pages requested, not pages crawled. Default 1,000 pages = 50 credits. Example: {"target": "example.com", "max_pages": 500}
seo_search_keywords
ChatGPTCandidate keywords around a seed, with volume, difficulty, intent, CPC and trend for each. Use when: "find keywords for X", "what should I target around X", "keyword ideas for a page about X". Not for: metrics on keywords the user already has, use seo_get_keyword_metrics (this tool already returns those metrics, so do not call it afterwards). Prompts people ask AI engines, use aeo_search_prompts. The top-10 page for one query, use seo_get_serp. Returns: List. rows[]: keyword, volume, kd (0 to 100), intent, cpc (USD), competition, bid_low, bid_high (Google Ads top-of-page bid range, USD), trend[12] (month, volume). volume, kd, cpc null = provider has no data; 0 = measured zero. Cost: 5 + 5 per 100 rows. Default 100 rows = 10 credits. Cached 7 days. Example: {"seed": "crm for startups", "mode": "suggestions", "limit": 50}
shopping_get_product
ChatGPTOne Google Shopping product: description, specs, images, rating and its offers from each store. Use when: "what specs does Google list for this product", "how is it described and rated across stores". Not for: the store list with shipping and total price, use shopping_get_sellers. Reviews, use shopping_get_reviews. Returns: Record. product_id, gid, data_docid, title, description, url, images[], rating, ratings_count, specs[] (name, value), offers[] (seller, url, price, regular_price, currency, seller_rating, seller_ratings_count, availability). Pass product_id, gid and data_docid together, from one shopping_search_products row. Cost: 1 credit. Cached 1 day. Can take up to a minute. Example: {"product_id": "13896795030841728717", "gid": "12076690216614034454", "data_docid": "10381679383724335789"}
shopping_get_reviews
ChatGPTReviews of one Google Shopping product pooled from the stores that sell it, with the count at each star rating. Use when: "what do buyers say about this product", "what do 1-star reviews of competitor's product complain about". Not for: app reviews, use apps_get_reviews. Amazon reviews: not available. Returns: Record. product_id, title, rating, ratings_count, stars[] (stars, count), rows[]: rating, title, text, author, source (the store the review came from), published_at. Pass product_id, gid and data_docid together, from one shopping_search_products row. Cost: 5 credits per 100 reviews. Default 100 = 5 credits. Cached 7 days. Can take up to a minute. Example: {"product_id": "13896795030841728717", "gid": "12076690216614034454", "limit": 50}
shopping_get_sellers
ChatGPTThe stores Google lists for one Google Shopping product, with base price, shipping, total and the store's rating: a price comparison. Use when: "who sells this cheapest", "is anyone undercutting us", "which retailers carry our product". Not for: the product's specs, use shopping_get_product. Amazon's sellers, use amazon_get_sellers. Returns: Record. product_id, title, rows[]: rank, seller, domain, url, price, shipping (null when free or not shown), total_price, currency, seller_rating, seller_ratings_count, availability, note. Up to 20 stores, often 5 to 10: Google's list for the product, not every store that sells it, and the store on the product's search row can be missing. Pass product_id, gid and data_docid together, from one shopping_search_products row. Cost: 2 credits. Cached 6 hours. Can take up to a minute. Example: {"product_id": "13896795030841728717", "gid": "12076690216614034454", "data_docid": "10381679383724335789"}
shopping_search_products
ChatGPTGoogle Shopping results for a search: products in order with store, price, previous price, rating and delivery, plus the ids the other shopping_* tools take. Use when: "what does Google Shopping show for X", "which stores win Shopping for our product", "what do competitors charge". Not for: Amazon, use amazon_search_products. Google web results, use seo_get_serp. Returns: Record. keyword, rows[]: rank (1 to N over the rows returned), product_id, gid, data_docid, title, seller, price, old_price, currency, rating, ratings_count, tags[], delivery, url. Google's grouped carousels and results with no product page are left out, so fewer rows than depth can come back. A row is an offer: one product can fill two rows. Cost: 1 credit per 40 results. Default 40 = 1 credit. Cached 1 day. Can take up to a minute. Example: {"keyword": "standing desk"}
submit_feedback
ChatGPTSends a report to the Manifold team: an error a tool returned, data that looks wrong, a tool or parameter that is missing, or anything the user asks you to pass on. Free. Use when: a call failed in a way its typed error does not explain, a result contradicts itself or the source, the same ProviderUnavailable keeps coming back, no tool answers what the user needs, "tell Manifold that...". Tell the user what you sent. Not for: retrying a call; follow the typed error first. Asking for help with a task; this sends no reply. Contacting a person or a company; this reaches only the Manifold team. Returns: Record. feedback_id, to quote if the user contacts support. Cost: 0 credits. Up to 20 reports per workspace per day; over that, ProviderUnavailable with retry_after_s. Example: {"kind": "error", "tool": "seo_get_serp", "request_id": "3f1c9a2e-8d4b-4c6f-9e1a-7b2d5c8f0a13", "message": "seo_get_serp returned ProviderUnavailable five times in ten minutes for the keyword crm for startups."}
tiktok_get_audience
ChatGPTWhere one TikTok account's audience is, by country. Use when: checking a creator reaches the market you sell in, before paying for a partnership. Not for: who the followers are, use tiktok_get_followers. The account's size, use tiktok_get_profile. Returns: List, largest share first. rows[]: country, country_code, share (percent, a decimal), count. The split comes from a sample of followers, a few hundred for an account of millions: count is followers in that sample, not in the account, so read share and ignore count as a size. Cost: 26 credits, because the vendor charges 26 for this one call. Check the handle with tiktok_get_profile first. Cached 7 days. Example: {"handle": "gymshark"}
tiktok_get_followers
ChatGPTThe accounts that follow one TikTok account, with their own follower counts. Use when: judging whether a creator's audience is real, looking for the notable accounts in a following. Not for: where an audience is in the world, use tiktok_get_audience. How big the account is, use tiktok_get_profile. Returns: List. rows[]: handle, name, url, followers, following, country (the account's region code), bio. Cost: 1 credit per page. Cached 7 days. Example: {"handle": "gymshark"}
tiktok_get_profile
ChatGPTOne TikTok account: its follower count, its lifetime likes and how many videos it has posted. Use when: sizing a creator or a brand on TikTok, checking a handle is real, reading a bio before outreach. Not for: the account's videos, use tiktok_get_videos. Where its audience is, use tiktok_get_audience. Finding accounts by topic, use tiktok_search_videos and read the authors. Returns: Record. The account's handle, name, bio, verified, followers, following, posts_count, likes, views, website (the link in bio) and links, with other profile fields where TikTok fills them. null or empty = the platform does not publish it. Cost: 1 credit. Cached 24 hours. Example: {"handle": "@gymshark"}
tiktok_get_transcript
ChatGPTWhat is said out loud in one TikTok video, as text. Use when: reading a video without watching it, pulling the claims or the hook out of an ad or a review. Not for: the video's numbers, use tiktok_get_video. The written caption, which tiktok_get_video already returns as text. Returns: Record. platform, url, language, text (the full transcript, uncut). NoData when the video carries no speech the platform kept. Cost: 1 credit, or 11 with ai_fallback. Cached 30 days. Example: {"url": "https://www.tiktok.com/@gymshark/video/7517114944362499342"}
tiktok_get_video
ChatGPTOne TikTok video with its engagement: views, likes, comments, shares and its length. Use when: a row from a search or a listing is worth the detail, or you have a URL and nothing else. Not for: what was said in it, use tiktok_get_transcript. The replies, use tiktok_get_comments. Returns: Record. rows[]: the one video, with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. saves is how many people saved it; music is the sound and collaborators the branded-content partners. null or empty = the platform does not publish it. Cost: 10 credits when the vendor has to fetch the media, 1 when it does not. The estimate is the higher one, so max_credits never surprises you. Cached 6 hours. Example: {"url": "https://www.tiktok.com/@gymshark/video/7517114944362499342"}
tiktok_get_videos
ChatGPTThe videos one TikTok account has posted, newest or most viewed first. Use when: "what has this creator posted", judging how often a brand posts, pulling a creator's recent work before a partnership. Not for: one video in full, use tiktok_get_video. What was said in it, use tiktok_get_transcript. Videos by topic rather than by account, use tiktok_search_videos. Returns: List. rows[]: videos with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. saves is how many people saved it; music is the sound and collaborators the branded-content partners. null or empty = the platform does not publish it. Cost: 1 credit per page. Cached 6 hours. Example: {"handle": "gymshark", "sort": "popular"}
tiktok_search_videos
ChatGPTTikTok videos matching a keyword, ranked by the platform's own search. Use when: "what is TikTok saying about X", finding creators in a category, watching a product or a brand name. Not for: one account's own videos, use tiktok_get_videos. A complete window of everything posted (TikTok search is ranked and never complete). Returns: List, ranked. rows[]: videos with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. saves is how many people saved it, music the sound, and author_followers sizes each creator without another call. null or empty = the platform does not publish it. Cost: 1 credit per page. Cached 6 hours. Example: {"query": "creatine gummies", "since": "month", "sort": "popular"}
youtube_get_channel
ChatGPTOne YouTube channel: subscribers, total views and when it joined. Use when: sizing a channel before a sponsorship, checking a handle, reading a channel description. Not for: its videos, use youtube_get_videos. Videos by topic, use youtube_search_videos. Returns: Record. The channel's handle, name, bio, verified, followers (the subscriber count), posts_count, views, links (the channel's links), website (the first link that is not a profile on another platform), email (where the channel publishes one) and topics (its keywords), with other profile fields where YouTube fills them. null or empty = the platform does not publish it. kind is channel. Cost: 1 credit. Cached 24 hours. Example: {"handle": "@ThePatMcAfeeShow"}
youtube_get_transcript
ChatGPTThe transcript of one YouTube video, as text. Use when: reading a video instead of watching it, pulling claims, chapters or quotes out of long content. Not for: the video's numbers, use youtube_get_video. The comments, use youtube_get_comments. Returns: Record. platform, url, language, text (the full transcript, uncut). NoData when the video has no captions. Cost: 1 credit. Cached 30 days. Example: {"url": "https://www.youtube.com/watch?v=5EWaxmWgQMI"}
youtube_get_video
ChatGPTOne YouTube video with its views, likes, comments and length. Use when: a row is worth the detail, or you have a URL and nothing else. Not for: what is said in it, use youtube_get_transcript. The comments, use youtube_get_comments. Returns: Record. rows[]: the one video, with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. links are the links in the description, sponsors' and affiliates' included; collaborators are co-creators. null or empty = the platform does not publish it. Cost: 1 credit. Cached 6 hours. Example: {"url": "https://www.youtube.com/watch?v=5EWaxmWgQMI"}
youtube_get_videos
ChatGPTThe videos on one YouTube channel, newest or most viewed first. Use when: "what does this channel publish", judging cadence and view counts before a sponsorship. Not for: one video in full, use youtube_get_video. What is said in it, use youtube_get_transcript. Returns: List. rows[]: videos with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. null or empty = the platform does not publish it. A listing carries views and length; likes and comments come with youtube_get_video. Cost: 1 credit per page. Cached 6 hours. Example: {"handle": "@ThePatMcAfeeShow", "sort": "popular"}
youtube_search_videos
ChatGPTYouTube videos matching a keyword, ranked by YouTube's own search. Use when: "what videos cover X", finding review and tutorial coverage of a product or a competitor. Not for: one channel's own videos, use youtube_get_videos. Text pages about X, use seo_get_serp. Returns: List, ranked. rows[]: videos with author and author_followers, created_at, text (cut at 2000 characters), likes, comments, shares, saves, views, media, duration_s, links, transcript and top_comments[]. null or empty = the platform does not publish it. created_at is approximate: the platform shows an age such as "3 weeks ago", so it is exact only to that unit. Cost: 1 credit per page. Cached 6 hours. Example: {"query": "best crm for agencies", "since": "year"}
