# Search Autocomplete: Google, YouTube, Bing & eBay Keywords (`fairfetch/search-autocomplete`) Actor Get keyword ideas from the search-box autocomplete of Google, YouTube, Bing and eBay. A-Z and question expansion, recursive long-tail discovery, many countries and languages, dedupe across engines. Clean JSON for SEO and content research. $0.20 per 1,000 suggestions. - **URL**: https://apify.com/fairfetch/search-autocomplete.md - **Developed by:** [Naveen Raja](https://apify.com/fairfetch) (community) - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.20 / 1,000 suggestions This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event ## What's an Apify Actor? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Search Autocomplete: Google, YouTube, Bing & eBay keyword suggestions Get the **autocomplete suggestions** of **Google, YouTube, Bing and eBay** in one run and one clean JSON format. Expand each seed keyword with **A-Z**, **question words** ("how", "what", "best", "vs", "near me" ...) or **your own modifiers**, and optionally go **recursive** to dig out long-tail keywords. Choose the **country and language** for every engine. **Price: $0.20 per 1,000 suggestions** ($0.0002 each). You pay only for suggestions saved to the dataset. Apify platform costs are included. | Example (cloud runs, 20 Oct 2026) | Suggestions | Cost | |---|---|---| | 1 seed, Google + YouTube + Bing, no expansion | 42 | about $0.01 | | 1 seed, Google + YouTube + Bing + eBay, A-Z expansion | 1,485 | about $0.30 | | Same, with "Across all engines" duplicate removal | about 1,120 | about $0.22 | ### What you get - One row per suggestion: engine, seed keyword, the exact query typed, the suggestion, its position in the list, recursion depth, country, language and time. - Four engines through their public suggestion endpoints. No browser, no login. For Google this is Google's suggestion service as Chrome's address bar uses it (up to 15 suggestions; the google.com search box shows 10 and may rank them differently). - **Keyword expansion:** seed + a...z and 0...9, question and comparison modifiers (localised for German, French, Spanish, Italian, Portuguese and Dutch), or a custom list such as "for kids", "best {seed} 2026". - **Recursive mode:** feed every suggestion back into the same engine (1 or 2 levels) for suggestions of suggestions, with a hard cap on requests. - **Duplicate removal** per engine (default) or across all engines, so you don't pay twice for the same keyword. - Only search phrases are kept: Google's website links (e.g. "https://www.facebook.com/") and instant answers (the calculator's "= 4" for "2+2") are left out and not charged. - A free `SUMMARY` record with counts per engine and **per seed** (what each seed returned, and why a seed returned nothing), and a clean stop when your spending limit is reached. ### Supported engines | Engine | Suggestions per query | Country / language | Good for | |---|---|---|---| | `google` | up to 15 | any country (`gl`) and language (`hl`) | SEO keyword research, content ideas | | `youtube` | about 14 | any country and language | YouTube SEO, video titles and topics | | `bing` | up to 25 | the country's Bing market (`mkt`, 34 countries) | SEO for Bing search | | `ebay` | up to 10 | us, ca, gb, au, at, be, fr, de, it, nl, es, ch, ie, pl | Marketplace and resale keywords | Countries without their own eBay site use the nearest one (New Zealand uses ebay.com.au) or ebay.com. Bing has markets for 34 countries; when it has no market for your language in that country (for example English in Germany) the country's own market is used (de-DE), and for countries without a Bing market Bing may answer with its default suggestions. The country and language each engine used are in every row, and anything that differs from your input is noted in the run summary. **Amazon and DuckDuckGo were removed on 20 Oct 2026**: the robots.txt files of their suggestion services disallow automated access. Inputs, saved tasks and schedules that still list `amazon` or `duckduckgo` keep working: those engines are skipped with a free notice row, and the other engines run as usual. ### Use cases - **Keyword research and SEO:** collect hundreds of real long-tail queries for a topic in seconds and feed them into your keyword tool. - **YouTube SEO:** find what viewers type after your topic ("standing desk hack", "standing desk health") for titles, tags and video ideas. - **eBay listings:** see the product searches shoppers start (sizes, colors, "with storage") for listing titles. - **Content ideas and FAQs:** the questions mode surfaces "how", "why", "what", "best" and "vs" queries to plan articles and FAQ sections. - **Market and trend checks:** compare what people search for in different countries and languages, or on different engines. ### How to use 1. Enter one or more **Seed keywords**. 2. Pick the **Engines** (Google, YouTube and Bing are selected by default). 3. Set **Country** (two-letter code) and, optionally, **Language** (empty = the country's main language). 4. Choose a **Keyword expansion**: none, alphabet, questions or custom. 5. Optional: **Recursive depth** 1 or 2, **Remove duplicates** mode, and limits (**Max suggestions in total**, **Max requests**). 6. Run the Actor and download the results as JSON, CSV, Excel or via API. Per-engine and per-seed counts are in the `SUMMARY` record of the run's key-value store. #### Input example The input of one of our cloud test runs: ```json { "seeds": ["standing desk"], "engines": ["google", "youtube", "bing", "ebay"], "country": "us", "expansion": "alphabet", "maxSuggestionsTotal": 0 } ``` It sent 148 queries (37 per engine) and saved 1,485 suggestions in 20 seconds: Google 535, Bing 467, YouTube 392, eBay 91 (1,116 unique across all engines). #### Output example Rows from that run: ```json [ { "engine": "google", "seed": "standing desk", "querySent": "standing desk f", "modifier": "f", "suggestion": "standing desk for home office", "position": 2, "depth": 0, "country": "us", "language": "en", "scrapedAt": "2026-10-20T00:12:02Z" }, { "engine": "youtube", "seed": "standing desk", "querySent": "standing desk h", "modifier": "h", "suggestion": "standing desk hack", "position": 1, "depth": 0, "country": "us", "language": "en", "scrapedAt": "2026-10-20T00:12:02Z" }, { "engine": "bing", "seed": "standing desk", "querySent": "standing desk c", "modifier": "c", "suggestion": "standing desk converter 2 monitors", "position": 4, "depth": 0, "country": "us", "language": "en", "scrapedAt": "2026-10-20T00:12:00Z" }, { "engine": "ebay", "seed": "standing desk", "querySent": "standing desk w", "modifier": "w", "suggestion": "standing desk with storage", "position": 2, "depth": 0, "country": "us", "language": "en", "scrapedAt": "2026-10-20T00:12:03Z" } ] ``` #### Output fields | Field | Description | |---|---| | `engine` | `google`, `youtube`, `bing` or `ebay` | | `seed` | The input keyword this suggestion belongs to | | `querySent` | The exact text typed into the search box: the seed, seed + modifier, or a suggestion (recursive mode) | | `modifier` | Expansion modifier for this query (`"a"`, `"how"`, `"vs"`, your custom text), `null` for the plain seed and recursive queries | | `suggestion` | The autocomplete suggestion as the engine returned it | | `position` | 1-based position in the engine's list | | `depth` | `0` for the seed and its expansions, `1` or `2` for suggestions of suggestions | | `country`, `language` | Country and language the engine actually used | | `scrapedAt` | ISO 8601 time (UTC) when the suggestion was fetched | The dataset has four views: **Suggestions**, **Keyword list** (suggestion + engine, easy to copy), **All fields** and **Notices (free)**. #### Notice rows (free) When something in your input can't be fetched, the dataset gets a **free notice row** instead of failing the run: `suggestion` is `null`, `errorKind` says what happened and `error` explains it. To keep only suggestions, filter out rows that have an `errorKind`. | `errorKind` | When | |---|---| | `invalid_input` | A run-wide setting is invalid (for example expansion "custom" without modifiers, or a bad country code). Nothing is fetched. | | `invalid_seed` | The seed has no letter or digit (e.g. `???`). Engines answer such input with unrelated trending searches, so it is not sent. | | `seed_too_long` | The seed is longer than the engine accepts (Google and YouTube: 100 characters). It is not sent to that engine; the other engines still get it. | | `rejected_by_engine` | The engine refused the seed (HTTP 400). Other seeds are not affected. | | `engine_removed` | The input lists `amazon` or `duckduckgo`, which were removed from this Actor. | | `unknown_engine` | The input lists an engine name this Actor doesn't know (API input). | | `proxy_failed` | Every request through your own proxy URLs failed: the proxy can't be reached or answered with an error (wrong host, port or credentials). | ### Expansion, recursion and duplicates - **None:** each seed is typed as is. Fast and cheap: about 40 suggestions per seed on the three default engines. - **Alphabet:** the seed, then seed + a, b, ... z and 0 ... 9 (37 queries per seed and engine). One seed on all four engines returned 1,485 suggestions in our cloud test. - **Questions:** the seed plus question words (how, what, why, which, who, where, when, can, is, does, should ...), "best", "top", "cheap" and comparisons and prepositions (vs, versus, or, and, for, with, without, near me, to, like, under, alternative). About 29 queries per seed and engine. German, French, Spanish, Italian, Portuguese and Dutch get their own question words; other languages use the English set. - **Custom:** the seed plus each of your modifiers. A modifier is appended (`for kids` gives "coffee maker for kids"); put `{seed}` where the keyword should go to prepend or wrap (`best {seed} 2026`). Custom modifiers are ignored with the other expansions (the summary says so). - **Long seeds:** Google and YouTube refuse queries over 100 characters, so longer seeds, and expanded or recursive queries that get too long, are skipped for those two engines and counted in the summary. Bing and eBay accept up to 200 characters. - **Recursive depth 1 or 2:** every new suggestion is typed back into the same engine. Each level multiplies requests by about 10, so **Max requests** (default 2,000, maximum 20,000) caps the run: the run never sends more, recursion included. The cap is shared fairly between engines; an engine that needs less than its share leaves the rest to the others. - **Duplicates:** with **Per engine** (default) a suggestion appears once per engine even if several queries return it. **Across all engines** keeps only the first engine's row. **Off** keeps every row. The engine echoing your exact query back (for example "standing desk" for the query "standing desk") is never saved. ### Pricing Pay per event, no subscription and no extra usage fees: | Event | Price | |---|---| | `suggestion`: one suggestion row in the dataset | **$0.0002** ($0.20 per 1,000) | | Actor start (standard Apify event, per run) | $0.00005 | Good to know: - **Max suggestions in total** (default 5,000) and the run's **Maximum cost per run** (or `maxTotalChargeUsd` via API) both cap spending. The Actor stops cleanly when a limit is reached, and everything saved up to then stays in the dataset. - Free: duplicates, echoes of your query, website links and instant answers, failed or skipped queries, notice rows and the `SUMMARY` record. - If Apify moves a run to another server mid-run, the run continues where it stopped: suggestions already saved are never saved or charged again. The same holds if you abort a run and then resurrect it: everything saved before the abort stays, and the status message and `SUMMARY` say how much that was. ### Use it from the API Run synchronously and get the suggestions in one call (keep your own API token in the `APIFY_TOKEN` environment variable): ```bash curl -X POST "https://api.apify.com/v2/acts/fairfetch~search-autocomplete/run-sync-get-dataset-items?maxTotalChargeUsd=1" \ -H "Authorization: Bearer $APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"seeds": ["standing desk"], "engines": ["google", "youtube"], "expansion": "questions"}' ``` The items can include free notice rows (for example for a seed that is too long, or an input that still lists `amazon`). They have `suggestion: null` and an `errorKind`: keep only the rows without an `errorKind` if you just want the keywords. ### Performance and limits - In the cloud, one seed with alphabet expansion on all four engines (148 queries) finished in 20 seconds using about 60 MB of memory. - Requests are polite: at most 2 at a time per engine (configurable 1 to 5), requests to one host are spaced out, and HTTP 429 / 403 / 5xx responses are retried with exponential backoff (honouring Retry-After). Google and YouTube share one host, so they are paced together. - If an engine fails 3 queries in a row (for example because it is rate-limiting), that engine stops for the rest of the run, the other engines continue, and the run summary explains what happened. Queries an engine refuses (HTTP 400) don't count towards this. - A run fails only if every engine that sent queries failed with blocks or errors, or refused every query it was sent (which points to a change on the engine's side), and nothing was saved. Problems caused by the input (a bad setting, a too-long seed, a removed engine, a mistyped proxy URL) end the run successfully with free notice rows. - At most 20,000 seeds per run (a run sends at most 20,000 requests). - Each engine decides how many suggestions it shows (see the table above); some queries return fewer or none. ### FAQ **Are these search volumes?** No. Autocomplete shows what people commonly search for, ranked by each engine, but no numbers. Use the suggestions as keyword ideas and check volumes in a keyword-volume tool if you need them. **Why do I see different suggestions in my browser?** Suggestions depend on location, language, trends and sometimes your own history. The Actor asks each engine for the country and language you choose, but engines also look at the IP address the request comes from, so local suggestions (for example "near me" places) reflect the server's location. Results also change over time. **Do I need proxies?** Usually not; the Actor keeps request rates low. If the run summary shows an engine stopped with HTTP 429 or 403, enable **Proxy configuration** with Apify Proxy (the datacenter proxy is usually enough) or lower **Parallel requests per engine**. With a proxy, every request opens a new proxy connection, so a rotating proxy can use a different IP address each time. **Which countries and languages are supported?** Google and YouTube accept any two-letter country and language code. Bing has markets for 34 countries and eBay sites for 14; other countries use the nearest site or the default, and the summary notes it. **Does it work for non-English keywords?** Yes, for example "kaffeemaschine" with country `de` or "γ‚³γƒΌγƒ’γƒΌ" with country `jp`. Alphabet expansion adds Latin letters and digits; for other scripts use the custom modifiers. **What does "position" mean when some numbers are missing?** It is the position in the engine's own list. Skipped entries (duplicates, the echo of your query, website links) keep the remaining positions unchanged. **Why did a seed return nothing?** `SUMMARY.perSeed` lists every seed with its status (`ok`, `partial`, `no_suggestions`, `failed`, `skipped`, `invalid`), the suggestions per engine and the reason: too long for an engine, refused by the engine, the request cap, an engine that stopped after errors, or all of its suggestions already saved for an earlier seed. The status message names seeds that returned nothing. **Can I schedule it?** Yes. Schedule a run in Apify Console to track how suggestions for your keywords change over time. ### Legal This Actor reads the public autocomplete suggestions these services show to anyone typing a search, through public suggestion endpoints used by browsers and the sites' search boxes (for Google, the one Chrome's address bar uses; for Bing, the OpenSearch endpoint browsers use). It does not log in, solve CAPTCHAs or bypass access controls, and it keeps its request rate low. Be aware that the services' terms restrict automated access and reuse: - **Google and YouTube** (suggestqueries.google.com, which has no robots.txt): Google's Terms of Service prohibit automated access that ignores a site's machine-readable instructions such as robots.txt, and YouTube's Terms of Service prohibit automated access without YouTube's prior written permission (except for public search engines). - **Bing** (api.bing.com, whose robots.txt does not load): the Microsoft Services Agreement says the text and other material available on Bing and MSN is for noncommercial, personal use only, and that using it to build your own products is allowed only as far as Microsoft or the rights holders specifically authorize (section 14.f.i, "Bing and MSN Materials"). It also prohibits circumventing restrictions on access to its services, including "impermissible scraping" (section 3.a.vi). - **eBay** (autosug.ebaystatic.com; its robots.txt allows the suggestion path for general user agents): eBay's User Agreement prohibits robots, scrapers and other automated means without eBay's prior permission. Amazon and DuckDuckGo were removed because their robots.txt files disallow automated access to their suggestion services. Suggestions are generated by the engines from what many people search for. They can include names of public figures (for example celebrities in trending searches) and, rarely, other text you should handle with care. The Actor does not collect any other personal data. You are responsible for how you use the data and for complying with the terms of these services and the laws that apply to you. Not affiliated with or endorsed by Google, YouTube, Microsoft/Bing, eBay, Amazon or DuckDuckGo. Names are trademarks of their owners and are used only to describe the data sources. # Actor input Schema ## `seeds` (type: `array`): One keyword or phrase per line, e.g. "coffee maker". Each seed is typed into every selected engine's search box (plus the expanded variants if you choose an expansion below). Google and YouTube accept at most 100 characters per query; longer seeds are skipped there with a free notice row. Seeds without any letter or digit (e.g. "???") are skipped. ## `engines` (type: `array`): Which search boxes to read. Google: up to 15 suggestions per query. YouTube: about 14. Bing: up to 25. eBay: up to 10 (marketplace searches). Amazon and DuckDuckGo were removed on 20 Oct 2026: they are still accepted so saved inputs keep working, but they are skipped with a free notice row and cost nothing. ## `country` (type: `string`): Two-letter country code, e.g. us, gb, de, fr, in, jp, br. Google and YouTube accept any country. Bing uses the country's market (34 countries; for others Bing may answer with its default suggestions). eBay has sites for us, ca, gb, au, at, be, fr, de, it, nl, es, ch, ie, pl (others use ebay.com). The country and language each engine used are in every result row and in the run summary. ## `language` (type: `string`): Language code such as en, de, es, pt-BR, es-419 or zh-TW. Leave empty to use the country's main language. eBay always answers in its site's language; Bing uses the country's market language when it has no market for your language. ## `expansion` (type: `string`): Type more than just the seed to discover long-tail keywords. Alphabet: the seed, then seed + a ... z and 0 ... 9 (37 queries per seed and engine). Questions: the seed plus question words and comparisons such as how, what, why, best, vs, for, with, near me (about 29 queries; localised for de, fr, es, it, pt, nl). Custom: the seed plus your own modifiers below. ## `customModifiers` (type: `array`): Used with "Custom modifiers" expansion (ignored with the other expansions). Each modifier is added after the seed ("for kids" gives "coffee maker for kids"). Use {seed} to place the seed elsewhere: "best {seed} 2026". ## `recursionDepth` (type: `integer`): 0 = off. 1 = also type every suggestion back into the same engine to get suggestions of suggestions. 2 = one more level. Grows fast (about 10x requests per level); Max requests below caps it. ## `dedupe` (type: `string`): Per engine (default): each suggestion once per engine, even if several queries return it. Across engines: each suggestion once in the whole run (the first engine to return it is kept). Off: every row, including repeats. You are only charged for rows in the dataset. ## `maxSuggestionsTotal` (type: `integer`): Stop after this many suggestions have been saved (each one is a charged result). 0 = no limit (your run's maximum charge still applies). ## `maxRequests` (type: `integer`): Upper limit on autocomplete requests in this run, recursion included; the run never sends more. Shared fairly between engines (an engine that needs less leaves the rest to the others). Queries beyond the cap are skipped and counted per seed in the run summary. ## `proxyConfiguration` (type: `object`): Usually not needed. If an engine starts rate-limiting (the run summary then reports HTTP 429/403 for it), enable Apify Proxy (the datacenter proxy is enough in most cases). With a proxy, every request opens a new proxy connection, so a rotating proxy can use a different IP address each time. ## `maxConcurrencyPerEngine` (type: `integer`): How many requests run at the same time for each engine. Kept low on purpose to stay polite; requests to one host are also spaced out. ## `requestTimeoutSecs` (type: `integer`): Timeout for a single request. ## `maxRetries` (type: `integer`): Retries for network errors, HTTP 429 / 403 and 5xx responses, with exponential backoff (honours Retry-After). An engine that fails 3 queries in a row is stopped for the rest of the run; other engines continue. Queries an engine refuses (HTTP 400, e.g. too long) are not retried and don't stop the engine. ## Actor input object example ```json { "seeds": [ "coffee maker", "standing desk", "how to learn python" ], "engines": [ "google", "youtube", "bing" ], "country": "us", "expansion": "none", "customModifiers": [ "for office", "best {seed}", "{seed} under 100" ], "recursionDepth": 0, "dedupe": "perEngine", "maxSuggestionsTotal": 5000, "maxRequests": 2000, "proxyConfiguration": { "useApifyProxy": false }, "maxConcurrencyPerEngine": 2, "requestTimeoutSecs": 20, "maxRetries": 3 } ``` # Actor output Schema ## `suggestions` (type: `string`): All suggestions from this run as JSON. ## `summary` (type: `string`): Per-engine and per-seed counts (queries sent, failed, refused or skipped and why, suggestions saved, duplicates), the site and market used, and any errors. # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "seeds": [ "coffee maker" ], "engines": [ "google", "youtube", "bing" ], "country": "us", "expansion": "none" }; // Run the Actor and wait for it to finish const run = await client.actor("fairfetch/search-autocomplete").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "seeds": ["coffee maker"], "engines": [ "google", "youtube", "bing", ], "country": "us", "expansion": "none", } # Run the Actor and wait for it to finish run = client.actor("fairfetch/search-autocomplete").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print(f"πŸ’Ύ Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}") for item in client.dataset(run.default_dataset_id).iterate_items(): print(item) # πŸ“š Want to learn more πŸ“–? Go to β†’ https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "seeds": [ "coffee maker" ], "engines": [ "google", "youtube", "bing" ], "country": "us", "expansion": "none" }' | apify call fairfetch/search-autocomplete --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,fairfetch/search-autocomplete" } } } ``` The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer ` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations). ## OpenAPI specification Download the OpenAPI definition: https://api.apify.com/v2/actors/4trv3AiLq1oAE3f36/builds/Lob2G5fLB9GaEVdns/openapi.json