# People Also Ask Scraper (`blueskyscraper/people-also-ask-scraper`) Actor

\[$2.25/1K questions] Scrape Google People Also Ask questions for any keyword: question, nesting level, parent question, position, plus optional Related searches. Any country, language, desktop or mobile. Export, run via API, schedule runs or use with AI agents.

- **URL**: https://apify.com/blueskyscraper/people-also-ask-scraper.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** SEO tools, AI
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.63 / 1,000 people also ask questions

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### What is People Also Ask Scraper?

**People Also Ask Scraper** extracts the **Google "People also ask" questions** for any list of keywords. One row is one question, with the **keyword** it came from, its **nesting level** (shown on the page or revealed by expanding another question), the **parent question** that revealed it, its **position** in the box, the country, language and device of the search, and a link to the Google results page. Optionally it also returns Google's **Related searches** and **People also search for** suggestions.

The data comes from live Google results pages in **any country and language Google serves, on desktop or mobile**, through a licensed SERP data provider. No Google account, no API key, no proxy setup and no official Google API needed. Questions cost **$0.0009 each ($0.90 per 1,000)**, there is **no fee per run**, and keywords with no "People also ask" box are free.

Use it as a **PAA scraper** for content ideas, FAQ schema research, blog outlines, topic clusters and AI content briefs — a Google questions API you can call from Python, JavaScript, n8n, Make or an AI agent.

### What data can People Also Ask Scraper extract?

| Field | Example | What it means |
|---|---|---|
| `type` | `question` | Row type: `question`, `related-search` (only when switched on) or `error` (free) |
| `keyword` | `how to start a podcast` | The keyword you searched |
| `question` | `Do I need a license for a podcast?` | The question exactly as Google shows it |
| `level` | `2` | 1 = on the results page, 2 = appeared after Google expanded a level-1 question, 3–5 = deeper expansions |
| `parentQuestion` | `How to start a podcast with no audience?` | The question whose expansion revealed this one (empty for level 1) |
| `position` | `6` | Order of the question in the box, starting at 1 |
| `answerType` | `ai_overview_not_captured` | How Google answers the question (see "Answers" below) |
| `serpPosition` | `3` | Where the "People also ask" box sits among all elements of the results page |
| `location`, `locationCode` | `United States`, `2840` | Country of the search |
| `language`, `languageCode` | `English`, `en` | Google interface language |
| `device` | `desktop` | `desktop` or `mobile` |
| `searchUrl` | `https://www.google.com/search?q=…` | The Google results page, to check any row by hand |
| `scrapedAt` | `2026-10-01T14:23:33Z` | When the row was produced |

Related-search rows (only when you switch them on) carry `keyword`, `query` (the suggested search), `source` (`related_searches` or `people_also_search`), `position`, country, language, device and `searchUrl`.

#### 🧭 Questions as a tree, not a flat list

`level` and `parentQuestion` let you rebuild the question tree Google builds when someone clicks through the box. In our test run for **how to start a podcast** (United States, English, desktop, depth 2) Google showed four questions on the page; expanding "How to start a podcast with no audience?" added "Why do most podcasts fail?" and "Do I need a license for a podcast?", and expanding the licence question added three more, including "Do podcasters have to pay their guests?". That is how you see which sub-topics Google connects to your keyword — the structure of a good FAQ section or a pillar page.

#### Answers: what Google shows in 2026

Google used to answer each "People also ask" question with a quoted paragraph from a web page. In 2026 it answers most of them with an **AI-generated answer that loads after the page**. Our data provider does not capture those AI answers, so on such questions `answerType` is `ai_overview_not_captured` and there is no answer text. In our October 2026 test runs (United States and Germany, desktop and mobile) this was the case for **every one of the 56 questions** we checked.

When Google does show a classic quoted answer, the row also carries `answer`, `sourceUrl`, `sourceDomain` and `sourceTitle`, and `answerType` is `featured_snippet` (or `ai_overview` when an AI answer was captured). Those fields simply do not appear on rows without an answer. The price per question is the same either way: you pay for the question.

### How much does it cost to scrape People Also Ask questions?

People Also Ask Scraper uses **pay-per-event** pricing. You pay only for rows with data.

| Event | Price (free plan) | What you get |
|---|---|---|
| `question` | **$0.0009** ($0.90 per 1,000) | One People Also Ask question row |
| `related-search` | **$0.0005** ($0.50 per 1,000) | One Related searches / People also search for row — only when you switch it on |
| Run start | **$0** | No fee per run |
| Keyword without a People Also Ask box | **$0** | Free row with `hasData: false` |
| Error rows | **$0** | Bad country, bad language, empty keyword — never charged |

