# Fast ChatGPT Scraper - No Token Limits (`dxbear/chatgpt-scraper`) Actor

Bypass ChatGPT API limits! Scrape unlimited AI responses to generate content, summarize text, and extract data. Zero token costs, no rate limits. just endless AI power for your automation needs.

- **URL**: https://apify.com/dxbear/chatgpt-scraper.md
- **Developed by:** [Dxbear](https://apify.com/dxbear) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.00 / 1,000 response generateds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Fast ChatGPT Scraper - No Token Limits | Unlimited AI Responses

### 🚀 Overview
#### **No more per-token fees!**

With the **Fast ChatGPT Scraper**, enjoy unlimited AI responses without unpredictable costs or API limits. Extract data, summarize documents, or create bulk content automatically—**no token counting needed!**

#### **Why choose this tool?**

-   **Flat-Rate Pricing:** Pay a set price for successful responses.
    
-   **Easy Data Extraction:** Grab emails, names, prices, and details from messy text.
    
-   **Quick Summaries:** Transform long articles and reports into concise summaries.
    
-   **Bulk Content Creation:** Generate SEO articles, product descriptions, and outreach messages.

### 🛠️ How to Use the Actor

Getting started is incredibly simple. You can run the actor directly in the Apify Console or integrate it into your automated workflows.

**To run it in the Apify Console:**

1.  Go to the **Input** tab of the actor.
2.  Enter your prompt in the text area. Be specific about your task—whether it's extracting data, summarizing, or writing content.
3.  Click **Start** and let the AI generate your response.
4.  View and export your results from the **Dataset** tab.

**Sample Input:**

    {
	    "prompt": "Extract emails from this text :"
    }

**Integrate and Automate:** You don't have to run this actor manually. You can easily integrate it into your existing systems using:

-   **Apify API:** Programmatically trigger the actor and fetch results directly in your own applications or scripts.
-   **MCP Server:** Connect the actor directly to AI agents and clients (like Claude Desktop) using the Model Context Protocol for seamless tool-calling.
-   **Apify Integrations:** Connect the actor to your favorite tools using Zapier, Make, or webhook automations, or chain it with other Apify actors (like web scrapers) to process data on autopilot.


### 💲 Pricing

No more unpredictable API bills! This actor uses a simple **Pay-per-event** model. You are only charged when a successful `chat-response` is generated—meaning you never pay for failed requests, errors, or tokens.

**Cost per successful AI response:**

-   **No discount:** $0.01 per response ($10.00 per 1,000 responses)
-   **Bronze discount:** $0.008 per response ($8.00 per 1,000 responses)
-   **Silver discount:** $0.007 per response ($7.00 per 1,000 responses)
-   **Gold discount:** $0.006 per response ($6.00 per 1,000 responses)

_Note: Discounts are automatically applied based on your active Apify monthly plan._

### 👥 Who Can Use This Actor & What You Can Do With It

**Who can use this actor:**

-   **Marketers & SEOs:** Generate bulk product descriptions, ad copy, and meta tags without worrying about API costs.
-   **Data Analysts & Researchers:** Pull specific data from messy text, summarize long reports, and organize information fast.
-   **Developers & Automation Experts:** Add smart AI to your apps and scripts without managing API keys or token limits.
-   **Content Creators & Writers:** Beat writer's block by generating drafts, social media posts, and article outlines instantly.
-   **Lead Generation Teams:** Extract contact details like emails and phone numbers from scraped web pages at scale.

**What you can do with this actor:**

-   **Extract Data:** Pull out emails, names, prices, or addresses from unstructured text.
-   **Summarize Text:** Turn long articles, documents, or scraped web pages into short, easy-to-read bullet points.
-   **Write Content:** Create blog posts, outreach emails, product descriptions, and social media captions in bulk.
-   **Rewrite & Format:** Fix grammar, change the tone of voice, or turn messy text into clean data tables.
-   **Categorize & Tag:** Sort support tickets, analyze sentiment, or label large lists of data automatically.

### ❓ FAQ

**Can it search the internet?** No. This actor generates responses based only on the prompt you provide. It does not browse the web or search for real-time information.

**What AI model does it use?** It uses the powerful GPT-4 model to deliver high-quality, intelligent responses.

**Do you charge per token?** No! You can use as many tokens as you need for your prompt and the AI's output. You are only charged a flat rate per successful chat response.

**Can I have chat history or a continuous conversation?** No. This actor is designed for single tasks. It processes one prompt and gives one response. It does not remember previous prompts or keep a chat history.


### 🛟 Support

If you encounter any issues or the actor throws an error, **it is very important that you let me know** so I can fix it as quickly as possible!

Please don't just retry and hope for the best—report the problem so I can ensure the actor runs smoothly for you and everyone else.

You can reach out through either of these two ways:

-   **Submit an Issue:** Click on the **Issues** tab on this actor's Apify page and create a new ticket.
-   **Email Me Directly:** Send the details of the error to **[ahmed@scravity.com](mailto:ahmed@scravity.com)**

When reporting, please include your Run ID and a brief description of what went wrong. I'll get it sorted out for you!

# Actor input Schema

## `prompt` (type: `string`):

Enter your prompt here [Extract emails from:, Summarize this tesxt: Write article about].

## Actor input object example

```json
{
  "prompt": "Your example prompt here..."
}
````

# 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 = {
    "prompt": "Your example prompt here..."
};

// Run the Actor and wait for it to finish
const run = await client.actor("dxbear/chatgpt-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 = { "prompt": "Your example prompt here..." }

# Run the Actor and wait for it to finish
run = client.actor("dxbear/chatgpt-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 '{
  "prompt": "Your example prompt here..."
}' |
apify call dxbear/chatgpt-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fast ChatGPT Scraper - No Token Limits",
        "description": "Bypass ChatGPT API limits! Scrape unlimited AI responses to generate content, summarize text, and extract data. Zero token costs, no rate limits. just endless AI power for your automation needs.",
        "version": "1.0",
        "x-build-id": "RymwK8ozG2nfMf2kF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dxbear~chatgpt-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dxbear-chatgpt-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/dxbear~chatgpt-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dxbear-chatgpt-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/dxbear~chatgpt-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dxbear-chatgpt-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": [
                    "prompt"
                ],
                "properties": {
                    "prompt": {
                        "title": "Prompt",
                        "type": "string",
                        "description": "Enter your prompt here [Extract emails from:, Summarize this tesxt: Write article about]."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
