# Keyword Question Finder — AnswerThePublic Alternative (`khadinakbar/answerthepublic-alternative`) Actor

Find keyword questions and related searches using Google autocomplete. Submit seed phrases and research patterns, then export ordered suggestions with source queries, country, language, and collection time.

- **URL**: https://apify.com/khadinakbar/answerthepublic-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, Automation
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 question-research source queries

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?

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 Question Finder — AnswerThePublic Alternative

Find keyword questions and related searches using Google autocomplete. Submit seed phrases and research patterns, then export ordered suggestions with source queries, country, language, and collection time. For content researchers, each dataset record is a completed autocomplete source query with its ordered suggestions.

### Workflow: put the results to work

Choose seed phrases and the question patterns your audience might use. Keep country and language aligned with the intended readers. Group the returned suggestions into research themes; autocomplete order is observed source data, not a search-volume or keyword-difficulty estimate.

### Best fit and focused standalone workflow

Choose this Actor when you need current, machine-readable search-question discovery that can feed an editorial brief, content gap list, landing-page outline, or a downstream keyword-metrics workflow. It works well for a specific seed, locale, and research category when an API or dataset is more useful than a visual research interface.

This Actor is designed as a focused standalone workflow. A practical flow starts with a seed such as `shopify seo`, then expands it into selected Google autocomplete patterns, reviews the returned dataset, and passes the shortlist to a separate tool for search volume, CPC, SERP, or rank validation if those metrics are needed.

It deliberately does not replace a broader research suite's saved history, alerts, visual wheels, team workspace, content studio, search-volume, CPC, or trend-comparison features.

### Quick start

```json
{
  "seedKeywords": ["content marketing"],
  "researchTypes": ["questions", "comparisons", "prepositions", "alphabeticals", "numbers", "related"],
  "language": "en",
  "country": "US",
  "maxSourceQueries": 60,
  "maxSuggestionsPerQuery": 10
}
```

Use fewer categories or a lower `maxSourceQueries` value for a smaller, cheaper research pass. The full six-category plan creates up to 58 source queries for one seed; the cap always stops expansion predictably.

### What the Actor does

| Category | Lookup pattern | Why it is useful |
| --- | --- | --- |
| Related | `seed` | Captures the current direct autocomplete context for the seed. |
| Questions | `how seed`, `what seed`, and similar forms | Finds question-led content and FAQ angles. |
| Comparisons | `seed vs`, `seed or`, `seed and` | Finds comparison and alternative-intent phrases. |
| Prepositions | `seed for`, `seed with`, and similar forms | Finds use-case and relationship modifiers. |
| Alphabeticals | `seed a` through `seed z` | Broadens long-tail discovery with a bounded A-Z plan. |
| Numbers | `seed 0` through `seed 9` | Finds number-led modifiers when the live source offers them. |

The source returns autocomplete predictions, not search-volume, CPC, keyword difficulty, rankings, traffic, conversion, or audience estimates.

### Output contract

Each dataset item is one completed source-query snapshot. `suggestions` is an ordered, de-duplicated array from that one request; an empty array is a valid result and is recorded truthfully.

| Field | Meaning |
| --- | --- |
| `seedKeyword` | The original phrase that started the research branch. |
| `researchType` and `variant` | The category and exact pattern used to build the source query. |
| `query` and `queryOrder` | The exact autocomplete phrase and its bounded plan position. |
| `suggestions` and `suggestionCount` | Ordered predictions retained for that one source query. |
| `language` and `country` | Source hints that scoped the request. |
| `sourceUrl`, `sourceEndpoint`, and `collectedAt` | Provenance for rechecking a live, changeable source. |

