# Gemini Answers Scraper (`axiomworks/gemini-answers-scraper`) Actor

Collect Gemini responses for questions in your chosen language. Each row includes the prompt, answer text, inline citations, web sources, cited domains, and brand mentions. Prompts are sent as separate anonymous conversations, with no login or API key required.

- **URL**: https://apify.com/axiomworks/gemini-answers-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 results

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

**Returns:** one row per prompt with `prompt`, `answerText`, `citations`, `sources`, `citedDomains`, `usedWebSearch`, `brandMentions`.
**Input:** `{"prompts": ["What are the best CRM tools for small businesses?"], "brands": ["HubSpot", "Salesforce"], "maxItems": 50}`
**Best for:** AI-visibility and GEO tracking, brand and competitor monitoring in AI answers, finding which sites Gemini cites.

```json
{
  "id": "r_e6bc98e1d3ab2126",
  "prompt": "Write a two-line poem about the ocean.",
  "answerText": "Endless blue waves crash against the shore,\nWhispering secrets of the deep ocean floor.",
  "language": "en",
  "usedWebSearch": false,
  "citationCount": 0,
  "sourceCount": 0
}
```

### What does Gemini Answers Scraper do?

Gemini Answers Scraper asks Google Gemini the questions you give it and saves each answer as one dataset row. It works as a Gemini scraper and a simple Gemini API for people who need the answers as data: the full answer text, the inline citations, the list of web sources Gemini searched, and the domains behind them. No login and no API key are needed. Each prompt is a fresh anonymous conversation, so earlier prompts do not influence later ones.

The main use is AI-visibility tracking, also called generative engine optimisation (GEO). You list the questions your customers ask, add the brand names you care about (yours and your competitors), and the Actor tells you for every answer whether each brand is mentioned, how many times, and whether the brand name appears in a cited domain. Run it on a schedule and you can compare the results over time.

It is also useful for research: collecting Gemini answers in many languages, seeing which publications and review sites Gemini relies on for a topic, and building datasets of question and answer pairs.

Answers are not deterministic. Gemini can word an answer differently, cite different sources or skip web search on the same prompt in two runs. Treat one run as a sample and run important prompts more than once.

### What data can you get from Gemini?

Every row has the fields below. The citation and source fields are empty arrays when Gemini answered without searching the web, which happens for creative or purely conversational prompts.

| Field | Description | Example |
|---|---|---|
| `id` | Gemini response id (`r_...`), unique per answer | r_e6b596c8d50be85f |
| `prompt` | The question sent to Gemini | What are the best CRM tools? |
| `language` | Language code from the input | en |
| `answerText` | Full answer as markdown, may contain code blocks | When choosing the best CRM... |
| `citations` | Inline citations with url, title, domain, siteName, snippet and citedText | \[{"url": "https://flowqi.com/..."}] |
| `citationCount` | Number of inline citations | 11 |
| `sources` | The web source list with url, title and domain | \[{"domain": "pcmag.com"}] |
| `sourceCount` | Number of sources | 6 |
| `citedDomains` | Sorted unique domains across citations and sources | \["pcmag.com"] |
| `domainSummary` | Per domain citation and source counts plus distinct URLs | \[{"domain":"pcmag.com","citationCount":2,"sourceCount":1,"urls":\["https://pcmag.com/example"]}] |
| `usedWebSearch` | True when the answer has citations or sources | true |
| `brandMentions` | Per brand: mentioned, count, cited, mentionRank and firstMentionContext (only when brands are given) | \[{"brand": "HubSpot", "mentioned": true}] |
| `conversationId` | Gemini conversation id (`c_...`) | c_81994921342a1ebe |
| `responseId` | Gemini response id | r_e6b596c8d50be85f |
| `scrapedAt` | ISO 8601 time the answer was received | 2026-10-16T00:07:13.487Z |
| `sourceUrl` | Gemini endpoint the answer came from | https://gemini.google.com/app |

