# Keyword Autocomplete Intelligence — Google & Bing Long-Tail (`johnatan029/keyword-autocomplete-intelligence`) Actor

Keyword research from public autocomplete routes: batch of seeds, A-Z + digits expansion, custom modifiers, multi-language (hl/gl), Google + Bing + YouTube sources. Pay only for keywords written. No key, no login, no browser. Not affiliated with Google or Microsoft.

- **URL**: https://apify.com/johnatan029/keyword-autocomplete-intelligence.md
- **Developed by:** [Johnn Mottin](https://apify.com/johnatan029) (community)
- **Categories:** SEO tools, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 keyword results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Keyword Autocomplete Intelligence — Google & Bing Suggest, A–Z Long-Tail

**Keyword research costs $68–788/month at KeywordTool.io and $29–1,499/month at Ahrefs — for data that comes from public autocomplete routes.** This Actor turns a list of seed keywords into hundreds of structured long-tails: A–Z + digit expansion, custom modifiers, multi-language (`hl`/`gl`), across Google, Bing and YouTube autocomplete. You pay only for the keywords written. No API key, no login, no browser, no LLM.

**Not affiliated with, sponsored by, or endorsed by Google or Microsoft.** All data comes from public autocomplete endpoints and remains subject to those providers' terms.

Who it's for:

- **SEO / content teams:** harvest the long-tail around a topic ("crm software" → "crm software for nonprofits", "crm software vs spreadsheet") in one run, straight to Sheets or your pipeline via Apify integrations.
- **PPC / marketplace sellers:** real buyer phrasing per country and language, not a scraped guess.
- **Market researchers:** what people actually type — including localized demand (`hl=pt&gl=br` returns "melhor crm para whatsapp").

### How it works

You provide **seed keywords**. Default mode is **expand**: each seed becomes the seed itself plus `seed a`…`seed z` and `seed 0`…`seed 9` (plus any custom `modifiers`, applied as prefix and suffix) — ~37 queries per seed, yielding ~260+ unique long-tails (measured). `suggest` mode fetches one direct query per seed instead. Results are deduplicated per source, and **every run writes one free `RUN_SUMMARY` record** — so even a run where every seed returns nothing still yields a non-empty dataset confirming coverage.

**You are only charged for keywords actually written** — duplicates, filtered variants and anything past the cap cost you nothing.

### Input

Copy-paste ready (long-tail harvest, Google + Bing):

```json
{
  "seeds": ["crm software", "email marketing"],
  "mode": "expand",
  "sources": ["google", "bing"]
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `seeds` | array | required | 1–100 seed keywords |
| `mode` | string | `expand` | `expand` (A–Z long-tail harvest) or `suggest` (direct only) |
| `sources` | array | `["google"]` | `google`, `bing`, `youtube`. Prefill ships Google **+ Bing** for redundancy — see below |
| `language` | string | `en` | `hl` code (`en`, `pt`, `de`…) |
| `country` | string | `us` | `gl` code (`us`, `br`…) |
| `modifiers` | array | `[]` | Extra terms as prefix AND suffix (e.g. `["how","best","vs"]`); max 20 |
| `maxResults` | integer | 5000 | Cap on charged keywords; the free summary doesn't count |
| `requestDelayMs` | integer | 250 | Polite pacing before each request (floor 100 ms, deliberate) |

**Why the prefill includes Bing.** These are public, undocumented routes. If one provider changes its response shape, the Actor flags `API_CONTRACT_CHANGED` for that source and **keeps going on the other** — a run stays partial-but-useful instead of failing whole. Google is the product default (omit `sources`); Bing in the prefill is the daily-run safety net.

### Output

One record per keyword (`recordType: "KEYWORD"`):

```json
{
  "recordType": "KEYWORD",
  "keyword": "crm software for nonprofits",
  "seed": "crm software",
  "variantQuery": "crm software f",
  "position": 3,
  "source": "google",
  "language": "en",
  "country": "us",
  "detectedAt": "2026-07-30T13:00:00.000Z"
}
```

Plus one free `RUN_SUMMARY` per run (`statusCounts`, `keywordsWritten`, `duplicatesDiscarded`, and a per-seed×source status array).

### Schedule it (recommended — cloud, not your desktop)

This Actor is built to run on a schedule. **Use Apify's own Schedules, not a local scheduler** — configure it once and it runs in the cloud whether or not your machine is on.

1. Save your input as a **Task** (Console → the Actor → *Create task*), e.g. your niche's seed list.
2. Console → **Schedules → Create schedule**, add the Task, set the cron (e.g. weekly Monday 6am → `0 6 * * 1`).
3. Point downstream (Sheets, webhook, your DB) at the dataset via Apify integrations.

Weekly is a good cadence for tracking how the long-tail around your topics shifts over time.

### Honest limits

- **Public but undocumented routes.** Google/Bing can change the response shape without notice; the Actor detects it (`API_CONTRACT_CHANGED`) and reports rather than emitting garbage. Running Google + Bing together means one shape change never empties your run.
- **Autocomplete returns ~10 suggestions per query** — depth comes from expansion (A–Z, digits, modifiers, languages), not from a single call.
- **Suggestions are demand signals, not volumes.** This Actor does not provide search volume (no public route exposes it honestly); pair it with a volume source if you need that.
- Non-English `hl` responses arrive in ISO-8859-1; the Actor decodes by the response charset, so accents come through clean (`imobiliária`, not mojibake).
- Compliance: `suggestqueries.google.com` publishes no robots.txt (404) and `google.com/robots.txt` does not list `/complete` (verified 2026-07-30) — recorded as fact, not as permission; the providers' general terms still apply. Pacing is polite and identified; a source that walls us off (redirect/403) becomes a controlled `SOURCE_BLOCKED`, never bypassed.

### Ops notes

- `STATS` key in the run's key-value store: per-seed×source summary, HTTP counters, dedup counts, field-completeness health check, warnings. `ERRORS` on failure.
- Cost drivers: requests made (≈37 per seed per source in expand) + keywords written. A 2-seed expand over Google runs in well under a minute at 512 MB.

### FAQ

**Do I need a Google or Bing API key?** No. The Actor reads public autocomplete endpoints without a key and without logging in.

**Does it return search volume?** No. Autocomplete exposes demand *signals* — what people actually type — not volumes, and no public route exposes volume honestly. Pair this Actor with a volume source if you need that number.

**What exactly am I charged for?** Per keyword written to the dataset (Pay Per Event) — duplicates, filtered variants and anything past the cap cost you nothing, and the `RUN_SUMMARY` record is free. The Pricing tab on this page is always the authoritative source for current rates and for any per-run fee.

**Can I schedule it?** Yes — that is the intended use. See "Schedule it" above.

**Is this affiliated with Google or Microsoft?** No. This is an unofficial community Actor; all data comes from public autocomplete endpoints and remains subject to those providers' terms.

# Actor input Schema

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

1–100 seed keywords (e.g. "crm software"). Each seed expands to ~37 queries in expand mode (~260+ unique long-tails measured).

## `mode` (type: `string`):

expand (default): seed + a-z + 0-9 (+ modifiers) — the long-tail harvest. suggest: one direct query per seed.

## `sources` (type: `array`):

google (web autocomplete), bing (osjson), youtube (Google suggest with ds=yt). Prefill includes Google + Bing for redundancy — if one source changes its response contract, the other keeps the run alive (controlled per-source status, partial survival).

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

Autocomplete language, e.g. "en", "pt", "de". Verified working with pt/br.

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

2-letter country code for regional suggestions, e.g. "us", "br".

## `modifiers` (type: `array`):

Extra expansion terms applied as prefix AND suffix (e.g. "how", "best", "vs" → "how crm software" and "crm software how"). Max 20; each adds 2 queries per seed.

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

Global cap on charged keyword records. The free RUN\_SUMMARY does not count.

## `requestDelayMs` (type: `integer`):

Polite pacing before every request (serial per source; sources run in parallel). The 100 ms floor is deliberate.

## `debug` (type: `boolean`):

Verbose logs.

## Actor input object example

```json
{
  "seeds": [
    "crm software",
    "email marketing"
  ],
  "mode": "expand",
  "sources": [
    "google",
    "bing"
  ],
  "language": "en",
  "country": "us",
  "modifiers": [],
  "maxResults": 5000,
  "requestDelayMs": 250,
  "debug": false
}
```

# 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": [
        "crm software",
        "email marketing"
    ],
    "mode": "expand",
    "sources": [
        "google",
        "bing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnatan029/keyword-autocomplete-intelligence").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": [
        "crm software",
        "email marketing",
    ],
    "mode": "expand",
    "sources": [
        "google",
        "bing",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("johnatan029/keyword-autocomplete-intelligence").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "crm software",
    "email marketing"
  ],
  "mode": "expand",
  "sources": [
    "google",
    "bing"
  ]
}' |
apify call johnatan029/keyword-autocomplete-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnatan029/keyword-autocomplete-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7y59zGStePeRwjps9/builds/ruonhzA0QWbE9jHL6/openapi.json