# NVIDIA GeForce Marketplace Scraper (`unfenced-group/nvidia-geforce-marketplace-scraper`) Actor

Live NVIDIA GeForce graphics card prices, stock, and retailers from NVIDIA marketplace across 17 countries. Founders Edition direct prices, per-retailer offers, 25+ fields. No API key required.

- **URL**: https://apify.com/unfenced-group/nvidia-geforce-marketplace-scraper.md
- **Developed by:** [Unfenced Group](https://apify.com/unfenced-group) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## NVIDIA GeForce Marketplace Scraper
![Banner](https://api.apify.com/v2/key-value-stores/lJlifu6C8YQfZMPKE/records/nvidia-geforce-marketplace-scraper)

Pull live NVIDIA GeForce graphics card prices, stock, and retailers straight from NVIDIA's own "where to buy" marketplace — across 17 countries, in local currency. Includes Founders Edition direct-from-NVIDIA prices. No API key required.

---

### Why this scraper?

#### 🟢 Founders Edition direct prices
Captures NVIDIA's own Founders Edition cards — the ones sold and fulfilled directly by NVIDIA at MSRP — with live price and stock, flagged separately so you can spot them instantly.

#### 🏷️ Per-retailer price and stock
Every product carries the full list of retailers selling it, each with its own price, availability, stock level, and direct buy link. Compare offers across sellers in one pass.

#### 🌍 17 markets, local currency
United States, United Kingdom, Germany, France, Italy, Spain, Poland, Denmark, Norway, Canada, Australia, India, South Korea, Taiwan, Mexico, Philippines, and Malaysia — each returns its own lineup in its own currency.

#### 🔍 Keyword and model filters
Narrow to a single model ("RTX 5090"), a brand ("ASUS"), or any keyword across the catalogue. Filter at the source or across results.

#### 📊 25+ fields per product
Model, manufacturer, price, MSRP, lowest retailer price, stock status, ratings where available, images, buy links, and more — clean, structured, ready to use.

---

### Input parameters

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `keyword` | string | Filter results by keyword across title, model, and brand (e.g. "5090", "Founders Edition"). | _(empty — all)_ |
| `gpu` | string | Restrict to a GPU model at the source (e.g. "RTX 5090", "RTX 5070 Ti"). | _(empty)_ |
| `manufacturer` | string | Restrict to a manufacturer (e.g. "NVIDIA" for Founders Edition, "ASUS", "MSI"). | _(empty)_ |
| `locales` | array | Which markets to scrape. Leave empty for all 17 supported. | _(all 15)_ |
| `oneRowPerRetailer` | boolean | Flatten each retailer offer into its own row. | `false` |
| `maxResults` | integer | Maximum rows to return across all selected markets. | `5` |

---

### Output schema

Each product is one row. With `oneRowPerRetailer: true`, each retailer offer becomes its own row instead.

| Field | Description |
|-------|-------------|
| `country` / `locale` / `currency` | Market and currency of the listing |
| `productTitle` / `displayName` | Full and short product name |
| `gpu` | GPU model (e.g. RTX 5090) |
| `manufacturer` | Brand (NVIDIA, ASUS, MSI, Gigabyte, Zotac, PNY, …) |
| `productPrice` / `priceValue` | Display price and numeric value |
| `msrp` | Manufacturer's suggested price |
| `lowestRetailerPrice` | Cheapest offer across retailers |
| `productAvailable` / `prdStatus` / `inStock` | Availability signals |
| `isFounderEdition` | True for NVIDIA Founders Edition (direct-sale) cards |
| `certified` / `bestSeller` | Product flags |
| `productSKU` / `productUPC` / `productID` | Identifiers |
| `retailerCount` / `retailers[]` | Per-retailer price, stock, availability, and buy link |
| `imageURL` / `productLink` | Product image and page |
| `scrapedAt` | Timestamp of capture |

#### Example record

```json
{
  "country": "India",
  "currency": "INR",
  "productTitle": "NVIDIA GeForce RTX 5090",
  "gpu": "RTX 5090",
  "manufacturer": "NVIDIA",
  "productPrice": "₹232,000.00",
  "priceValue": 232000,
  "msrp": 239000,
  "lowestRetailerPrice": 239000,
  "prdStatus": "buy_now",
  "inStock": true,
  "isFounderEdition": true,
  "retailerCount": 2,
  "retailers": [
    {
      "retailerName": null,
      "salePrice": 239000,
      "isAvailable": true,
      "directPurchaseLink": "https://marketplace.nvidia.com/en-in/consumer/graphics-cards/nvidia-geforce-rtx-5090/"
    }
  ],
  "imageURL": "https://assets.nvidia.partners/images/png/...",
  "scrapedAt": "2026-06-30T10:47:00.000Z"
}
````

***

### Examples

**All products, every market**

```json
{ "maxResults": 1000 }
```

**Only Founders Edition cards in the US**

```json
{ "locales": ["en-us"], "manufacturer": "NVIDIA" }
```

**Every RTX 5090 across Europe**

```json
{ "locales": ["de-de", "fr-fr", "it-it", "es-es"], "gpu": "RTX 5090" }
```

**One row per retailer offer, keyword "5080"**

```json
{ "keyword": "5080", "oneRowPerRetailer": true, "maxResults": 500 }
```

***

**Scheduled daily run:**

```json
{
  "maxResults": 300
}
```

Schedule this input in the Apify Scheduler (for example daily at 07:00) to keep an always-fresh dataset.

### 💰 Pricing

**From $0.50 per 1,000 results** — you only pay for products successfully retrieved.

| Results | Cost |
|---------|------|
| 100 | ~$0.07 |
| 1,000 | ~$0.7 |
| 10,000 | ~$7 |
| 100,000 | ~$70 |

Prices step down by account tier, from $0.7/1,000 down to $0.7/1,000 at the highest tier.

> Flat-rate alternatives typically charge $29–$49/month regardless of usage.

Use the **Max results** cap in the input to control your spend exactly.

***

### Performance

| Run size | Typical time |
|----------|--------------|
| One market (~100 products) | ~50 seconds |
| Five markets | ~3 minutes |
| All 17 markets | ~9 minutes |

***

### Known limitations

- **Coverage is 17 markets.** NVIDIA only serves its product feed in certain countries. Markets without an NVIDIA feed (for example the Netherlands) are not available and are not selectable.
- **Founders Edition stock is intermittent.** NVIDIA releases FE cards in limited drops that sell out quickly, so FE cards only appear when NVIDIA has them listed.
- **Ratings and review counts** are not provided by NVIDIA's marketplace and are therefore not included.

***

### Technical details

- **Source:** nvidia.com — NVIDIA GeForce graphics card marketplace
- **Memory:** 256 MB
- **Retry:** Automatic retry on network errors, exponential backoff, 3 attempts per request

***

### Need a custom scraper?

**[Unfenced Group](https://www.unfencedgroup.nl)** builds Apify actors for any website — for free.

If the site you need isn't in our portfolio yet, just ask. We scope, build, and publish it at no cost to you. You only pay for results — we absorb the compute and proxy costs ourselves. Same pay-per-result pricing, same quality, same standards as every actor in this portfolio.

**Get in touch:** [www.unfencedgroup.nl](https://www.unfencedgroup.nl)

# Actor input Schema

## `keyword` (type: `string`):

Filter results by keyword, matched against product title, model, and brand (e.g. "5090", "Founders Edition", "ASUS"). Leave empty to return everything.

## `gpu` (type: `string`):

Restrict to a specific GPU model at the source (e.g. "RTX 5090", "RTX 5070 Ti"). Applied as a server-side filter on the NVIDIA API.

## `manufacturer` (type: `string`):

Restrict to a manufacturer at the source (e.g. "NVIDIA" for Founders Edition, "ASUS", "MSI", "Gigabyte", "Zotac", "PNY").

## `locales` (type: `array`):

Which NVIDIA markets to scrape. Leave empty to scrape all 17 supported countries. Only markets NVIDIA serves on its product API are listed; others (e.g. Netherlands) have no NVIDIA feed and are not selectable.

## `oneRowPerRetailer` (type: `boolean`):

When on, each retailer offer becomes its own row (flattened). When off, each product is one row with a nested retailers array.

## `maxResults` (type: `integer`):

Maximum number of rows to return across all selected locales.

## Actor input object example

```json
{
  "oneRowPerRetailer": false,
  "maxResults": 5
}
```

# Actor output Schema

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

No description

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("unfenced-group/nvidia-geforce-marketplace-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("unfenced-group/nvidia-geforce-marketplace-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call unfenced-group/nvidia-geforce-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=unfenced-group/nvidia-geforce-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NVIDIA GeForce Marketplace Scraper",
        "description": "Live NVIDIA GeForce graphics card prices, stock, and retailers from NVIDIA marketplace across 17 countries. Founders Edition direct prices, per-retailer offers, 25+ fields. No API key required.",
        "version": "0.0",
        "x-build-id": "ETwkL5AiOcUQY7KwK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/unfenced-group~nvidia-geforce-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-unfenced-group-nvidia-geforce-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/unfenced-group~nvidia-geforce-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-unfenced-group-nvidia-geforce-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/unfenced-group~nvidia-geforce-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-unfenced-group-nvidia-geforce-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Filter results by keyword, matched against product title, model, and brand (e.g. \"5090\", \"Founders Edition\", \"ASUS\"). Leave empty to return everything."
                    },
                    "gpu": {
                        "title": "GPU model filter",
                        "type": "string",
                        "description": "Restrict to a specific GPU model at the source (e.g. \"RTX 5090\", \"RTX 5070 Ti\"). Applied as a server-side filter on the NVIDIA API."
                    },
                    "manufacturer": {
                        "title": "Manufacturer filter",
                        "type": "string",
                        "description": "Restrict to a manufacturer at the source (e.g. \"NVIDIA\" for Founders Edition, \"ASUS\", \"MSI\", \"Gigabyte\", \"Zotac\", \"PNY\")."
                    },
                    "locales": {
                        "title": "Countries / locales",
                        "type": "array",
                        "description": "Which NVIDIA markets to scrape. Leave empty to scrape all 17 supported countries. Only markets NVIDIA serves on its product API are listed; others (e.g. Netherlands) have no NVIDIA feed and are not selectable.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "en-us",
                                "en-gb",
                                "de-de",
                                "fr-fr",
                                "it-it",
                                "es-es",
                                "pl-pl",
                                "da-dk",
                                "nb-no",
                                "en-ca",
                                "en-au",
                                "en-in",
                                "ko-kr",
                                "zh-tw",
                                "es-mx",
                                "en-ph",
                                "en-my"
                            ]
                        }
                    },
                    "oneRowPerRetailer": {
                        "title": "One row per retailer offer",
                        "type": "boolean",
                        "description": "When on, each retailer offer becomes its own row (flattened). When off, each product is one row with a nested retailers array.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of rows to return across all selected locales.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