### How to use Gemini Answers Scraper

1. Open the Actor on Apify and go to the Input tab.
2. Enter one question per line under Prompts. Write them the way a customer would ask Gemini.
3. Optionally add brand and competitor names under Brands to track, and set the Language code (for example `de` or `ja`).
4. Set Maximum results to the number of prompts you want answered, then press Start.
5. When the run ends, open the Output tab and export the dataset as JSON, CSV, Excel or XML, or read it through the API.

Tips for good results:

1. Ask full questions that include the buying context, such as "best CRM tools for small businesses", because they give Gemini useful context. Web search and citations are not guaranteed.
2. Put competitor names in the brands list too. The `brandMentions` field then shows mention counts and first-appearance order per answer.
3. Keep runs modest. The Actor answers prompts one after another with a short pause, and each answer takes roughly 5 to 20 seconds, so 50 prompts take around 15 minutes.
4. Duplicate prompts in the input are answered once.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `prompts` | array of strings | Yes | Questions to ask Gemini, one dataset item per prompt. Up to 4000 characters each. |
| `brands` | array of strings | No | Brand names to flag in each answer. Adds `brandMentions` to every item. |
| `language` | string | No | Language code for Gemini, for example `en`, `de`, `ja`, `pt-BR`. Default `en`; malformed codes fall back to `en` with a warning. |
| `maxItems` | integer | No | Maximum number of prompts answered, 1-10000, default 50. Shared across all prompts. |
| `proxyConfiguration` | object | No | Proxy settings. Default: Apify Proxy (datacenter). |

