# Google AI Product Answers (`s-r/google-ai-product-answers`) Actor

Hosted google ai overview scraper that returns structured JSON without the captcha-solving, proxy-rotation, and site-update maintenance you'd otherwise own. Run it from the Apify Store with one click, or call it from your own service via the Apify API.

- **URL**: https://apify.com/s-r/google-ai-product-answers.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** AI, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 ai overview scrapeds

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

## Google AI Product Answers: turn a barcode into a described, sourced product

Give this actor a barcode, a model number or a product name and it returns
Google's AI answer about that exact product as structured JSON: what the
product is, its specifications, the shops carrying it, and the merchant pages
the answer cited. One dataset row per product.

The interesting input is a bare barcode. An EAN or UPC on its own is not a
search term in any useful sense, yet Google resolves it to the real product and
writes an answer about it. That turns a number with nothing attached into a
described, sourced item without a product catalogue anywhere in the loop.

### What you get

- **A written description of the product** (`answer_text`) covering what it is,
  what it is made of, what is in the box and how it is used, in the language you
  asked in.
- **The description with its structure intact** (`answer_blocks`): specification
  lists stay lists, section headings stay headings, and each block carries the
  merchant pages cited for it.
- **The merchant pages behind the answer** (`sources`) with shop name, domain,
  page title, the snippet Google used and the destination URL. These are the
  retailers Google found carrying the product.
- **Google's own product identifiers** (`products`) where the answer surfaced a
  product card: catalog id, product id, merchant id and cluster id, plus title,
  URL and image.
- **Links inside the answer** (`links`) with Google's redirect already resolved
  to the real shop URL.
- **An honest answered flag** (`answered`). Products Google could not resolve
  come back marked, and are not billed.

### Why look products up this way

A barcode is the one identifier every supply chain agrees on and the one that
carries no information. It tells you nothing about what the product is, and the
usual ways to find out are all partial: a commercial barcode database has
coverage gaps and stale titles, a marketplace listing gives you one seller's
description, and scraping a shop gives you that shop's catalogue and nobody
else's.

Asking the question of a system that has already read the whole retail web is a
different approach. The answer is assembled from the merchant pages that
actually carry the product, so the description reflects what several sellers
say rather than one, and the cited pages are themselves the useful output: they
are a list of retailers stocking that barcode, discovered rather than
configured.

It is worth being clear about what this is not. It is not a price feed and it
is not a guaranteed-coverage database. It is a fast way to go from an identifier
you have to a description and a set of sources you did not, for products where
a catalogue lookup returns nothing.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `products` | array of strings | yes | — | One product per line: a barcode (EAN, UPC, GTIN), a model number, or a product name. |
| `product_urls` | array of strings | no | empty | Google product links to ground the answer on, when you already have them. |
| `country` | string | no | `nl` | Two-letter country code. Sets which market's shops the answer draws on. |
| `language` | string | no | `nl` | Two-letter language code for the answer. |
| `retries` | integer | no | `3` | Extra rounds to spend when an answer does not render. Range 0 to 5. |

Supply `products` on its own for the ordinary case. If you pass
`product_urls` together with exactly one entry in `products`, that entry is
used as the question asked about each link, which is how you ask "is this worth
buying" about a list of specific products.

### Output

One row per product.

```json
{
  "query": "8711942001414",
  "country": "nl",
  "language": "nl",
  "answered": true,
  "product_url": "",
  "answer_text": "Dit EAN-barcodenummer hoort bij de Victorinox Swiss Classic Tomatenmessenset. Het betreft een 6-delige, meerkleurige set met gekartelde messen van roestvrij staal...",
  "answer_blocks": [
    {
      "type": "paragraph",
      "text": "Dit EAN-barcodenummer hoort bij de Victorinox Swiss Classic Tomatenmessenset...",
      "citations": [
        { "uuid": "ebe31371", "site_name": "Supersales", "domains": ["supersales.nl"] }
      ]
    },
    { "type": "heading", "text": "Productspecificaties", "level": 3, "citations": [] },
    {
      "type": "list",
      "items": ["Merk: Victorinox", "Serie: Swiss Classic", "Aantal delen: 6"],
      "citations": []
    }
  ],
  "answer_block_count": 4,
  "sources": [
    {
      "site_name": "Supersales",
      "domain": "supersales.nl",
      "title": "Victorinox Swiss Classic Tomatenmessenset - 11cm - 6-delig",
      "snippet": "Merk, Victorinox. Serie, Swiss Classic...",
      "url": "https://www.supersales.nl/p/victorinox-swiss-classic-tomatenmessenset...",
      "favicon": "https://...",
      "thumbnail": "https://...",
      "citation_id": "ebe31371"
    }
  ],
  "source_domains": ["nr1koken.nl", "supersales.nl"],
  "source_count": 2,
  "links": [{ "text": "Victorinox Swiss Classic Tomatenmessenset", "url": "https://www.supersales.nl/p/...", "kind": "site" }],
  "products": [
    { "title": "Victorinox Swiss Classic Tomatenmessenset", "url": "https://...", "image": "https://...",
      "catalog_id": "14746354957...", "product_id": "", "merchant_id": "576462...", "cluster_id": "" }
  ],
  "thread_id": "rHKhasr7IsidhvcP3v7aoAU",
  "attempts": 1,
  "error": null,
  "fetched_at": "2026-09-09T15:44:07Z",
  "duration_seconds": 6.7,
  "response_bytes": 333779
}
```

### Use cases