```json
{
  "runId": "abc123",
  "seedKeyword": "content marketing",
  "researchType": "questions",
  "variant": "how",
  "query": "how content marketing",
  "queryOrder": 2,
  "language": "en",
  "country": "US",
  "suggestions": ["how content marketing works", "how content marketing helps businesses"],
  "suggestionCount": 2,
  "provider": "Google Search autocomplete",
  "sourceEndpoint": "suggestqueries.google.com",
  "sourceUrl": "https://suggestqueries.google.com/complete/search?client=firefox&hl=en&gl=US&q=how+content+marketing",
  "collectedAt": "2026-09-07T10:00:00.000Z"
}
```

Every terminal run also writes `OUTPUT` and `RUN_SUMMARY`. Outcomes are `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, or `CONFIG_ERROR`; use the terminal record before continuing an automated workflow.

```json
{
  "outcome": "COMPLETE",
  "sourceQueriesRequested": 58,
  "sourceQueriesCompleted": 58,
  "sourceQueriesFailed": 0,
  "itemsPushed": 58,
  "suggestionsReturned": 421,
  "warnings": []
}
```

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~answerthepublic-alternative/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "seedKeywords": ["shopify seo"],
    "researchTypes": ["questions", "comparisons", "related"],
    "language": "en",
    "country": "US",
    "maxSourceQueries": 16,
    "maxSuggestionsPerQuery": 10
  }'
```

Read the run's default dataset for the snapshots, then read `OUTPUT` and `RUN_SUMMARY` from its default key-value store before using the results downstream.

### How this workflow compares with AnswerThePublic

| Decision | This Actor | AnswerThePublic |
| --- | --- | --- |
| Scope and workflow | Covers a bounded Google-autocomplete discovery workflow across six explicit category patterns. | A broader research suite can cover dashboard-oriented workflows beyond this focused API dataset. |
| Input friction | Uses seed phrases, locale hints, selected categories, and query caps in a single run. | Use the incumbent when you prefer its broader product workflow and workspace experience. |
| Output contract | Returns one source-provenanced dataset row per completed query, plus terminal `OUTPUT` and `RUN_SUMMARY` records. | Use the incumbent when its product-specific visual or export workflow is a better fit. |
| Automation and integrations | Provides an Apify API run and dataset readback for this bounded workflow; no named client integration is claimed here. | Use the incumbent when its documented suite integrations or alert workflow are required. |
| Freshness and provenance | Each row includes the direct source URL and collection timestamp for a live, changing autocomplete response. | Choose the incumbent when its history, comparison-over-time, or reporting features are the deciding requirement. |
| Billing, cost, and effective efficiency | The Actor is Pay per event with an explicit source-query cap; a same-job cost or effective-efficiency comparison is not claimed without current, matched evidence. | The incumbent lists subscription plans and search allowances that should be checked against the exact workload. |

The comparison is about this specific search-question discovery workflow, not a claim of full-suite parity or a universal recommendation.

### Best-results guidance

Use a specific seed and country/language pair, then validate promising suggestions with your own demand, SERP, and business-context data before publishing content. Autocomplete is live and can change between runs; retain `sourceUrl` and `collectedAt` whenever decisions need a recheck.

If a run is `PARTIAL`, reuse the same bounded input after checking `RUN_SUMMARY`; the record lists the source queries that need another collection attempt. If a valid input finishes `VALID_EMPTY`, try a more natural seed phrase or a different locale to broaden the live autocomplete context.

### AI agent and MCP handoff

An AI agent can use this Actor as a research step, provided it reads the terminal records rather than assuming a successful HTTP request means useful data.

> Run the Actor for `shopify seo` in US English, extract the question and comparison suggestions from the dataset, confirm `OUTPUT.outcome`, then pass only source-provenanced phrases to the next validation step.

The Actor makes read-only autocomplete requests and produces a dataset plus terminal outcome records. It does not write to search engines, publish content, or change external accounts.

### Builder's note

I built this Actor to make the useful part of question-led autocomplete research repeatable in a small, explicit API workflow: a seed, a bounded expansion plan, and an output that keeps the source and collection time beside the suggestions. My goal is to make it easy to inspect what was actually queried before a team treats a phrase as an SEO decision.