Paid Apify plans pay less per question: Bronze $0.00085, Silver $0.0008, Gold and above $0.00075.

Set **Max cost per run** in the run options and the Actor stops exactly there: it never hands out rows past your limit, and it does not keep searching once the limit is reached.

**Real numbers from our test runs:**

- The default input (2 keywords, depth 2) returned **18 questions for $0.0162**.
- One German keyword with Related searches on returned 9 questions and 8 related searches: **$0.0121**.
- One keyword on mobile at depth 0 with People also search for on: 4 questions + 10 suggestions = **$0.0086**.

A typical keyword at the default depth gives about 9 questions, so **$1 buys roughly 1,100 questions, or about 120 keywords** fully expanded. Apify's free plan includes $5 of monthly usage, enough for about 5,500 questions.

#### 💰 How expansion depth changes the cost

Each keyword is one Google search. `Question expansion depth` tells Google how many times to open a question and collect the new ones it adds. More depth = more questions per keyword = more rows billed:

| Depth | Questions per keyword (measured) | Cost per keyword |
|---|---|---|
| 0 | 4 | about $0.0036 |
| 1 | 6 | about $0.0054 |
| 2 (default) | 9 | about $0.0081 |

Depths 3 and 4 continue the same way (Google adds two to three questions per expansion). The number of questions is Google's, not ours: some keywords show fewer, and some show none.

### How to scrape Google People Also Ask with People Also Ask Scraper

1. Open **People Also Ask Scraper** in Apify Console and click **Try for free**.
2. In **🔍 Keywords**, type one search phrase per line — the way people search, e.g. `bali visa`, `how to start a podcast`.
3. Set **📍 Country** and **🗣️ Language** (names or codes: `United States`, `GB`, `Germany`, `de`, `Indonesian`, `id`).
4. Choose **❓ Question expansion depth** (default 2) and the **💻 Device**.
5. Switch on **🔗 Add Related searches** or **🔗 Add People also search for** if you want those suggestions too.
6. Click **Start**. Most runs finish in under a minute; repeating the same keywords within 7 days is answered from cache in a few seconds.
7. Download the results as **CSV, Excel, JSON or HTML**, or read them over the API.

### ⬇️ Input

The default input runs two keywords in the United States, in English, on desktop, expanded to depth 2:

```json
{
  "keywords": ["bali visa", "how to start a podcast"],
  "location": "United States",
  "language": "English",
  "clickDepth": 2,
  "device": "desktop",
  "includeRelatedSearches": false,
  "includePeopleAlsoSearch": false,
  "maxKeywords": 100
}
```

| Field | Default | Notes |
|---|---|---|
| `keywords` | 2 demo keywords | Up to 1,000 per run, one Google search each |
| `location` | United States | Country name or two-letter code; every Google country is supported |
| `language` | English | Language name or code; empty = the country's main language (Indonesia → Indonesian, Vietnam → Vietnamese, Germany → German) |
| `clickDepth` | 2 | 0–4; more depth = more questions ($) |
| `device` | desktop | `desktop` or `mobile` |
| `includeRelatedSearches` | false | Adds Related searches rows ($) |
| `includePeopleAlsoSearch` | false | Adds People also search for rows when Google shows them, mostly on mobile ($) |
| `maxKeywords` | 100 | Safety cap on the number of keywords searched |

#### Questions only (the default)

Leave both 🔗 switches off. The dataset then has one row type — `question` — and the **Questions** tab shows a clean table.

#### Questions plus Related searches

Switch on **🔗 Add Related searches**. Each keyword then also returns its Google Related searches (8 per keyword in our tests) as `related-search` rows. They appear in the **Related searches** tab; `type` is the first column in every tab so the two row types never mix up.

### ⬆️ Output

One question row from the default run:

```json
{
  "type": "question",
  "keyword": "bali visa",
  "question": "Is it safe for Americans to travel to Bali right now?",
  "hasData": true,
  "level": 2,
  "parentQuestion": "Should I get a Bali visa online or on arrival?",
  "position": 6,
  "answerType": "ai_overview_not_captured",
  "serpPosition": 3,
  "location": "United States",
  "locationCode": 2840,
  "language": "English",
  "languageCode": "en",
  "device": "desktop",
  "searchUrl": "https://www.google.com/search?q=bali%20visa&hl=en&gl=US&ie=UTF-8",
  "scrapedAt": "2026-10-01T14:23:33.088Z"
}
```

One related-search row:

```json
{
  "type": "related-search",
  "keyword": "podcast starten",
  "query": "Podcast starten kostenlos",
  "source": "related_searches",
  "position": 2,
  "location": "Germany",
  "language": "German",
  "device": "desktop"
}
```

