# Give Claude or ChatGPT Real-Time Product Data via Apify's MCP Server (Full Setup Guide)

> Source: <https://dev.to/dynamict3ch/give-claude-or-chatgpt-real-time-product-data-via-apifys-mcp-server-full-setup-guide-1lpi>
> Published: 2026-09-11 04:52:22+00:00

Ask Claude or ChatGPT to check the price of something on a random e-commerce site, and it'll either refuse (no browsing) or guess from stale training data. Even agents with browsing turn up empty-handed more often than you'd expect: Apify's own testing found that Claude browsing five major retailers directly pulled **0 products out of 100** — with Apify's MCP server in the loop, that became **100 out of 100**. Same model, same question, completely different result, because the bottleneck was never the model's reasoning — it was the lack of a reliable way to read a product page.

This guide shows the exact setup: connecting Claude Desktop to Apify's MCP server, then pulling clean, structured product data through it — including a real example using an actor built specifically for this ([Product Data for AI Shopping Agents](https://apify.com/dynamict3ch/product-data-for-ai-shopping-agents)).

MCP (Model Context Protocol) is a standard that lets an AI model call external tools mid-conversation — not just generate text, but actually fetch live data or take actions. Apify runs an MCP server that exposes its entire Store (70,000+ actors — scrapers, extractors, automations) as callable tools. Once connected, Claude can search for the right tool, call it with real input, and get real output back, all inside the conversation.

Open Claude Desktop's config file (`claude_desktop_config.json`) and add one of these:

**Remote, OAuth (recommended — no token to manage):**

```
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}
```

First connection opens your browser for Apify sign-in and approval. Nothing else to configure.

**Remote, with a token** (if you'd rather not do the OAuth flow):

```
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer <YOUR_APIFY_TOKEN>"
      }
    }
  }
}
```

Get your token from **Apify Console → Settings → API & Integrations**.

**Local (stdio), if you want it running on your own machine instead of Apify's remote endpoint:**

```
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Restart Claude Desktop. You should now see Apify's tools available — `search-actors`, `call-actor`, `get-dataset-items`, and a few others.

ChatGPT connects to MCP servers through **Developer Mode**, not a config file. Full read/write access (needed for `call-actor`, since running an actor is a write-style action) is available on Business, Enterprise, and Edu plans; Pro gets read/fetch-only in developer mode. Plus and Free currently don't support custom connectors.

If you're on a supported plan:

`https://mcp.apify.com`, set auth (OAuth is easiest — same flow as Claude).`@mention` it mid-conversation when you need a fresh call.
Everything past this point — the `call-actor` input, the output shape, the pricing — works identically once the connector is scanned in.

You don't need to know actor names by heart — just ask Claude naturally, and it uses `search-actors` to find the right one:

"Search Apify for an actor that turns e-commerce product pages into structured data for AI agents."

Or skip straight to it and call the actor directly by name using `call-actor`:

```
{
  "actor": "dynamict3ch/product-data-for-ai-shopping-agents",
  "input": {
    "startUrls": [
      { "url": "https://mejuri.com/ca/en/products/bia-mini-hoops" }
    ],
    "maxRequestsPerCrawl": 10
  }
}
```

Real output from this exact call:

```
{
  "id": "p134860210",
  "name": "18k Gold Vermeil / Lab Grown White Sapphire",
  "brand": "Mejuri",
  "price": 168,
  "currency": "CAD",
  "availability": "InStock",
  "rating": 4.6,
  "reviewCount": 29,
  "url": "https://mejuri.com/ca/en/products/bia-mini-hoops",
  "imageUrl": "https://cdn.shopify.com/...",
  "description": null,
  "embeddingText": "18k Gold Vermeil / Lab Grown White Sapphire — Mejuri",
  "source": "json-ld",
  "scrapedAt": "2026-09-11T04:01:52.791Z"
}
```

Same shape every time, regardless of which store the URL points to — name, brand, price, currency, stock status, rating, and a source URL, with every field explicitly present (or explicitly `null`) instead of missing keys you have to guard against.

Once connected, you're not limited to one call at a time. A real prompt might look like:

"Here are three ring product URLs. Get the current price and rating for each, and tell me which one has the best rating-to-price ratio."

Claude calls the actor once per URL (or batches them in one `startUrls` list), gets back structured records, and reasons over actual numbers instead of guessing from a product description it half-remembers.

Most e-commerce sites embed `schema.org`/JSON-LD product markup for Google's own crawler — this actor reads that structured data first, falling back to Open Graph tags when JSON-LD isn't present. That's the difference between an agent parsing a hundred different HTML layouts (and breaking on every redesign) and an agent reading data the site already publishes in a machine-readable format.

Pay-per-event: charged per product record returned, not per page crawled. Roughly **$0.01 per product** — a batch of 100 products costs about a dollar.

[Product Data for AI Shopping Agents on Apify Store](https://apify.com/dynamict3ch/product-data-for-ai-shopping-agents)

Sources: [Apify — Real-time product data for AI agents](https://blog.apify.com/real-time-product-data-for-ai-agents/), [Apify MCP server documentation](https://docs.apify.com/integrations/mcp)