# Google Merchant Center Q\&A Writer (question_and_answer feed) (`donrulezz/merchant-center-qa-writer`) Actor

Write the new Google Merchant Center question_and_answer attribute for every product from your feed or product pages. Answers use only facts from your page, Google's rules are checked, and you get a ready TSV/XML supplemental feed. Pay per product.

- **URL**: https://apify.com/donrulezz/merchant-center-qa-writer.md
- **Developed by:** [Ashish Agarwal](https://apify.com/donrulezz) (community)
- **Categories:** E-commerce, AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $14.00 / 1,000 product writtens

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

## Google Merchant Center Q\&A Writer (question_and_answer feed)

Google Merchant Center now has a **`question_and_answer`** product attribute: up to 30 shopper questions and answers per
product, used mainly in conversational shopping such as **AI Mode in Google Search**.
This Actor writes them for your whole catalog and hands you a **ready supplemental feed** (TSV and XML) to add in
Merchant Center.

**Answers come only from your own product data.** Every answer must quote a sentence from your feed or product page as
proof, every number must appear on the page, and pairs that break Google's rules are thrown away. You pay only for
products that get at least one valid pair.

### What it does

1. Reads your **Merchant Center feed** (XML, TSV/CSV or a published Google Sheets CSV) or a list of **product page URLs**.
2. Opens each product page and collects facts: Product structured data (brand, material, size, weight, GTIN...), spec
   tables, FAQs already on the page, and the page text. Prices and offers are ignored on purpose.
3. Asks an AI model for the questions a shopper would ask before buying, answered only from those facts.
4. Checks every pair against Google's rules (see below) and drops the ones that fail, with the reason.
5. Writes `supplemental-feed.tsv` and `supplemental-feed.xml` with `id` + `question_and_answer`, plus one dataset item
   per product with the pairs, the proof quotes and the dropped candidates.

### Google's rules, checked for you

From Google's `question_and_answer` specification (Merchant Center Help, article 17085211):

| Rule | What this Actor does |
|---|---|
| Question and answer up to 1,000 characters each | Longer pairs are dropped (answers are written short: 1-3 sentences) |
| Up to 30 pairs, 10,000 characters per product | Hard caps (stays under 9,500 characters to be safe) |
| Product information only, no prices or dates | Drops pairs that mention prices, currencies, discounts, dates, shipping, stock or returns |
| No keywords or search terms | Drops keyword-list questions and ALL-CAPS text; no links, emails or markup |
| Answers must be correct | Each answer needs a proof quote found in your facts, and every number must appear there |
| Don't repeat the title, description, product detail or highlight | Prefers facts that aren't in them and drops answers that only repeat them (can be turned off) |

### Input

- **Product feed URL**: your Merchant Center feed. Ids, titles, descriptions, highlights and product details come from
  here, so the supplemental feed matches your products exactly. Variants with the same `item_group_id` share one set of
  answers (written and charged once).
- **Product page URLs**: or give pages directly. Write `id, URL` on a line to set the Merchant Center id yourself;
  otherwise the page's SKU (or GTIN, MPN or the URL, your choice) becomes the id. It must match the id in your main feed.
- **Q\&A pairs per product**: 6 by default, up to 30. Fewer come back when the page doesn't have enough facts: answers
  are never padded or guessed.
- **Language**: `auto` writes in the page's language, or name one (English, Deutsch, Español...).

Example:

```json
{
  "productUrls": [
    "SKU-123, https://shop.example/products/blue-kettle",
    "https://shop.example/products/travel-mug"
  ],
  "pairsPerProduct": 8,
  "language": "auto"
}
```

### Output

**Dataset** (one item per product id):

```json
{
  "id": "SKU-123",
  "status": "written",
  "pairCount": 2,
  "pairs": [
    {"question": "What is the capacity?", "answer": "It holds 1.7 L of water.", "evidence": "Capacity: 1.7 L"},
    {"question": "How long does Keep Warm last?", "answer": "Keep Warm holds the chosen temperature for up to 30 minutes.",
     "evidence": "Keep Warm holds the chosen temperature for up to 30 minutes."}
  ],
  "questionAndAnswer": "\"What is the capacity?\":\"It holds 1.7 L of water.\",\"How long does Keep Warm last?\":\"Keep Warm holds the chosen temperature for up to 30 minutes.\"",
  "questionAndAnswerSheets": "What is the capacity?:It holds 1.7 L of water.,How long does Keep Warm last?:Keep Warm holds the chosen temperature for up to 30 minutes.",
  "dropped": [{"question": "How much does it cost?", "answer": "...", "reason": "mentions price or promotion"}]
}
```

Status is `written` (charged), `skipped` (not enough facts, or not a product page), `no-valid-pairs` or `failed`
(page couldn't be loaded); only `written` is charged.

**Key-value store**: `supplemental-feed-sheets.csv` (import into a Google Sheet used as a supplemental source), `supplemental-feed.tsv` (Google's text syntax `"question":"answer","question":"answer"` with quotes
doubled) and `supplemental-feed.xml` (RSS 2.0 with `g:question_and_answer` groups). `questionAndAnswerSheets` uses the
Google Sheets syntax (no quotes; commas, colons and backslashes escaped with a backslash).

### Add it to Merchant Center

1. Run the Actor and download `supplemental-feed.tsv` (or `.xml`) from the run's Storage tab.
2. In Merchant Center, open **Data sources**, add a **supplemental** product data source (file upload or Google Sheets)
   and link it to your primary source. The `id` column matches your products, so only `question_and_answer` is added.
3. Already merging columns yourself? Use `questionAndAnswer` from the dataset as the value of a `question_and_answer`
   column in your own feed (or `questionAndAnswerSheets` in a Google Sheet).

Tip: don't also submit a `document_link` with the same information; Google says it extracts FAQs from such documents.

### Pricing

Pay per event: **one charge per product that gets at least one valid pair**. Skipped, failed and no-valid-pairs
products are free, variant groups are charged once, and the run stops when your spending limit is reached. Try it on 10
products first (`maxProducts`).

### Good to know

- Pages are loaded politely: one page at a time per store, 1.5 seconds apart, with back-off when a store answers
  "too many requests". A 1,000-product store takes roughly 30-40 minutes.
- Pages that build their content only with JavaScript expose fewer facts. In feed mode the feed's own data is still
  used; such products may be skipped (free) rather than filled with guesses.
- Review the answers before you submit them: you are responsible for what goes into your feed. The `pairs` view shows
  the proof quote next to every answer.

### FAQ

**Is the `question_and_answer` attribute real?** Yes: it is in Google's Merchant Center product data specification
(Help article 17085211), with question and answer sub-attributes, up to 30 per product.

**Does it work for Shopify, WooCommerce, Magento, BigCommerce?** Yes, it reads any public product page and any standard
Google Shopping feed (XML/TSV/CSV). Most platforms put Product structured data on product pages.

**Will it invent features?** It is built not to: an answer without a proof quote from your data, or with a number that
isn't in your data, is dropped and listed in `dropped` with the reason.

**How do I add questions and answers to my Google Shopping feed?**
Use the `question_and_answer` attribute: in a text/TSV feed one cell holds `"question":"answer","question":"answer"`,
in XML each pair is a `<g:question_and_answer>` with `<g:question>` and `<g:answer>`. The easiest way is a supplemental
data source with `id` + `question_and_answer`, which this Actor produces.

**Where does Google show product Q\&A?**
Google describes the attribute as primarily intended for conversational experiences such as AI Mode in Google Search.

### More tools from the same author

- [Shopify Image Size Checker](https://apify.com/donrulezz/shopify-image-size-checker): every product image under the 500x500 Merchant Center minimum (31 January 2027).
- [AI Visibility Monitor](https://apify.com/donrulezz/ai-answer-engine-monitor): does ChatGPT, Perplexity, Claude or Gemini recommend your brand.
- [Shopify Script Tag Shutoff Scanner](https://apify.com/donrulezz/shopify-script-tag-scanner): which apps on a Shopify store stop on 1 March 2027, and legacy customer accounts.
- [PayPal Legacy Button Finder](https://apify.com/donrulezz/paypal-legacy-button-finder): every old PayPal Buy Now / Add to Cart button before PayPal retires them.
- [SSL Root Certificate Distrust Checker](https://apify.com/donrulezz/root-certificate-distrust-checker): which sites, APIs and mail servers break when Mozilla removes 19 roots on 15 April 2027.
- [Azure Classic CDN & Front Door Retirement Checker](https://apify.com/donrulezz/azure-classic-cdn-front-door-checker): hostnames and page assets still on Front Door (classic) or azureedge.net.
- [Drupal Version & End-of-Life Checker](https://apify.com/donrulezz/drupal-version-eol-checker): which sites run Drupal 10 (end of life 9 December 2026) or older.
- [Website 2027 Breakage Audit](https://apify.com/donrulezz/website-2027-breakage-audit): every 2026-2027 deadline (certificates, Shopify, PayPal, Azure, Drupal, PHP) in one report per site.

*Google and Google Merchant Center are trademarks of Google LLC. This Actor is independent and not affiliated with or endorsed by Google.*

# Actor input Schema

## `feedUrl` (type: `string`):

Your Merchant Center feed: paste its URL or upload the file. XML (RSS/Atom with g: fields) or TSV/CSV with an 'id' column (a published Google Sheets CSV link works). Ids, titles, descriptions, highlights and product details come from here, so the supplemental feed matches your products exactly.

## `productUrls` (type: `array`):

Or/also: product pages, one per line. To set the Merchant Center id yourself, write 'id, URL' (for example 'SKU-123, https://shop.example/p/123'). Without an id the page's SKU (or the URL) is used.

## `pairsPerProduct` (type: `integer`):

How many question/answer pairs to write (Google allows up to 30). Fewer are returned when the page doesn't have enough facts: answers are never padded or guessed.

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

'auto' writes in the product page's language. Or name one, e.g. English, German, Español. Use the language of your feed.

## `readProductPages` (type: `boolean`):

Feed mode: also open each product's link to read specs, on-page FAQs and details that aren't in the feed (recommended: Google asks you not to repeat the title, description, highlights or product details).

## `avoidRepeatingFeedText` (type: `boolean`):

Google's best practice: Q\&A shouldn't repeat data already in title, description, product_detail or product_highlight.

## `groupVariants` (type: `boolean`):

Variants with the same item_group_id share one set of Q\&A (written and charged once, output for every variant id).

## `idSource` (type: `string`):

Which value becomes the feed id when you give only a URL. It must match the id in your main Merchant Center feed. 'Auto' uses Shopify Google & YouTube app ids on Shopify stores (one row per variant: shopify_US\_<product id>\_<variant id>) and the page's SKU elsewhere (the URL when there is no SKU).

## `shopifyCountry` (type: `string`):

Two-letter country in your Shopify Merchant Center ids, e.g. US in shopify_US_123_456. Check one product id in Merchant Center.

## `maxProducts` (type: `integer`):

Optional cap on how many products (variant groups) to process; 0 = all. Try 10 first.

## `maxConcurrency` (type: `integer`):

At most 2 pages are loaded at once per website, whatever this number is.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.allbirds.com/products/mens-tree-runners",
    "SKU-123, https://shop.example/products/blue-kettle"
  ],
  "pairsPerProduct": 6,
  "language": "auto",
  "readProductPages": true,
  "avoidRepeatingFeedText": true,
  "groupVariants": true,
  "idSource": "auto",
  "shopifyCountry": "US",
  "maxProducts": 0,
  "maxConcurrency": 4
}
```

# Actor output Schema

## `feedTsv` (type: `string`):

Upload in Merchant Center: Data sources → Add supplemental product data → file.

## `feedXml` (type: `string`):

Same data as RSS 2.0 with g:question_and_answer groups.

## `feedSheets` (type: `string`):

Import into a Google Sheet used as a supplemental source (Sheets syntax: no quotes, commas/colons escaped).

## `overview` (type: `string`):

One row per product: status, pair count, the TSV value.

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

Pairs with the proof quote, dropped candidates with the reason, Google Sheets syntax.

# 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 = {
    "productUrls": [
        "https://www.allbirds.com/products/mens-tree-runners"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("donrulezz/merchant-center-qa-writer").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 = { "productUrls": ["https://www.allbirds.com/products/mens-tree-runners"] }

# Run the Actor and wait for it to finish
run = client.actor("donrulezz/merchant-center-qa-writer").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 '{
  "productUrls": [
    "https://www.allbirds.com/products/mens-tree-runners"
  ]
}' |
apify call donrulezz/merchant-center-qa-writer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,donrulezz/merchant-center-qa-writer"
        }
    }
}
```

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/scV0pQxbPA3tjduQz/builds/llXVw7rdrQaW549k6/openapi.json