```json
{
    "prompts": [
        "What are the best CRM tools for small businesses?",
        "Which project management software do you recommend for remote teams?"
    ],
    "brands": ["HubSpot", "Asana", "Pipedrive"],
    "language": "en",
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

How brand matching works: a brand counts as mentioned when its name appears in the answer text, ignoring case. `count` is the number of occurrences. `cited` is true when the lowercased brand name appears inside any cited or source domain, for example `hubspot` inside `hubspot.com`.

The additive `mentionRank` field orders only the tracked brands by their first appearance in the answer, starting at one. It does not describe a numbered recommendation, sentiment, quality or market position. Two names first appearing at the same position share a rank. An absent brand has a null rank and null `firstMentionContext`. The context is a verbatim excerpt with up to 100 characters before and after the matching name, so analysts can check how Gemini used the name without opening the full answer. Existing `mentioned`, `count` and `cited` values keep their original meanings.

`domainSummary` groups the same citations and sources by domain. Each entry contains `domain`, `citationCount`, `sourceCount` and `urls`. Repeated inline citations are counted separately; the URLs list is deduplicated across both lists. This makes it possible to distinguish a publisher supporting many answer sentences from a site that appears only in the search source list. Domains remain alphabetically ordered, rather than presented as a recommendation ranking. An answer without web sources has an empty domain summary. These calculations use the returned answer without another request or an AI enrichment call.

An empty prompts list ends the run with a clear input error. A prompt that Gemini does not answer after several retries is logged and skipped, and the rest of the batch continues. If nothing could be answered the run still ends successfully with zero items and a status message explaining why.

Gemini's exact English service-error message, “I encountered an error doing what you asked. Could you try again?”, triggers the existing retry path instead of being saved as an answer. Ordinary answers, short creative text and refusals remain unchanged. Other service-error wording is not automatically classified.

### Output

Each prompt becomes one item. Here is a real item for a prompt where Gemini did not search the web:

```json
{
    "id": "r_24cd5d14ca6605ec",
    "prompt": "Write a haiku about autumn leaves",
    "language": "en",
    "answerText": "Golden leaves drift down,\nWhispering of cooler days,\nNature falls asleep.",
    "citations": [],
    "citationCount": 0,
    "sources": [],
    "sourceCount": 0,
    "citedDomains": [],
    "usedWebSearch": false,
    "conversationId": "c_5032e07ec26e5b7a",
    "responseId": "r_24cd5d14ca6605ec",
    "scrapedAt": "2026-10-16T00:07:04.728Z",
    "sourceUrl": "https://gemini.google.com/app",
    "brandMentions": [
        {
            "brand": "HubSpot",
            "mentioned": false,
            "count": 0,
            "cited": false
        }
    ]
}
```

The following selected fields from a local comparison answer show the added visibility metrics and domain summaries:

```json
{
  "id": "r_12d3deb0c489e1b9",
  "prompt": "Compare Notion and Trello for planning a small team project.",
  "brandMentions": [
    {
      "brand": "Notion",
      "mentioned": true,
      "count": 6,
      "cited": false,
      "mentionRank": 1,
      "firstMentionContext": "When planning a small team project, choosing between **Notion** and **Trello** comes down to a core trade-off: **Simplicity vs. Flexibility**. \n\nBoth tools are p"
    },
    {
      "brand": "Trello",
      "mentioned": true,
      "count": 6,
      "cited": false,
      "mentionRank": 2,
      "firstMentionContext": "When planning a small team project, choosing between **Notion** and **Trello** comes down to a core trade-off: **Simplicity vs. Flexibility**. \n\nBoth tools are popular, but the"
    },
    {
      "brand": "MissingBrandXYZ",
      "mentioned": false,
      "count": 0,
      "cited": false,
      "mentionRank": null,
      "firstMentionContext": null
    }
  ],
  "domainSummary": [
    {
      "domain": "aicomparison.ai",
      "citationCount": 5,
      "sourceCount": 1,
      "urls": [
        "https://aicomparison.ai/notion-vs-trello/"
      ]
    },
    {
      "domain": "fastlancer.org",
      "citationCount": 4,
      "sourceCount": 1,
      "urls": [
        "https://www.fastlancer.org/en/fastlancer-blog/notion-vs-trello/"
      ]
    },
    {
      "domain": "rambox.app",
      "citationCount": 2,
      "sourceCount": 1,
      "urls": [
        "https://rambox.app/blog/notion-vs-trello-comparison/"
      ]
    },
    {
      "domain": "toolfinder.com",
      "citationCount": 4,
      "sourceCount": 1,
      "urls": [
        "https://toolfinder.com/comparisons/trello-vs-notion-for-project-management"
      ]
    }
  ]
}
```

The answer text is the visible markdown of the answer. When Gemini runs code to answer, for example for arithmetic, the text can consist mostly of a code block. Download the dataset as JSON, CSV, Excel, XML or RSS from the Output tab or the API.

### How much does it cost to scrape Gemini?

Gemini Answers Scraper is charged per result, which means per prompt answered. You pay only for the answers returned, and `maxItems` caps how many that can be. If you set a maximum cost per run, the Actor stops cleanly when the limit is reached and keeps everything saved so far. See the Pricing tab for the current price.

### Use with AI agents (MCP)

Connect Gemini Answers Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/gemini-answers-scraper"
        }
    }
}
```

Example prompts:

1. "Ask Gemini 'best CRM tools for small businesses' and tell me whether HubSpot or Pipedrive is cited."
2. "Run these 20 buying questions through Gemini and list the domains it cites most often."
3. "Check how Gemini answers 'Was sind die besten Online-Banken in Deutschland?' in German and flag N26 and DKB."

### Integrations and API

