Provides a ChatGPT query tool that sends a prompt anonymously and returns ChatGPT's answer as markdown, along with the web sources it consulted, conversation title, model, and whether web search was used, without requiring an OpenAI account or API key.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ChatGPT MCP Server Ask ChatGPT what the Artemis program's current status is and cite its sources."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A hosted Model Context Protocol (MCP) server that gives Claude, Cursor, Windsurf and any other MCP client one ChatGPT tool. Send a prompt anonymously and get the answer back as markdown together with the web pages ChatGPT consulted, as structured JSON, with no OpenAI account and no API key of your own.
1,000 free credits every month, no card required, which is 100 prompts.
https://mcp.hasdata.com/mcp?apis=chatgpt
Related MCP server: apexapi-mcp
An MCP client and a HasData API key from the dashboard, free to create with no card, and the free tier covers 100 calls a month at the 10-credit rate. This is a remote server, so the simplest path is a URL and an x-api-key header, with no container to run and no OpenAI billing anywhere in the flow. A client that only speaks stdio reaches it through a thin launcher, published as @hasdata/chatgpt-mcp on npm and hasdata-chatgpt-mcp on PyPI, shown below.
The server URL is the same for every client. We run it hands-on in Claude Code and Claude Desktop. The other blocks follow each client's own documented format for a remote server.
Field | Value |
URL |
|
Transport | HTTP, streamable |
Auth header |
|
Clients with OAuth support can add the same URL as a connector and sign in without putting a key in a config file.
claude mcp add --transport http chatgpt "https://mcp.hasdata.com/mcp?apis=chatgpt" \
--header "x-api-key: HASDATA_API_KEY"{
"mcpServers": {
"chatgpt": {
"type": "http",
"url": "https://mcp.hasdata.com/mcp?apis=chatgpt",
"headers": { "x-api-key": "HASDATA_API_KEY" }
}
}
}{
"mcpServers": {
"chatgpt": {
"type": "streamable-http",
"url": "https://mcp.hasdata.com/mcp?apis=chatgpt",
"headers": { "x-api-key": "HASDATA_API_KEY" }
}
}
}{
"servers": {
"chatgpt": {
"type": "http",
"url": "https://mcp.hasdata.com/mcp?apis=chatgpt",
"headers": { "x-api-key": "HASDATA_API_KEY" }
}
}
}Prompts, not code. Paste one in and the agent picks the tool itself. Each is annotated with the calls it takes, because every successful call costs 10 credits.
Ask ChatGPT what the current state of the Artemis program is, and list the sources it used.
One call, 10 credits. The answer and the sources come back together.
Ask ChatGPT the same question in German.
One call, 10 credits. The answer follows the language of the prompt, so write the prompt in the language you want back.
Ask ChatGPT what happened in AI this week, with Berlin as the current date.
One call, 10 credits. timezone is what fixes the meaning of "this week".
Put the same question to ChatGPT three times and show where the answers differ.
Three calls, 30 credits. Each request is a fresh conversation, so there is no carry-over between them.
Tool | What it returns |
| The answer as markdown, the web sources ChatGPT consulted with their domain and title, the conversation title it generated, the model that answered, and whether a web search was used. 10 credits a call |
One tool, 10 credits per successful call.
hasdata_chatgpt_chat_getChatgptAnswer
Parameter | Type | Required | Notes |
| string | yes | The question or instruction, up to 8000 characters |
| string | IANA zone name such as |
Everything lands under conversation. The answer is in answer as markdown, with title holding the name ChatGPT generated for the thread, model the model that answered, and usedWebSearch saying whether it went to the web at all. finishReason and complete tell a truncated answer from a finished one.
{
"conversation": {
"answer": "As of **October 5, 2026**, NASA's Artemis program has made substantial progress…",
"title": "Artemis developments cited",
"model": "gpt-5-6",
"usedWebSearch": true,
"finishReason": "stop",
"complete": true,
"sources": [
{ "title": "Artemis News - NASA", "url": "https://www.nasa.gov/artemis-news/", "domain": "www.nasa.gov" }
]
}
}Your client almost never sees an HTTP error code from a tool call. The MCP layer answers 200 and puts the failure inside the result, with isError set to true and the reason as text.
sources is uneven, and partly absent. In a measured answer carrying twenty sources, every one had title, url and domain, eleven had publishedDate and only five had snippet. Read each field defensively rather than assuming the shape of the first element holds for the rest.
No web search means no sources. usedWebSearch is false when ChatGPT answers from the model alone, and sources is then empty or missing. A prompt about a stable fact often takes that path, so ask for current information when citations are the point.
Every call is a fresh conversation. There is no memory between requests, so a follow-up has to carry its own context in the prompt. conversationId identifies the thread that answered, not a thread you can continue.
A truncated answer still succeeds. Check complete and finishReason before treating answer as the whole response.
Each successful call spends credits from the connected account. A call that fails validation is not billed.
The ChatGPT tool costs 10 credits per successful call. Answer length does not change the price.
The free tier is 1,000 credits every month with no card, which is 100 prompts.
Paid plans start at $59 a month for 200,000 credits, which is 20,000 calls. The unit price falls on larger plans. Current numbers are on the plans page.
OpenAI API | This server | |
Account | Your own OpenAI account and billing | One HasData key |
What you get | The model's answer | The answer plus the web sources behind it |
Web search | A separate tool you wire up | Included, with |
Output | Your own schema | Parsed JSON with the sources already split out |
The two are not substitutes. The OpenAI API is the right call when you need system prompts, tools, streaming and conversation state. This server is the right call when you want what ChatGPT publicly answers, with its citations, and no account of your own.
No. The server answers anonymously through HasData, and the only credential involved is your HasData key.
Whichever ChatGPT serves anonymously at the time. The response reports it in model, so read it rather than assuming. A measured call returned gpt-5-6.
No. Each request is a fresh thread with no memory of earlier ones. Carry the context in the prompt instead.
The language of the prompt. Ask in German and the answer comes back in German, or ask explicitly for a language in the prompt.
No. HasData is an independent web data provider and is not affiliated with, endorsed by or sponsored by OpenAI. All trademarks belong to their owners.
The server reads what ChatGPT answers publicly to an anonymous visitor. It does not log in, and it does not reach private conversations or account data.
Product page and request builder | |
Endpoint documentation | |
Server documentation | |
Every tool in one server | |
Client walkthroughs | |
Plans and credit costs |
npm install
npm testThe tests in test/ assert the tool contract, the part that can break without a commit here. They check that ?apis=chatgpt returns the one expected tool, that its name and required parameter have not changed, that it carries a description, and that a real call still puts the answer under conversation.
The parameter table and the sample above were read from the live schema and from real calls rather than from documentation. A correction is welcome when a field or a failure mode has changed. Open an issue with the response you saw.
MIT
Get ChatGPT Answer
Sends a prompt to ChatGPT anonymously and returns the answer as markdown text, plus every web source ChatGPT consulted with its domain, page title, snippet, publication date and thumbnail, the links rendered inside the answer, the conversation title ChatGPT generated, the model that answered, and whether a web search was used. The language of the answer follows the prompt — write the prompt in the language you want back, or ask for one in it. Set the frame of reference for words like "today" with timezone. Each request is a fresh conversation with no memory of earlier ones. Use to answer questions with cited sources, to ground an agent or RAG pipeline in ChatGPT's web-search results, to summarise current events with their sources, or to build datasets of model answers.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | The question or instruction to send to ChatGPT, up to 8000 characters. A prompt that asks about recent events makes ChatGPT search the web and return sources; a general-knowledge prompt is answered from the model alone. The prompt also decides the language of the answer — write it in the language you want back, or ask for one explicitly ("Antworte auf Deutsch"). | |
| timezone | No | IANA time zone name, for example `America/Chicago` or `Europe/Berlin`. It sets what ChatGPT treats as the current date and time, which matters for prompts that say "today", "this week" or "latest". |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so safety is covered; the description goes well beyond that by disclosing statelessness (no memory of earlier requests), that language follows the prompt, that web search is conditionally triggered, and that every consulted source is returned with full metadata. This is meaningful behavioral context an agent needs to invoke it correctly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The opening sentence is a dense list of return fields, then usage guidance follows, so it is reasonably front-loaded and every sentence carries information. It is close to the upper bound of comfortable length for a two-parameter tool, costing a point against truly tight prose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, yet the description fully specifies the return payload (answer, sources with metadata, links, title, model, search flag), plus behavior and usage. Nothing an agent needs to select or call the tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are already fully documented in the schema (character limit, language behavior, IANA timezone framing). The description restates the language and timezone semantics but adds no syntax or format detail beyond what the structured fields already provide, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (send a prompt to ChatGPT, get the answer) and then enumerates exactly what comes back: markdown answer, web sources with domain/title/snippet/date/thumbnail, inline links, conversation title, model, and search flag. An agent can tell this is a prompt-to-answer Q&A tool rather than a SERP scraper without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete use cases (answer questions with cited sources, ground a RAG pipeline, summarise current events, build datasets) and a key constraint ('a fresh conversation with no memory of earlier ones'). It does not explicitly name the most obvious alternative, hasdata_perplexity_chat_getPerplexityAnswer, or state when not to use it, so it falls short of full when/when-not/alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0hasdata_chatgpt_chat_getChatgptAnswerScored across 1 tool
There is only one tool, so there is no possibility of confusing it with another. Its purpose (send a prompt to ChatGPT and return the answer plus sources) is unambiguous.
With a single tool there is no mixed convention to penalize. However, the name is an unwieldy prefixed, camelCase string (hasdata_chatgpt_chat_getChatgptAnswer) rather than a clean verb_noun pattern.
The narrow, single-endpoint domain means one tool covers the core capability without redundancy. Still, a one-tool surface is thin and leaves no room for related operations like continuing a conversation or fetching sources separately.
The tool covers a one-shot query with rich metadata, which fits the described use. But it explicitly has no memory, and there is no way to continue or manage a conversation, so multi-turn workflows are a notable gap.
Live AI-native web search with citations. One tool for every MCP client. Flat per-request pricing.
Google AI Overview answers and cited sources via the Apify Google AI Overview API, hosted MCP.
Read-only hosted MCP over CanonicAI's cited Answers corpus on canonicai.com.
Generate contextual prompts and reusable agent skills, evaluate prompts with the 16-dimension Prompt Score, and manage saved work in PromptDrive. Twelve MCP tools also provide authorized access to private Memory for source-grounded answers. Connect over Streamable HTTP using OAuth 2.1 and PKCE. Generation consumes account quota and automatically saves successful results; Memory access follows account permissions and plan limits.
