# Google, YouTube & Amazon Autocomplete Scraper - Keyword Ideas (`vaquilla/keyword-autocomplete-explorer`) Actor

Scrape autocomplete suggestions from Google, YouTube, Amazon, Bing, DuckDuckGo, eBay and the App Store in one run. Get hundreds of long-tail keywords per seed, each tagged with search intent. No API keys, no login.

- **URL**: https://apify.com/vaquilla/keyword-autocomplete-explorer.md
- **Developed by:** [Hugo Da Silva](https://apify.com/vaquilla) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 keyword 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

## Google, YouTube & Amazon Autocomplete Scraper

A Google autocomplete scraper, YouTube autocomplete scraper and Amazon autocomplete scraper in one Actor. It turns a few seed keywords into hundreds of real search suggestions from **Google, YouTube, Bing, DuckDuckGo, Amazon, eBay and the Apple App Store** in a single run. Every keyword is tagged with its search intent, so you can filter the list instead of reading it.

No API keys, no login, no browser. A typical run returns 1,000+ keywords in under 15 seconds.

### What you can do with it

- **SEO and content planning:** find the long-tail phrases and questions people really type.
- **YouTube topic research:** see what viewers search for around your niche.
- **Amazon and eBay listings:** collect buyer phrases for titles, bullets and backend keywords.
- **App Store Optimization:** get App Store search suggestions per country.
- **PPC:** build ad groups by intent and spot negative keywords.
- **AI agents:** give an agent real demand data before it writes or plans content.

### Which autocomplete sources are supported?

| Engine | Input value | Typical use |
|---|---|---|
| Google autocomplete | `google` | SEO keyword research, long-tail keywords, content ideas |
| YouTube autocomplete | `youtube` | Video topics, titles and tags |
| Amazon autocomplete | `amazon` | Product listing keywords, buyer search terms |
| Bing autocomplete | `bing` | Extra long-tail keywords, Microsoft Ads |
| DuckDuckGo autocomplete | `duckduckgo` | Privacy-audience search terms |
| eBay autocomplete | `ebay` | Listing titles and product demand |
| App Store search hints | `appstore` | App Store Optimization (ASO) keywords |

### Why this one

| | Keyword Autocomplete Explorer |
|---|---|
| Engines | 7 in a single run, deduplicated per engine |
| Expansions | Alphabet (a to z), questions, prepositions |
| Depth | Up to 3 levels of recursive suggestions |
| Intent tag | transactional, commercial, informational, navigational, local, general |
| Languages for expansions | English, Spanish, French, German, Italian, Portuguese |
| Price | $0.40 per 1,000 keywords saved |

### Input

| Field | What it does | Default |
|---|---|---|
| `seeds` | Starting keywords (required) | |
| `engines` | `google`, `youtube`, `bing`, `duckduckgo`, `amazon`, `ebay`, `appstore` | `["google"]` |
| `expansions` | `alphabet`, `questions`, `prepositions` | none |
| `country` | Two-letter country code | `us` |
| `language` | Two-letter language code | `en` |
| `depth` | 1 to 3. Each extra level searches the suggestions again | `1` |
| `maxResults` | Stop after this many keywords | `1000` |

Example:

```json
{
    "seeds": ["running shoes"],
    "engines": ["google", "youtube", "amazon"],
    "expansions": ["alphabet", "questions"],
    "country": "us",
    "language": "en",
    "depth": 2,
    "maxResults": 2000
}
```

### Output

One row per keyword and engine:

```json
{
    "keyword": "best running shoes for flat feet",
    "seed": "running shoes",
    "engine": "google",
    "position": 3,
    "intent": "commercial",
    "isQuestion": false,
    "wordCount": 6,
    "modifier": "f",
    "query": "running shoes f",
    "depth": 1,
    "country": "us",
    "language": "en"
}
```

- `position` is the rank of the suggestion in the engine's own list (1 is the top suggestion).
- `modifier` is the letter or word that was added to the seed to get this suggestion.
- `depth` is 1 for direct suggestions and 2 or 3 for suggestions of suggestions.

Export the dataset as JSON, CSV or Excel, or read it through the Apify API.

### Use it as a keyword suggestion API

Run the Actor and get the keywords back in one HTTP call:

```bash
curl -X POST "https://api.apify.com/v2/acts/vaquilla~keyword-autocomplete-explorer/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN"   -H "Content-Type: application/json"   -d '{"seeds":["running shoes"],"engines":["google","youtube","amazon"],"expansions":["alphabet"]}'
```

The same call works from Python, JavaScript, n8n, Make, Zapier or any tool that can send an HTTP request.

### Use it with AI agents

The Actor works as a tool for AI agents through the Apify MCP server. Give your agent a topic and it can pull the real questions and phrases people search for before it writes an outline, a brief or an ad group.

### How much does it cost?

You pay $0.40 per 1,000 keywords saved to the dataset, plus a $0.00005 fee per run start. Platform usage is included. A failed or empty request costs nothing. Use `maxResults` or the run's maximum cost setting to cap your spend.

### Tips

- Start with `depth: 1` and the alphabet expansion. That alone usually returns 150 to 300 keywords per seed and engine.
- Use `questions` to get content ideas and FAQ sections.
- Filter `intent` by `transactional` and `commercial` for money keywords.
- Amazon supports `us`, `gb`, `de`, `fr`, `it` and `es`. Other countries fall back to the US marketplace.

### FAQ

**Is this an AnswerThePublic or Keyword Tool alternative?** It covers the same idea: autocomplete suggestions expanded with letters, questions and prepositions. You get the raw data as JSON or CSV and pay only for the keywords you save, with no subscription.

**How do I find long-tail keywords?** Turn on the alphabet expansion and set `depth` to 2. Each suggestion is searched again, which surfaces longer and more specific phrases.

**Does it return search volume?** No. Autocomplete suggestions are ordered by popularity, so `position` is a relative signal, but there are no absolute volumes.

**How is intent decided?** With keyword rules for six languages (for example "buy" and "price" are transactional, "best" and "vs" are commercial). Keywords without a clear cue are tagged `general`.

**Is this legal?** The Actor reads the public suggestion endpoints that search boxes use. It collects no personal data.

**Something is missing or broken?** Open an issue in the Issues tab and it will be looked at.

# Actor input Schema

## `seeds` (type: `array`):

One or more starting keywords. Each one is sent to every engine you select.

## `engines` (type: `array`):

Where to collect suggestions from.

## `expansions` (type: `array`):

Extra queries per seed. Alphabet adds a to z after the seed, questions adds how/what/why before it, prepositions adds for/with/vs after it.

## `country` (type: `string`):

Two-letter country code, for example us, gb, es, de, fr, mx.

## `language` (type: `string`):

Two-letter language code, for example en, es, de, fr, it, pt. Also sets the words used by the questions and prepositions expansions.

## `depth` (type: `integer`):

1 returns the direct suggestions. 2 also searches each suggestion again, and 3 repeats that once more. Higher depth finds many more long-tail keywords.

## `maxResults` (type: `integer`):

The run stops when it has saved this many keywords. You only pay for keywords saved.

## Actor input object example

```json
{
  "seeds": [
    "running shoes"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ],
  "expansions": [],
  "country": "us",
  "language": "en",
  "depth": 1,
  "maxResults": 1000
}
```

# Actor output Schema

## `keywords` (type: `string`):

All keyword suggestions found, one row per keyword and engine.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "seeds": [
        "running shoes"
    ],
    "engines": [
        "google",
        "youtube",
        "amazon"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vaquilla/keyword-autocomplete-explorer").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "seeds": ["running shoes"],
    "engines": [
        "google",
        "youtube",
        "amazon",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("vaquilla/keyword-autocomplete-explorer").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": [
    "running shoes"
  ],
  "engines": [
    "google",
    "youtube",
    "amazon"
  ]
}' |
apify call vaquilla/keyword-autocomplete-explorer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vaquilla/keyword-autocomplete-explorer"
        }
    }
}
```

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 <APIFY_API_TOKEN>` 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/ZCebgCE9ymiK1wsbF/builds/bDA5XMfpIB9zezoAk/openapi.json