**Filling gaps in a product catalogue.** Run the barcodes your catalogue has no
title or description for. What comes back is a written description, a
specification list and the shops that carry the item, which is enough to create
a usable record for a product you previously had only a number for.

**Finding which retailers carry a barcode.** `source_domains` is a discovered
list of shops selling that product in the chosen market. Compare it across
markets by changing `country`, and the difference tells you where a product has
distribution and where it does not.

**Enriching marketplace and supplier feeds.** Supplier feeds arrive with a
barcode and a two-word title. Passing them through gives you the longer
description, the specifications and the competing retailers, which is the
material a marketplace listing needs and the feed did not include.

**Product research before sourcing.** Ask a question about a specific product by
combining `product_urls` with one entry in `products`. The answer covers what
buyers say about it and which shops carry it, with the merchant pages cited, so
you can check the reasoning rather than take the summary on faith.

### How it compares

| | This actor | Typical alternative |
|---|---|---|
| Input | Barcode, model number, product name, or a Google product link | Usually a product URL or a keyword |
| Output | Written description plus specifications, cited merchant pages and Google's product identifiers | Title and price, or raw listing HTML |
| Retailer discovery | Comes free with the answer, as the cited pages | Requires scraping each shop separately |
| Coverage of unknown barcodes | Resolved by Google, not by a fixed database | Barcode databases return nothing outside their index |
| Unanswered products | Returned and marked, not billed | Often a failed run |

Barcode lookup services and product databases are the closer comparison here
than other Apify actors, since the AI actors in the store answer general
questions rather than resolve products. Those services charge per lookup against
a fixed index and return nothing when the barcode is outside it; this actor asks
the open web instead, which trades guaranteed schema for far wider coverage.

### Pricing

$0.008 per product answer returned. There is no actor start fee. Products that
come back unanswered are returned in the dataset and are not charged. All
pricing is pay-per-event, so you only pay for results you receive. There are no
per-compute-unit charges.

### Limits and gotchas

- This is not a price feed. The answer often mentions prices as they appeared on
  the cited pages, but they are part of the prose and are not a structured,
  timestamped price field. Do not build repricing on it.
- Coverage varies by market. A barcode with several Dutch retailers answers well
  with `country: nl`; the same barcode with `country: us` may return little if
  the product is not sold there. Set the market to where the product is sold.
- Obscure or newly issued barcodes may not resolve at all. Those rows come back
  with `answered: false` and are not billed.
- Set `country` and `language` together. The answer is written in the language
  you ask for, and the cited shops follow the market you set.
- `products` is populated only when the answer surfaced a product card. An
  answer with cited merchant pages but an empty `products` array is normal.
- Free Apify plans are capped at 10 rows per run. Split larger lists across runs
  or upgrade to remove the cap.

### FAQ

**Can I look up a product by EAN or UPC without a barcode database?**
Yes. Pass the barcode in `products` and the answer describes the product and
cites the shops carrying it. No database subscription is involved.

**Does it return prices?**
Prices appear inside the answer text when the cited pages showed them, but they
are prose rather than a structured field. For structured offers use a dedicated
offers scraper.

**Which shops sell this product?**
`source_domains` lists the retailers whose pages the answer cited, for the
market you set in `country`.

**What happens if Google cannot identify the barcode?**
The row is returned with `answered: false` and an `error` value, and it is not
billed.

**Can I ask a specific question about a product instead of just describing it?**
Yes. Put the question as the single entry in `products` and the product links in
`product_urls`, and the question is asked about each link.

### Related Actors

- [Google AI Overview Scraper](https://apify.com/s-r/google-ai-overview-scraper)
  for the AI summary above the ordinary search results.
- [Google AI Mode Scraper](https://apify.com/s-r/google-ai-mode-scraper) for the
  conversational AI tab.
- [Google Shopping Scraper](https://apify.com/s-r/google-prices) for structured
  offers and prices per product.

# Actor input Schema

## `products` (type: `array`):

One product per line. A barcode (EAN, UPC, GTIN), a model number, or a product name all work. Google resolves it to the actual product and answers about that item.

## `product_urls` (type: `array`):

Google product links to ground the answer on, when you already have them. Leave empty to work from the Products field alone. If you supply exactly one entry under Products together with these links, that entry is used as the question asked about each link.

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

Two-letter country code. Sets the market the answer is written for, so 'nl' returns Dutch shops and Dutch phrasing while 'us' returns the US view of the same question.

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

Two-letter language code for the answer, for example en, nl, de, fr, es.

## `retries` (type: `integer`):

How many extra rounds to spend when an answer does not render. Each round tries fresh sessions. Three is enough for almost every product.

## Actor input object example

```json
{
  "products": [
    "4053423207231"
  ],
  "product_urls": [],
  "country": "nl",
  "language": "nl",
  "retries": 3
}
```

# Actor output Schema

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

One row per query with the answer and its sources.

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

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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 = {
    "products": [
        "8711942001414",
        "sonos era 300"
    ],
    "product_urls": [],
    "country": "nl",
    "language": "nl",
    "retries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/google-ai-product-answers").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 = {
    "products": [
        "8711942001414",
        "sonos era 300",
    ],
    "product_urls": [],
    "country": "nl",
    "language": "nl",
    "retries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/google-ai-product-answers").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 '{
  "products": [
    "8711942001414",
    "sonos era 300"
  ],
  "product_urls": [],
  "country": "nl",
  "language": "nl",
  "retries": 3
}' |
apify call s-r/google-ai-product-answers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/google-ai-product-answers"
        }
    }
}

```

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/nzrJgoGF3sOC48WRw/builds/RqUem0PwlAxWjiqrn/openapi.json