# ChatGPT Marketplace Scraper (`maximedupre/chatgpt-marketplace-scraper`) Actor

Scrape public ChatGPT GPT marketplace listings from URLs, search phrases, categories, or tags. Export GPT names, descriptions, creators, verification, categories, capabilities, usage metrics, images, and listing context.

- **URL**: https://apify.com/maximedupre/chatgpt-marketplace-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.60 / 1,000 scraped custom gpts

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

### 🔎 ChatGPT marketplace scraper for public GPT data

ChatGPT Marketplace Scraper collects public custom GPT listings from [ChatGPT](https://chatgpt.com/gpts). Use this chatgpt marketplace scraper to search by phrase, browse categories or marketplace pages, or enrich direct GPT listing URLs without opening each listing by hand.

Each saved row is one public custom GPT listing. Rows can include the GPT ID, name, description, image URL, creator details, verified creator status, categories, tags, capabilities, prompt examples, usage metrics, review facts when exposed, listing status, timestamps, and discovery context.

You do not need a ChatGPT account, OpenAI API key, cookies, private token, or browser extension. For a quick first run, keep the prefilled `data analysis` target, leave `Discovery order` on source relevance, and use a small `Maximum GPTs per discovery target` value before raising the limit.

### ✅ What this Actor does

- Searches public custom GPT listings from search phrases such as `data analysis`, `invoice assistant`, or `marketing`.
- Scrapes direct public GPT listing URLs such as `https://chatgpt.com/g/g-2fkFE8rbu-dall-e`.
- Reads public marketplace, category, or tag targets when the source exposes them.
- Saves one dataset row per accepted public custom GPT listing.
- Deduplicates the same GPT inside a run by its stable public GPT ID.
- Keeps source-native labels and metrics instead of inventing categories, scores, summaries, or recommendations.
- Skips private, unavailable, failed, or unsupported targets instead of mixing error rows into the dataset.

This Actor is built for GPT marketplace research, AI tool directories, creator research, category monitoring, competitor lists, and repeatable custom GPT exports. It focuses on public listing facts only. It does not scrape private chats, private GPT configuration, builder dashboards, account analytics, or logged-in-only workspace data.

### 📦 Data you can extract

Each dataset item can include:

- `gptId` and `name`
- `description` and `imageUrl`
- `creator.name`, `creator.url`, `creator.verified`, and `creator.organization`
- `categories`, `tags`, and `capabilities`
- `model`, `voice`, and `promptExamples`
- `conversationCount`, `rating`, `reviewCount`, and `reviewSummary`
- `listingStatus`, `publishedAt`, and `updatedAt`
- `discovery.targets`, `discovery.sourceUrl`, and `discovery.rank`

Some fields can be `null` or empty when ChatGPT does not expose that fact for a public listing. Direct listing URL targets return `discovery: null` because the submitted listing is already the source.

### 🎯 Target options

Add one target per row in `GPT marketplace targets`.

Supported target formats:

- Direct GPT listing URL: `https://chatgpt.com/g/g-2fkFE8rbu-dall-e`
- Search phrase: `data analysis`
- Category or tag name: `productivity`
- Marketplace page URL: `https://chatgpt.com/gpts`

`Maximum GPTs per discovery target` caps rows saved from search, category, tag, and marketplace page targets. Direct listing URLs return one matching GPT.

`Discovery order` chooses the source order for discovery targets when available:

- `Source relevance` keeps the source's default result order.
- `Popular first` sorts discovered listings by source-native conversation count when available.
- `Newest first` uses source-supported date order for search and source-native update dates for other discovery rows.

### 🚀 How to run it

1. Open the Actor input.
2. Add GPT URLs, marketplace URLs, search phrases, category names, or tag names.
3. Keep `Maximum GPTs per discovery target` small for your first run.
4. Choose a discovery order only if you need a specific result order.
5. Run the Actor and open the dataset.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the Actor through the Apify API, schedule repeat runs, or connect results to webhooks and integrations.

### 🧾 Output example

```json
{
	"gptId": "g-2fkFE8rbu",
	"name": "DALL-E",
	"description": "Create images from text prompts.",
	"imageUrl": "https://example.com/gpt-icon.png",
	"creator": {
		"name": "OpenAI",
		"url": "https://chatgpt.com/gpts/mine/openai",
		"verified": true,
		"organization": "OpenAI"
	},
	"categories": ["Productivity"],
	"tags": ["image generation", "design"],
	"capabilities": ["DALL-E", "Image generation"],
	"model": "GPT-4o",
	"voice": null,
	"promptExamples": ["Create a watercolor fox reading a book"],
	"conversationCount": 2500000,
	"rating": 4.7,
	"reviewCount": 1842,
	"reviewSummary": "Highly rated by users",
	"listingStatus": "active",
	"publishedAt": "2024-01-10",
	"updatedAt": "2026-06-01",
	"discovery": {
		"targets": ["data analysis"],
		"sourceUrl": "https://cse.google.com/cse?cx=b0b573346627a4812#gsc.tab=0&gsc.q=data+analysis&gsc.page=1&gsc.sort=date",
		"rank": 3
	}
}
````

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged once for each accepted public custom GPT listing saved to the dataset.

Failed targets, private targets, unavailable listings, unsupported inputs, skipped duplicates, and zero-row outcomes are not saved as result rows and are not charged as custom GPT listing events.

### ⚠️ Limits and caveats

- The Actor returns public marketplace facts that ChatGPT exposes at run time.
- Search phrase discovery uses public search discovery, then enriches accepted rows from ChatGPT public listing details.
- Source-native metrics can be missing, delayed, rounded, or unavailable for some listings.
- The Actor does not infer popularity, category, sentiment, recommendation quality, or review meaning.
- The Actor does not use your private ChatGPT or OpenAI account state.

### ❓ FAQ

#### 🔐 Do I need a ChatGPT login?

No. The Actor is designed for public custom GPT listings and does not ask for ChatGPT cookies, an OpenAI API key, or a private token.

#### 🎯 Can I scrape one known GPT?

Yes. Paste the public GPT listing URL in `GPT marketplace targets`. Direct listing targets return one matching row when the listing is public and available.

#### 🔎 Can I search for GPTs by keyword?

Yes. Add a plain search phrase such as `data analysis`, `sales assistant`, or `seo`. The Actor discovers matching public custom GPT listings and then saves source-backed listing details.

#### 📭 Why are some fields null?

ChatGPT does not expose every field for every public listing. The Actor keeps unavailable facts as `null` or empty arrays instead of guessing.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~chatgpt-marketplace-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Chrome Extensions Scraper ↗](https://apify.com/maximedupre/chrome-extensions-scraper) - Export Chrome Web Store extension listings for app and tool research.
- [Product Hunt Scraper ↗](https://apify.com/maximedupre/product-hunt-scraper) - Collect startup launch data, rankings, reviews, and website enrichment.
- [RapidAPI Scraper ↗](https://apify.com/maximedupre/rapidapi-scraper) - Search RapidAPI marketplace listings and enrich public API profiles.
- [G2 Products Scraper ↗](https://apify.com/maximedupre/g2-products-scraper) - Collect public software product, rating, review, and vendor data from G2.
- [Apple App Store Scraper ↗](https://apify.com/maximedupre/apple-app-store-scraper) - Export public iOS app metadata, charts, ratings, and reviews.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter public ChatGPT GPT listing URLs, marketplace page URLs, search phrases, category names, or tag names.

## `sortBy` (type: `string`):

Choose the source order for search, category, tag, and marketplace page targets.

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

Limit accepted custom GPT listings from each search, category, tag, or marketplace page target.

## Actor input object example

```json
{
  "targets": [
    "https://chatgpt.com/g/g-2fkFE8rbu-dall-e",
    "data analysis",
    "productivity",
    "sales",
    "customer support"
  ],
  "sortBy": "relevance",
  "maxItems": 75
}
```

# Actor output Schema

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

Open the dataset with one row for each saved public custom GPT marketplace listing.

# 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 = {
    "targets": [
        "https://chatgpt.com/g/g-2fkFE8rbu-dall-e",
        "data analysis",
        "productivity",
        "sales",
        "customer support"
    ],
    "maxItems": 75
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/chatgpt-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 = {
    "targets": [
        "https://chatgpt.com/g/g-2fkFE8rbu-dall-e",
        "data analysis",
        "productivity",
        "sales",
        "customer support",
    ],
    "maxItems": 75,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/chatgpt-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 '{
  "targets": [
    "https://chatgpt.com/g/g-2fkFE8rbu-dall-e",
    "data analysis",
    "productivity",
    "sales",
    "customer support"
  ],
  "maxItems": 75
}' |
apify call maximedupre/chatgpt-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ChatGPT Marketplace Scraper",
        "description": "Scrape public ChatGPT GPT marketplace listings from URLs, search phrases, categories, or tags. Export GPT names, descriptions, creators, verification, categories, capabilities, usage metrics, images, and listing context.",
        "version": "0.0",
        "x-build-id": "xSAjSriBZYdJkeLhP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~chatgpt-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-chatgpt-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/maximedupre~chatgpt-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-chatgpt-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/maximedupre~chatgpt-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-chatgpt-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",
                "required": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "GPT marketplace targets",
                        "minItems": 1,
                        "maxItems": 100,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Enter public ChatGPT GPT listing URLs, marketplace page URLs, search phrases, category names, or tag names.",
                        "items": {
                            "type": "string",
                            "minLength": 1,
                            "maxLength": 500
                        }
                    },
                    "sortBy": {
                        "title": "Discovery order",
                        "enum": [
                            "relevance",
                            "popular",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Choose the source order for search, category, tag, and marketplace page targets.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Maximum GPTs per discovery target",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Limit accepted custom GPT listings from each search, category, tag, or marketplace page target.",
                        "default": 75
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```