# Keyword Ideas: Google, YouTube, Bing & Amazon Autocomplete (`mitp1997/keyword-ideas-autocomplete`) Actor Keyword research tool: thousands of long-tail keyword ideas and question keywords from Google, YouTube, Bing and Amazon autocomplete in one run. A–Z, questions, best/vs, prepositions, depth, any country/language, cross-engine dedupe and intent tags. No browser, 256 MB. - **URL**: https://apify.com/mitp1997/keyword-ideas-autocomplete.md - **Developed by:** [Mit Parekh](https://apify.com/mitp1997) (community) - **Categories:** SEO tools, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $1.00 / 1,000 keyword ideas 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 ## Keyword Ideas: Google, YouTube, Bing & Amazon Autocomplete **Keyword Ideas** is a keyword research tool that collects **long-tail keyword ideas and question keywords** from the autocomplete of **Google, YouTube, Bing and Amazon** in a single run. Give it one or more seed keywords. It expands each one with **A–Z letters, question words, commercial modifiers (best, top, vs, review, price…), prepositions and your own prefixes or suffixes**, merges the suggestions across engines, and tags every keyword with **where it was found, the seed, the modifier and its search intent**. - 🔎 **4 sources in one run.** You get one clean table instead of four separate tools, and you can see which keywords appear on Google *and* Amazon *and* YouTube. - ❓ **Question keywords** (how, what, why, can, is…) for FAQ sections, People-Also-Ask style content and video ideas. - 🌍 **Any country and language**, plus Amazon suggestions from 22 Amazon marketplaces, including **amazon.in**, amazon.co.uk, amazon.de and amazon.co.jp. - 🪶 **No browser and no API key.** It runs on 256 MB of memory. In local tests, one seed on all 4 engines returned **1,517 unique keywords from 196 requests in about 10 seconds**. - 💸 **Errors are free.** If an engine fails, you get a free error record instead of a failed run. - 📈 **Built-in hand-off to Google Trends.** The best keywords are saved as a ready-made input for [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable), so you can check which ideas are actually growing. ### What keyword data does it return? Each dataset item is one unique keyword: | Field | Example | Meaning | |---|---|---| | `keyword` | `how to clean a coffee maker with vinegar` | The autocomplete suggestion | | `engines` | `["google", "youtube", "bing"]` | Where it was suggested (merged across engines) | | `engineCount` | `3` | Number of engines that suggested it (a strong demand signal) | | `seed` | `coffee maker` | Your seed keyword | | `modifier` / `modifierType` | `how` / `question` | What was typed to find it: `seed`, `alphabet`, `number`, `question`, `commercial`, `preposition`, `custom` or `depth` | | `query` | `how coffee maker` | The exact text typed into the search box | | `position` / `positions` | `1` / `{"google": 1, "bing": 3}` | The best position, and the position per engine | | `googleRelevance` | `1250` | Google's own suggestion relevance score (when available) | | `intent` | `question` | `question`, `commercial`, `navigational` or `informational` | | `intentSignals` | `["how"]` | The words that decided the intent, so you can re-classify with your own rules | | `isQuestion`, `wordCount`, `containsSeed` | `true`, `8`, `true` | Handy filters for long-tail and FAQ keywords | | `depth`, `parentKeyword` | `2`, `coffee maker cleaner` | For "suggestions of suggestions" (depth 2–3) | | `country`, `language`, `amazonMarketplace` | `IN`, `en`, `amazon.in` | The locale that was used | The key-value store also has: - **`RUN_SUMMARY`**: keywords per engine and per intent, keywords **unique to each engine**, requests, failures, stop reason and per-engine HTTP statistics. - **`TRENDS_INPUT`**: the top 5 keywords per seed, formatted as an input for the [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable). ### How to find keyword ideas from autocomplete 1. Click **Try for free** (or **Start**). 2. Enter one or more **seed keywords**, one per line, e.g. `coffee maker`. 3. Choose the **sources** (Google, YouTube, Bing, Amazon), the **country** and the **language**. 4. Pick the expansions: **A–Z**, **questions**, **commercial (best/top/vs/review/price)**, **prepositions (for/with/near…)**, **numbers**, or your own prefixes and suffixes. 5. Optionally set **Depth** to 2 or 3 to also expand the strongest new keywords. 6. Click **Start**, then export to **CSV, Excel, JSON or Google Sheets**, or read the results through the API. The prefilled example (`coffee maker`, capped at 300 keywords) finishes in well under a minute. ### Why use this keyword tool? - **Cross-engine demand signal.** A keyword that Google, YouTube *and* Amazon all suggest is a stronger bet than one found on Google alone. `engineCount` and `RUN_SUMMARY.uniqueToEngine` show you both the overlap and the hidden gems that only one engine suggests. - **YouTube keyword research and Amazon keyword research** in the same table as Google SEO keywords. That is useful for creators, Amazon sellers (listing titles, backend search terms, PPC) and content marketers. - **Intent tags out of the box.** Filter `intent = question` for blog FAQs, or `intent = commercial` for buyer keywords and affiliate content. - **Polite and reliable.** It paces requests per engine (with jitter), retries with exponential backoff, honours `Retry-After`, and detects blocks (429/403/captcha pages). If an engine starts blocking, that engine switches to Apify Proxy automatically. If an engine keeps failing, it is skipped, and the run still returns everything else. - **Spending cap.** Set **Max keywords in total** or **Maximum cost per run**, and the Actor stops cleanly at the limit. ### Popular use cases - **SEO content planning:** turn one topic into hundreds of long-tail keywords and question keywords, then group them into articles. - **YouTube video ideas:** see what people actually type into the YouTube search box (`engines` contains `youtube`). - **Amazon product research and listing optimisation:** find the real search terms on amazon.com, amazon.in, amazon.de and 19 more marketplaces. - **PPC keyword lists:** use the commercial modifiers (best, cheap, price, review, vs, alternative) to find buyer-intent terms. - **Local and multilingual SEO:** any country and language, e.g. Germany/`de` or India/`hi`, plus custom prefixes such as `kaise` or `near me`. - **Validate with Google Trends:** send the best ideas to [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable) (see below). ### Input examples One seed on all engines (the default): ```json { "keywords": ["coffee maker"] } ``` India, several seeds, prepositions on, depth 2: ```json { "keywords": ["masala chai", "air fryer"], "country": "IN", "language": "en", "expandPrepositions": true, "depth": 2, "depthKeywordsLimit": 10 } ``` YouTube and Google questions only, long-tail filter: ```json { "keywords": ["home workout"], "engines": ["google", "youtube"], "expandAlphabet": false, "expandCommercial": false, "minWordCount": 4 } ``` German Amazon keywords with custom suffixes: ```json { "keywords": ["kaffeemaschine"], "engines": ["amazon"], "country": "DE", "language": "de", "customSuffixes": ["mit mahlwerk", "für 1 person"] } ``` ### How many keywords and requests per run? Each seed is queried once per modifier per engine. With the defaults (A–Z + 14 question words + 8 commercial modifiers, 4 engines), that is **49 queries × 4 engines = 196 requests per seed**. In our local tests, that returned: | Test | Requests | Unique keywords | Time | |---|---|---|---| | `coffee maker`, US/en, all 4 engines, defaults | 196 | 1,517 (Google 669, YouTube 490, Bing 524, Amazon 394; 347 on 2+ engines) | ~10 s | | `kaffeemaschine`, DE/de, A–Z + custom prefixes | 120 | 906 | ~5 s | | 2 seeds, IN/en, prepositions + depth 2 | 520 | 800 (capped at 400 per seed) | ~20 s | Real numbers vary by keyword and country. See [Cost](#cost) for runs on the Apify platform. ### Send keyword ideas to Google Trends Autocomplete tells you *what* people search for. Google Trends tells you *whether it is growing* and *where*. When **Prepare input for Google Trends** is on (the default), the run saves a `TRENDS_INPUT` record like this: ```json { "searchTerms": ["coffee maker review", "coffee maker machine", "coffee maker with grinder", "coffee maker no plastic", "coffee maker cleaner"], "geo": "US", "timeRange": "today 12-m" } ``` Paste it into [Google Trends Scraper & API](https://apify.com/mitp1997/google-trends-scraper-reliable) to get interest over time, interest by region or city, and related rising queries. You can also chain the two Actors automatically: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("mitp1997/keyword-ideas-autocomplete").call(run_input={"keywords": ["coffee maker"], "maxItems": 500}) trends_input = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("TRENDS_INPUT")["value"] trends = client.actor("mitp1997/google-trends-scraper-reliable").call(run_input={ "searchTerms": trends_input["searchTerms"], "geo": trends_input["geo"], "timeRange": trends_input["timeRange"]}) ``` ### Use it as a keyword API **Python** ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("mitp1997/keyword-ideas-autocomplete").call(run_input={ "keywords": ["coffee maker", "espresso machine"], "engines": ["google", "amazon"], "country": "US", }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): if item["status"] == "ok": print(item["keyword"], item["engines"], item["intent"]) ``` **JavaScript** ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('mitp1997/keyword-ideas-autocomplete').call({ keywords: ['coffee maker'], country: 'GB' }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items.filter((i) => i.intent === 'question').map((i) => i.keyword)); ``` **curl (run and get the items in one call)** ```bash curl -X POST "https://api.apify.com/v2/acts/mitp1997~keyword-ideas-autocomplete/run-sync-get-dataset-items?token=" \ -H 'Content-Type: application/json' \ -d '{"keywords": ["coffee maker"], "maxItems": 200}' ``` It also works in **n8n, Make and Zapier** (Apify app: "Run Actor" and "Get dataset items"), and with AI agents through the **Apify MCP server**. ### Cost **Price: $1 per 1,000 keywords** (pay per event, `keyword-result` = $0.001). Apify platform usage is included in that price, error records are free, and you can cap the spend with **Max keywords in total** or **Maximum cost per run**. The Actor is light: no browser, 256 MB of memory, and small JSON responses (about 260 KB of traffic per seed on all 4 engines). For reference, the platform usage we measured on 23 Oct 2026 (256 MB, no proxy; you don't pay this separately): | Run | Keywords | Run time | Platform usage | Usage per 1,000 keywords | |---|---|---|---|---| | Prefill: `coffee maker`, US, capped at 300 | 300 | 10 s | $0.0018 | $0.006 | | 2 German seeds, DE/de, all defaults | 2,253 | 43 s | $0.0121 | $0.005 | | 2 seeds, IN, prepositions + depth 2 | 800 | 56 s | $0.0050 | $0.006 | Most of that usage is dataset writes, not compute. Error records (`status: "error"`) are never counted as results. ### Errors and blocking - Each engine has its own pacing, retries and block detection. Failed requests never stop the run. - **No proxy is used by default**, because these autocomplete endpoints answer plain HTTP requests. If an engine returns 3 blocked responses in a row, *that engine only* switches to Apify Proxy (datacenter first, then residential if your plan has it). You can turn this off, or force a proxy for all requests, under **Advanced**. - If an engine still fails, you get one free error item per seed and engine: `{"status": "error", "seed": "...", "engines": ["amazon"], "error": "...", "failedRequests": 15, "totalRequests": 49}`. - If *nothing* could be collected, the run is marked as failed, so schedules and monitoring notice. You can turn this off with **Fail the run if nothing was found**. ### FAQ **Is this the same as Google Keyword Planner?** No. Autocomplete shows what real users type, but it **does not give search volume**. Use it to discover ideas, then check volume in Keyword Planner, or check trends with the [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable). **How is intent detected?** With transparent word rules (English-oriented): question words → `question`; best/cheap/price/review/vs/buy/near me… → `commercial`; login/app/official/.com… → `navigational`; everything else → `informational`. The matched words are in `intentSignals`. **Which Amazon marketplaces are supported?** US, CA, MX, BR, GB, IE, DE, FR, IT, ES, NL, BE, SE, PL, TR, AE, SA, EG, IN, JP, AU and SG. For other countries, Amazon suggestions come from amazon.com, and the log says so. **Can I get keywords in Hindi, German, Spanish…?** Yes. Set **Language** (`hi`, `de`, `es`…) and **Country**. Use **Custom prefixes/suffixes** for language-specific modifiers, because the built-in question and commercial words are English. **Why do Google and Bing sometimes suggest keywords without my seed?** They correct spelling and suggest related brands. Turn on **Only keywords containing the seed** to drop them. **Does it need a proxy or an API key?** No. Proxy is optional and is only used automatically if an engine blocks. ### Limitations - Autocomplete has no search volumes or CPC data. - Suggestions are personalised and change over time. Results come from a neutral, logged-out session in the selected country and language. They are not tied to a specific city. - Amazon suggestions come from the marketplace that matches the country, in that marketplace's default language. - Intent tags are heuristic and mostly English. ### Support Found a bug or need another source (e.g. Pinterest, DuckDuckGo, eBay)? Open an issue on the **Issues** tab. ### More data Actors - [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable): interest over time, by region, related queries and trending searches. - [Google Ads Transparency Scraper](https://apify.com/mitp1997/google-ads-transparency-scraper): every ad a competitor runs on Google Search, Display and YouTube, with ad text, images, videos, dates and regions. - [Google Jobs Scraper](https://apify.com/mitp1997/google-jobs-scraper): job listings with salaries and direct apply links. - [Telegram Channel Scraper](https://apify.com/mitp1997/telegram-channel-scraper): posts, views, reactions, media and exact subscriber counts from public Telegram channels, no login. # Actor input Schema ## `keywords` (type: `array`): One seed keyword per line, e.g. coffee maker. Each seed is expanded with the modifiers below and sent to every selected engine. Duplicate seeds are ignored. ## `engines` (type: `array`): Where to collect suggestions. Google = Google Search autocomplete, YouTube = YouTube search autocomplete, Bing = Bing autosuggest, Amazon = Amazon search box suggestions for the marketplace of the selected country. ## `country` (type: `string`): Country for localised suggestions (Google gl, Bing market, Amazon marketplace). Amazon has 22 marketplaces; for other countries Amazon suggestions come from amazon.com. ## `language` (type: `string`): Interface language code for Google, YouTube and Bing, e.g. en, de, hi, es, pt-BR. Amazon uses the marketplace's language. ## `expandAlphabet` (type: `boolean`): Query seed a … seed z on every engine. Gives the most long-tail keywords (26 extra queries per seed per engine). ## `expandQuestions` (type: `boolean`): Query how seed, what seed, why seed, can seed, is seed and more (14 question words). Great for FAQ sections, People-Also-Ask style content and YouTube video ideas. ## `expandCommercial` (type: `boolean`): Query best seed, top seed, cheap seed, seed vs, seed or, seed alternative, seed review and seed price. ## `expandPrepositions` (type: `boolean`): Query seed for, seed with, seed without, seed near, seed to, seed like, seed from, seed in, seed on, seed and, seed under. ## `expandNumbers` (type: `boolean`): Query seed 0 … seed 9 (finds years, sizes, model numbers). ## `customPrefixes` (type: `array`): Your own words to put before each seed, e.g. kaise, diy, buy. ## `customSuffixes` (type: `array`): Your own words to put after each seed, e.g. near me, for beginners, 2026. ## `depth` (type: `integer`): 1 = seed + modifiers only. 2 or 3 = also re-query the strongest new keywords (suggestions of suggestions) for deeper long-tail. Each extra level adds up to Keywords per depth level × engines requests per seed. ## `depthKeywordsLimit` (type: `integer`): How many of the best new keywords (found by most engines, highest position) are re-queried at each extra depth level, per seed. ## `dedupeAcrossEngines` (type: `boolean`): On: one row per unique keyword with an engines list (e.g. found on Google + Amazon). Off: one row per keyword per engine. ## `onlyKeywordsContainingSeed` (type: `boolean`): Drop suggestions that do not contain every word of the seed (Google and Bing sometimes suggest spelling variants or related brands). ## `excludeWords` (type: `array`): Drop keywords that contain any of these whole words, e.g. brand names or free. ## `minWordCount` (type: `integer`): E.g. 3 keeps only long-tail keywords with 3+ words. 0 = no filter. ## `maxKeywordsPerSeed` (type: `integer`): Keep at most this many keywords per seed (highest-priority first: seed suggestions, questions, commercial, prepositions, A–Z). 0 = no limit. ## `maxItems` (type: `integer`): Stop after this many keywords across all seeds (caps the cost). 0 = no limit. A single seed with the default expansions returned about 900–1,500 keywords on all 4 engines in our tests. ## `exportForGoogleTrends` (type: `boolean`): Save the top 5 keywords per seed as a ready-to-use input for Google Trends Scraper in the TRENDS_INPUT key-value store record, so you can check which ideas are growing. ## `proxyConfiguration` (type: `object`): Not needed normally: the autocomplete endpoints work without a proxy. If an engine starts blocking, the Actor switches that engine to Apify Proxy automatically (see below). ## `fallbackToProxy` (type: `boolean`): If an engine returns 3 blocked responses in a row (HTTP 429/403/captcha), its remaining requests go through Apify Proxy (datacenter, then residential if available on your plan). ## `maxConcurrency` (type: `integer`): Requests in flight per engine. Requests are also paced (~1 every 150 ms per engine) to stay polite. ## `maxRequestRetries` (type: `integer`): Retries with exponential backoff for rate limits, server errors and timeouts. ## `requestTimeoutSecs` (type: `integer`): Timeout of a single HTTP request. ## `failIfNoResults` (type: `boolean`): Mark the run as failed when 0 keywords were saved because requests failed (useful for monitoring and schedules). ## Actor input object example ```json { "keywords": [ "coffee maker" ], "engines": [ "google", "youtube", "bing", "amazon" ], "country": "US", "language": "en", "expandAlphabet": true, "expandQuestions": true, "expandCommercial": true, "expandPrepositions": false, "expandNumbers": false, "depth": 1, "depthKeywordsLimit": 10, "dedupeAcrossEngines": true, "onlyKeywordsContainingSeed": false, "minWordCount": 0, "maxKeywordsPerSeed": 0, "maxItems": 300, "exportForGoogleTrends": true, "proxyConfiguration": { "useApifyProxy": false }, "fallbackToProxy": true, "maxConcurrency": 3, "maxRequestRetries": 4, "requestTimeoutSecs": 20, "failIfNoResults": true } ``` # Actor output Schema ## `overview` (type: `string`): All keywords with engines, seed, modifier, intent and word count (Overview view). ## `details` (type: `string`): Positions per engine, Google relevance, depth/parent keyword, matched intent signals and marketplace. ## `errors` (type: `string`): Free error records: one per seed and engine whose requests failed. ## `runSummary` (type: `string`): JSON summary: keywords per engine and intent, keywords unique to each engine, requests, failures, stop reason and per-engine HTTP statistics. ## `trendsInput` (type: `string`): Top keywords per seed as an input for the Google Trends Scraper Actor (mitp1997/google-trends-scraper-reliable). # 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 = { "keywords": [ "coffee maker" ], "maxItems": 300, "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("mitp1997/keyword-ideas-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 = { "keywords": ["coffee maker"], "maxItems": 300, "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("mitp1997/keyword-ideas-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 '{ "keywords": [ "coffee maker" ], "maxItems": 300, "proxyConfiguration": { "useApifyProxy": false } }' | apify call mitp1997/keyword-ideas-autocomplete --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,mitp1997/keyword-ideas-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/gtmd7niDFXq1zJdJ4/builds/U3SIMeq2toReSVvEa/openapi.json