A keyword with no "People also ask" box returns one free row with `question: null`, `hasData: false` and a `note` explaining it, so your list stays complete and you can see which keywords Google does not attach questions to.

The run summary (keywords searched, questions found, keywords without a box, rows from cache) is saved in the key-value store as `SUMMARY`.

### Use cases for Google People Also Ask data

#### Content ideas and blog outlines

Every question is a sub-heading someone actually searches. Run your topic list, sort by `keyword` and `level`, and you have the H2/H3 skeleton of an article that answers what readers ask next.

#### FAQ schema research

Pick the level-1 and level-2 questions for a page's keyword and answer them in a FAQ block. The questions are Google's own wording, which is what you want in FAQ markup and in AI search answers.

#### Topic clusters and pillar pages

`parentQuestion` shows which questions Google treats as follow-ups of which. Questions that branch from the same parent belong on the same page; separate branches are candidates for separate cluster articles.

#### Keyword research pipelines

Chain it with our other SEO actors: get long-tail keywords from [Keyword Suggestions Scraper](https://apify.com/lergassy/keyword-suggestions-scraper), pull the questions for each with People Also Ask Scraper, then check which questions have search demand in [Keyword Search Volume Checker](https://apify.com/blueskyscraper/keyword-search-volume-checker).

#### AI content briefs and agents

A writing agent can call the Actor through MCP with a keyword, get flat question rows back and turn them into an outline — no HTML parsing, no Google blocking.

#### Local and international SEO

The same keyword in different countries and languages produces different questions. Run `bali visa` for the United States, the United Kingdom and Australia and compare what each market wants to know.

### Integrations

#### Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/lergassy~people-also-ask-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["how to start a podcast"], "location": "US", "language": "en"}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("lergassy/people-also-ask-scraper").call(run_input={
    "keywords": ["how to start a podcast", "podcast microphone"],
    "location": "United States",
    "language": "English",
    "clickDepth": 2,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["level"], row["question"])
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('lergassy/people-also-ask-scraper').call({ keywords: ['bali visa'], location: 'GB' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((r) => r.question));
```

#### No-code tools

Use the Apify integrations for **Google Sheets, n8n, Make, Zapier, Slack** and **webhooks** to send questions to a spreadsheet or a content calendar after every run, or schedule a weekly run to track how the questions for your keywords change.

#### MCP server for AI agents

The Actor works with the **Apify MCP server** (`https://mcp.apify.com`), so Claude, ChatGPT, Cursor and other MCP clients can call it as a tool.

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling `lergassy/people-also-ask-scraper` through the Apify MCP server or API.

**Purpose:** returns the Google "People also ask" questions for keywords; one row per question with its nesting level and parent question.

**Minimal input:**

```json
{ "keywords": ["how to start a podcast"], "location": "US", "language": "en" }
```

**Output fields (question rows):** type, keyword, question, hasData, level, parentQuestion, position, answerType, serpPosition, location, locationCode, language, languageCode, device, searchUrl, scrapedAt; plus answer, sourceUrl, sourceDomain, sourceTitle only when Google showed a quoted answer. Related-search rows: type, keyword, query, source, position, location, language, device, searchUrl.

**Behaviors an agent should know:**

- One keyword = one Google search; `clickDepth` (0–4, default 2) controls how many extra questions are revealed.
- Answers are usually not available (`answerType: ai_overview_not_captured`); do not expect answer text.
- `hasData: false` rows mean Google showed no question box for that keyword; they are free.
- Related-search rows appear only when `includeRelatedSearches` or `includePeopleAlsoSearch` is true; filter by `type`.
- Billing: `question` $0.0009, `related-search` $0.0005; errors and empty keywords are free; no run fee.
- Rows are flat; no nested objects.

### ❓ FAQ

#### Is it legal to scrape Google People Also Ask?

The Actor reads public Google search results, the same page anyone sees without logging in, through a licensed SERP data provider. It collects no personal data. Using public search data for research and content planning is common practice, but rules differ by country and by use — consult a lawyer if you are unsure about your case.

#### Does it return the answers to the questions?

Only when Google shows a classic quoted answer. In 2026 Google answers most "People also ask" questions with an AI answer that loads after the page, and that text is not captured — in our tests, none of 56 questions had a capturable answer. Treat this Actor as a **question** scraper; you are billed per question, not per answer.

#### How many questions do I get per keyword?

Usually 4 on the page; about 6 at depth 1 and about 9 at depth 2 in our tests. Some keywords show fewer, and some show no box at all — those return a free `hasData: false` row.

#### Why are the questions different from what I see in my browser?

Google personalises results by location, language, device and history. The Actor searches as a clean, logged-out user in the country and language you choose. Open `searchUrl` to see the same page.

#### Can I use People Also Ask Scraper with the Apify API?

Yes. Every run can be started and read over the Apify REST API, or with the Python and JavaScript clients shown above.

#### Can I use it through an MCP server?

Yes. Connect the Apify MCP server to Claude, ChatGPT, Cursor or any MCP client and call `lergassy/people-also-ask-scraper` as a tool.

#### Can I integrate it with other apps?

Yes — Google Sheets, n8n, Make, Zapier, Slack, webhooks and any tool that reads JSON or CSV.

#### How much does it cost to scrape 1,000 keywords?

At the default depth about 9,000 questions, roughly **$8.10**. At depth 0 about 4,000 questions, roughly **$3.60**. Keywords without a question box cost nothing.

#### Is one row one question?

Yes. Every question is its own row with its keyword, level and parent, so you can sort, filter and count without unpacking nested data.

#### What happens if many keywords return nothing?

The Actor stops early and writes one free error row if the keywords keep returning no question box — for example, a list of random strings. Rows already delivered stay in the dataset.

### Your feedback

Found a bug, missing a field or need another country or device setting? Open an issue in the **Issues** tab — we read every one. If the Actor saves you time, a review on the Store page helps other people find it.

### You might also like

| Actor | What it does |
|---|---|
| [Keyword Suggestions Scraper](https://apify.com/lergassy/keyword-suggestions-scraper) | Google, YouTube, Amazon, Bing, eBay and TikTok autocomplete suggestions — the long-tail keywords to feed into this Actor |
| [Keyword Search Volume Checker](https://apify.com/blueskyscraper/keyword-search-volume-checker) | Monthly search volume, CPC, difficulty and intent for your keywords and questions |
| [Google Trends Scraper](https://apify.com/lergassy/google-trends-scraper) | Interest over time, by region, related queries and topics |
| [Competitor Keywords Finder](https://apify.com/blueskyscraper/competitor-keywords-finder) | Every keyword a competitor domain ranks for on Google |

# Actor input Schema

## `keywords` (type: `array`):

Enter one search keyword per line, exactly as people type it into Google (up to 1,000 per run). Each keyword is one Google search; every question in its "People also ask" box becomes one row.

## `location` (type: `string`):

Enter the country whose Google results you want: a country name or two-letter code (United States, US, United Kingdom, GB, Germany, DE, India, IN, Indonesia, ID…). All countries Google serves are supported; an unknown name returns a free error row.

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

Enter the Google interface language: a language name or code (English, en, Spanish, es, German, de, French, fr, Indonesian, id…). Leave empty to use the country's main language.

## `clickDepth` (type: `integer`):

Set how deep to expand the "People also ask" box (0–4). 0 = only the questions Google shows on the page (usually 4). Each extra level opens a question and collects the new questions Google adds under it (measured: about 6 questions at depth 1, about 9 at depth 2). More questions = more rows, each billed as one question.

## `device` (type: `string`):

Choose whose Google results to read: desktop or mobile. Mobile results can show a different set of questions and a "People also search for" box.

## `includeRelatedSearches` (type: `boolean`):

Switch on to also return the "Related searches" suggestions from the bottom of the Google results page (usually 8 per keyword), one row each with type = related-search. Billed per related-search row.

## `includePeopleAlsoSearch` (type: `boolean`):

Switch on to also return "People also search for" suggestions when Google shows them (most often on mobile), one row each with type = related-search and source = people_also_search. Billed per related-search row.

## `maxKeywords` (type: `integer`):

Safety cap: only the first N keywords of your list are searched. Raise it for bulk lists up to 1,000.

## Actor input object example

```json
{
  "keywords": [
    "bali visa",
    "how to start a podcast"
  ],
  "location": "United States",
  "language": "English",
  "clickDepth": 2,
  "device": "desktop",
  "includeRelatedSearches": false,
  "includePeopleAlsoSearch": false,
  "maxKeywords": 100
}
```

# Actor output Schema

## `results` (type: `string`):

One row per Google People Also Ask question: keyword, question, nesting level, parent question, position; optional related-search rows.

# 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 = {
    "keywords": [
        "bali visa",
        "how to start a podcast"
    ],
    "location": "United States",
    "language": "English"
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/people-also-ask-scraper").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 = {
    "keywords": [
        "bali visa",
        "how to start a podcast",
    ],
    "location": "United States",
    "language": "English",
}

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/people-also-ask-scraper").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": [
    "bali visa",
    "how to start a podcast"
  ],
  "location": "United States",
  "language": "English"
}' |
apify call blueskyscraper/people-also-ask-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,blueskyscraper/people-also-ask-scraper"
        }
    }
}
```

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/bb5gUGAOLzdhS3Qfu/builds/y1cdEA8JvTsVjDnYM/openapi.json