### Responsible use

Use the Actor only for research you are authorized to perform and in compliance with applicable laws and site terms. Google autocomplete responses are a live public-source observation, not a license to infer private behavior or make claims about search demand.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/answerthepublic-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `question-research-query` | Question-research source query | One completed, validated, and persisted Google autocomplete source-query snapshot, including a valid empty suggestion list. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Independent alternative

This Actor provides the specific workflow described above. It is not affiliated with or endorsed by AnswerThePublic; the named product and its trademarks belong to their respective owners.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

## `seedKeywords` (type: `array`):

Provide 1-5 starting phrases, such as `content marketing` or `shopify seo`. The Actor trims duplicate seeds, then creates category-specific autocomplete queries. These are phrases, not URLs, domains, search operators, or a bulk keyword export.

## `researchTypes` (type: `array`):

Choose the category patterns to query: questions, comparisons, prepositions, alphabeticals, numbers, or related. The default covers all six categories and is bounded by Maximum source queries. It does not reproduce visual wheels, saved history, alerts, or collaborative workspaces.

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

Language hint sent to Google autocomplete, for example `en`, `es`, or `pt-BR`. Defaults to `en`; the live source can still vary its suggestions. This does not translate the returned suggestions.

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

Two-letter ISO country hint sent to Google autocomplete, such as `US`, `GB`, or `PK`. It provides market context but does not prove the origin of every suggestion.

## `maxSourceQueries` (type: `integer`):

Hard cap on Google autocomplete requests across the full run. The default of 60 covers the standard six-category plan for one seed, and prevents accidental unbounded expansion. Each completed, persisted source query is a billed event; platform usage is additional.

## `maxSuggestionsPerQuery` (type: `integer`):

Maximum ordered suggestions retained from each Google autocomplete response. Defaults to 10 and caps at 10 because the source commonly returns a short prediction list. It is an output cap, not a claim about total demand.

## Actor input object example

```json
{
  "seedKeywords": [
    "content marketing"
  ],
  "researchTypes": [
    "questions",
    "comparisons",
    "prepositions",
    "alphabeticals",
    "numbers",
    "related"
  ],
  "language": "en",
  "country": "US",
  "maxSourceQueries": 60,
  "maxSuggestionsPerQuery": 10
}
```

# Actor output Schema

## `researchSnapshots` (type: `string`):

One source-provenanced Google autocomplete snapshot per completed research query.

## `output` (type: `string`):

Stable terminal outcome and summary for agents and automations.

## `runSummary` (type: `string`):

Detailed source-query, error, and charge diagnostics.

# 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 = {
    "seedKeywords": [
        "content marketing"
    ],
    "researchTypes": [
        "questions",
        "comparisons",
        "prepositions",
        "alphabeticals",
        "numbers",
        "related"
    ],
    "language": "en",
    "country": "US",
    "maxSourceQueries": 60,
    "maxSuggestionsPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/answerthepublic-alternative").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 = {
    "seedKeywords": ["content marketing"],
    "researchTypes": [
        "questions",
        "comparisons",
        "prepositions",
        "alphabeticals",
        "numbers",
        "related",
    ],
    "language": "en",
    "country": "US",
    "maxSourceQueries": 60,
    "maxSuggestionsPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/answerthepublic-alternative").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 '{
  "seedKeywords": [
    "content marketing"
  ],
  "researchTypes": [
    "questions",
    "comparisons",
    "prepositions",
    "alphabeticals",
    "numbers",
    "related"
  ],
  "language": "en",
  "country": "US",
  "maxSourceQueries": 60,
  "maxSuggestionsPerQuery": 10
}' |
apify call khadinakbar/answerthepublic-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/answerthepublic-alternative"
        }
    }
}
```

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/eCXwVp8IMpdHZRyuc/builds/hpBf7xXvOD7tRkz4q/openapi.json