Run Gemini Answers Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/gemini-answers-scraper").call(run_input={
    "prompts": ["What are the best CRM tools for small businesses?"],
    "brands": ["HubSpot", "Salesforce"],
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["prompt"], item["citedDomains"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/gemini-answers-scraper').call({
    prompts: ['What are the best CRM tools for small businesses?'],
    brands: ['HubSpot', 'Salesforce'],
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~gemini-answers-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"prompts": ["What are the best CRM tools for small businesses?"], "brands": ["HubSpot"], "maxItems": 50}'
```

On the Integrations tab you can connect the Actor to Make, Zapier, n8n, Google Sheets and webhooks, and schedule runs, for example weekly, to track how answers change.

### FAQ

**Do I need a Google account or API key?**
No. The Actor talks to the public Gemini web endpoint as an anonymous visitor.

**Why does the same prompt give different answers each time?**
Gemini generates a new answer on every request. The sources it searches and cites also change. Run prompts several times and compare the share of runs in which a brand appears.

**Why are citations and sources empty for some prompts?**
Gemini only searches the web when it decides the question needs fresh information. For creative or general prompts it answers from its own knowledge, so `usedWebSearch` is false and the arrays are empty.

**Can I ask in other languages?**
Yes. Set `language` to a code such as `de` or `ja` and write the prompts in that language. Brand names can use any script. If the optional language value is malformed, the Actor logs a warning and uses `en`; the output records this effective language. Missing or blank prompts still fail input validation.

**Why did a run return fewer items than prompts?**
`maxItems` limits the number of prompts answered. Prompts that Gemini did not answer after retries are skipped and listed in the log.

**Does it keep a conversation going across prompts?**
No. Every prompt starts a new anonymous conversation, so there is no follow-up context between prompts.

**What if Gemini starts requiring a login?**
This Actor does not log in. If Gemini stops answering anonymous requests, runs finish with zero items and a status message. Report it on the Issues tab.

### Is it legal to scrape Gemini?

The Actor sends questions to the public Gemini web page without logging in and stores the answers it receives. You are responsible for how you use the output, including any personal data it might contain, and for following the terms of the services and laws that apply to you. This is not legal advice.

Gemini Answers Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Google or Gemini.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `prompts` (type: `array`):

Questions to ask Gemini, one per line, e.g. 'What are the best CRM tools for small businesses?'. Each prompt returns one item with the answer text, citations, sources and cited domains. Duplicates are asked once. Max 4000 characters each. Blocked or unavailable prompts produce no item; check the final status and logs.

## `brands` (type: `array`):

Brand and competitor names to match as case-insensitive substrings. Default \[] skips brandMentions. When set, returns mentioned, count, cited, mentionRank (first-appearance order among tracked brands, not recommendation rank) and firstMentionContext. Absent brands have null rank and context.

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

Language code for the Gemini interface and answers, e.g. 'en', 'de', 'ja', 'pt-BR'. Default 'en'; malformed codes fall back to 'en' with a warning. The effective language is written into every item.

## `maxItems` (type: `integer`):

Maximum number of prompts answered (one item each), 1-10000, default 50. Shared across all prompts in the input: extra prompts are skipped. You are charged only for answers returned.

## `proxyConfiguration` (type: `object`):

Proxy to use for requests, default Apify Proxy (datacenter). Switch to residential proxies only if runs get blocked.

## Actor input object example

```json
{
  "prompts": [
    "What are the best CRM tools for small businesses?"
  ],
  "brands": [
    "HubSpot",
    "Salesforce",
    "Pipedrive"
  ],
  "language": "en",
  "maxItems": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "prompts": [
        "What are the best CRM tools for small businesses?"
    ],
    "brands": [
        "HubSpot",
        "Salesforce",
        "Pipedrive"
    ],
    "language": "en",
    "maxItems": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/gemini-answers-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 = {
    "prompts": ["What are the best CRM tools for small businesses?"],
    "brands": [
        "HubSpot",
        "Salesforce",
        "Pipedrive",
    ],
    "language": "en",
    "maxItems": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/gemini-answers-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 '{
  "prompts": [
    "What are the best CRM tools for small businesses?"
  ],
  "brands": [
    "HubSpot",
    "Salesforce",
    "Pipedrive"
  ],
  "language": "en",
  "maxItems": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/gemini-answers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/gemini-answers-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/dWP3fCOC3YUBIMe4x/builds/lORsgpbHlNZW2uZxC/openapi.json