# Programming Q\&A Search MCP Server (`mrbridge/dev-communities-mcp`) Actor

Programming Q\&A MCP server for Claude, ChatGPT, Cursor and other AI agents. Search Stack Overflow and other Stack Exchange sites, find questions similar to your error, and read accepted and top answers with code, each credited to its author under CC BY-SA. 10 read-only tools.

- **URL**: https://apify.com/mrbridge/dev-communities-mcp.md
- **Developed by:** [MrBridge](https://apify.com/mrbridge) (community)
- **Categories:** MCP servers, AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 read operations

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 💬 Programming Q\&A Search MCP Server

Programming Q\&A Search MCP Server is an MCP server that lets Claude, ChatGPT, Cursor, VS Code and other AI agents search Stack Overflow and the other sites of the Stack Exchange network, then read a question with its accepted and top answers. Its 10 read-only tools cover keyword search, similar questions for an error message, related questions, the classic questions of a tag, tag facts and the list of network sites, plus the search and fetch pair that ChatGPT deep research uses.

Paste an error such as "TypeError: Cannot read properties of undefined (reading 'map')" and ask Claude whether someone already solved it. It calls `devcom_find_similar_questions`, then `devcom_get_question` on the best match, and answers with the accepted fix, code blocks kept, and a link to each post with its author's name. No Stack Exchange account or key is needed, only your Apify token.

### Quick start

1. Copy your API token from [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge).
2. Add `https://mrbridge--dev-communities-mcp.apify.actor/mcp` to your AI client with the header `Authorization: Bearer <token>`. The Connect section below has a ready-made snippet for each client.
3. Ask a question such as "what are the most frequently asked questions about pandas groupby?"

### What this server exposes

This server answers developer questions from Stack Overflow and the other sites of the Stack Exchange network (Super User, Server Fault, Ask Ubuntu, Unix & Linux, Mathematics and many more), read through the public Stack Exchange API 2.3. It has 8 read-only tools with the `devcom_` prefix: keyword search, similar questions for a title or an error message, one question with its accepted and top answers (code blocks kept), related and linked questions (see "Question text and linked questions" below), the classic questions of a tag, tag facts and wiki, tag name search, and the list of network sites with their codes. It also has the `search` and `fetch` pair that ChatGPT deep research expects, over Stack Overflow. You need no Stack Exchange account or key. Each question and answer comes back with its author's name, a link to the author's profile, a link to the post and its CC BY-SA licence.

### Tools

| Tool | What it answers | Billed event |
|---|---|---|
| `devcom_search_questions` | Search developer questions | `tool-read` |
| `devcom_find_similar_questions` | Find questions similar to a title | `tool-read` |
| `devcom_get_question` | Get a question with its answers | `tool-read` |
| `devcom_get_related_questions` | Questions related to a question | `tool-read` |
| `devcom_top_questions_for_tag` | Top questions of a tag | `tool-read` |
| `devcom_get_tag` | Get a tag and its wiki | `tool-read` |
| `devcom_search_tags` | Search tag names | `tool-read` |
| `devcom_list_sites` | List Stack Exchange sites | `tool-read` |
| `search` | Search | `tool-read` |
| `fetch` | Fetch | `tool-read` |

#### `devcom_search_questions`: Search developer questions

Use this when you need questions and answers about a programming error, an API, a tool or a concept on Stack Overflow or another Stack Exchange site, by keywords. Returns question titles, links, scores, answer counts, whether an answer was accepted, the author and the licence of each question. Do not use for one known question (use devcom_get_question), for finding duplicates of a question title (use devcom_find_similar_questions) or for the classic questions of a tag (use devcom_top_questions_for_tag). Parameters: `query` (string, e.g. "python asyncio event loop is closed"), `tags` (up to 5 tag names, questions carry at least one of them, e.g. \["python"]), `accepted_only` (boolean, default false), `min_answers` (0-100), `sort` ("relevance" default, "votes", "newest", "active"), `site` (default "stackoverflow"), `limit` (1-50, default 10), `offset` (multiple of limit, default 0), `response_format` ("concise" default, "detailed" adds views, last activity and cache).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"python asyncio event loop is closed"` |
| `tags` | array of string | no | `["python"]` |
| `accepted_only` | boolean | no | `true` |
| `min_answers` | integer | no | `1` |
| `sort` | "relevance" or "votes" or "newest" or "active" | no | `"relevance"` |
| `site` | string | no | `"stackoverflow"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, site, results[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `devcom_find_similar_questions`: Find questions similar to a title

Use this when you have a question title or a one-line problem statement and want to know whether it was already asked on Stack Overflow or another Stack Exchange site, as the site suggests on its ask page. Returns the most similar questions first, with links, scores, answer counts, author and licence. Do not use for keyword search with filters (use devcom_search_questions) or for the questions related to a known question id (use devcom_get_related_questions). Parameters: `title` (string, e.g. "TypeError: Cannot read properties of undefined (reading 'map')"), `tags` (up to 5 preferred tags, e.g. \["reactjs"]), `site` (default "stackoverflow"), `limit` (1-30, default 10), `offset` (multiple of limit, default 0), `response_format` ("concise" default or "detailed").

| Parameter | Type | Required | Example |
|---|---|---|---|
| `title` | string | yes | `"TypeError: Cannot read properties of undefined (reading 'map')"` |
| `tags` | array of string | no | `["reactjs"]` |
| `site` | string | no | `"stackoverflow"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ title, site, results[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `devcom_get_question`: Get a question with its answers

Use this when you need how a Stack Overflow or other Stack Exchange question was answered: the accepted answer and the top voted answers with code blocks kept, and the question text when Stack Exchange sends it (otherwise question.body is null and `notice` gives its link). Accepts a question id, a question URL or an answer URL (that answer is then shown first). Each post comes with its author, links and licence. Do not use for searching (use devcom_search_questions) or for listing related questions (use devcom_get_related_questions). Parameters: `question` (id or URL, e.g. "11227809" or "https://stackoverflow.com/a/11227902"), `site` (default "stackoverflow", a URL sets it), `max_answers` (0-5, default 3, top voted answers, the accepted one is always added), `response_format` ("concise" default with answers cut at about 6,000 characters and the question at 4,000, "detailed" answers up to 10,000 and the question up to 15,000, with views and dates).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `question` | string | yes | `"11227809"` |
| `site` | string | no | `"stackoverflow"` |
| `max_answers` | integer | no | `3` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ site, question, answers[], focus_answer_id, answers_shown, answers_total, notice, attribution }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `devcom_get_related_questions`: Questions related to a question

Use this when you know a question (id or URL) and want the questions the site lists as related to it, or the questions that link to it (often duplicates and follow-ups). Returns questions with links, scores, answer counts, author and licence. Do not use for the question itself and its answers (use devcom_get_question) or for free-text search (use devcom_search_questions). Parameters: `question` (id or question URL, e.g. "11227809"), `relation` ("related" default, or "linked" for questions that link to it, refused by Stack Exchange on 2026-10-13), `site` (default "stackoverflow", a URL sets it), `limit` (1-30, default 10), `offset` (multiple of limit, default 0), `response_format` ("concise" default or "detailed").

| Parameter | Type | Required | Example |
|---|---|---|---|
| `question` | string | yes | `"11227809"` |
| `relation` | "related" or "linked" | no | `"related"` |
| `site` | string | no | `"stackoverflow"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ question_id, relation, site, results[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `devcom_top_questions_for_tag`: Top questions of a tag

Use this when you want the classic, frequently asked, top voted, trending or newest questions about a technology, given its tag names on Stack Overflow or another Stack Exchange site. Returns questions carrying all the given tags, with links, scores, answer counts, author and licence. Do not use for keyword search (use devcom_search_questions) or for facts about the tag itself (use devcom_get_tag). Parameters: `tags` (1 to 5 tag names, all required, e.g. \["python", "pandas"]), `ranking` ("frequent" default: the frequently asked questions, "votes" all-time top, "week", "month", "hot", "newest", "active"), `site` (default "stackoverflow"), `limit` (1-50, default 10), `offset` (multiple of limit, default 0), `response_format` ("concise" default or "detailed").

| Parameter | Type | Required | Example |
|---|---|---|---|
| `tags` | array of string | yes | `["python","pandas"]` |
| `ranking` | "frequent" or "votes" or "week" or "month" or "hot" or "newest" or "active" | no | `"frequent"` |
| `site` | string | no | `"stackoverflow"` |
| `limit` | integer | no | `10` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ tags[], ranking, site, results[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `devcom_get_tag`: Get a tag and its wiki

Use this when you need to know what a tag covers on Stack Overflow or another Stack Exchange site: its usage guidance (the tag wiki excerpt), how many questions it has, and in detailed mode the full wiki and the tags most used with it. Do not use for finding a tag name from a word (use devcom_search_tags) or for the questions of a tag (use devcom_top_questions_for_tag). Parameters: `tag` (exact tag name, e.g. "python" or "c#"), `site` (default "stackoverflow"), `response_format` ("concise" default, "detailed" adds the full wiki and related tags with one or two more upstream calls, and the last activity date when Stack Exchange sends one).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `tag` | string | yes | `"python"` |
| `site` | string | no | `"stackoverflow"` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ site, tag, question_count, has_synonyms, moderator_only, required, url, info_url, excerpt, wiki, wiki_truncated, related_tags[], last_activity, attribution }`. Upstream: Stack Exchange API. Cache: daily (1 day). Read-only.

#### `devcom_search_tags`: Search tag names

Use this when you need the exact tag name for a technology on Stack Overflow or another Stack Exchange site, or the most used tags containing a word. Returns tag names containing the text, with their question counts and links. Do not use for what a known tag covers (use devcom_get_tag) or for questions (use devcom_search_questions). Parameters: `query` (part of the tag name, e.g. "react"), `sort` ("popular" default, "activity", "name"), `site` (default "stackoverflow"), `limit` (1-50, default 20), `offset` (multiple of limit, default 0), `response_format` ("concise" default, "detailed" adds synonyms, moderator-only and required flags, and the last activity date when Stack Exchange sends one).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"react"` |
| `sort` | "popular" or "activity" or "name" | no | `"popular"` |
| `site` | string | no | `"stackoverflow"` |
| `limit` | integer | no | `20` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ site, query, tags[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: daily (1 day). Read-only.

#### `devcom_list_sites`: List Stack Exchange sites

Use this when you need to know which Stack Exchange site covers a topic (Unix, mathematics, databases, security, cooking...), or the site code to pass as `site` to the other tools. Returns site codes, names, addresses and audiences, main sites only unless `include_meta` is true. Do not use for questions or tags (use devcom_search_questions or devcom_search_tags). Parameters: `query` (optional text in the name, code, address or audience, e.g. "linux"), `include_meta` (boolean, default false), `limit` (1-100, default 25), `offset` (default 0), `response_format` ("concise" default, "detailed" adds state, type, launch date and aliases).

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | no | `"linux"` |
| `include_meta` | boolean | no | `false` |
| `limit` | integer | no | `25` |
| `offset` | integer | no | `0` |
| `response_format` | "concise" or "detailed" | no | `"concise"` |

Returns `{ query, sites[], pagination, attribution }`. Upstream: Stack Exchange API. Cache: daily (1 day). Read-only.

#### `search`: Search

Use this when ChatGPT needs to find Stack Overflow questions about a programming problem for research. Returns up to 8 questions with ids for fetch and their URLs. Do not use for other Stack Exchange sites or for paging through results (use devcom_search_questions). Parameter `query` (string), e.g. "python asyncio event loop is closed".

| Parameter | Type | Required | Example |
|---|---|---|---|
| `query` | string | yes | `"python asyncio event loop is closed"` |

Returns `{ results[], notices[] }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

#### `fetch`: Fetch

Use this when ChatGPT needs one question returned by search as text: its accepted answer and two top voted answers, and the question text when Stack Exchange sends it, each post credited to its author with its licence. Do not use for ids that did not come from search, other than a question id or a question URL. Parameter `id`, e.g. "stackoverflow:11227809", "11227809" or a question URL.

| Parameter | Type | Required | Example |
|---|---|---|---|
| `id` | string | yes | `"stackoverflow:11227809"` |

Returns `{ id, title, text, url, metadata, notices[] }`. Upstream: Stack Exchange API. Cache: hourly (1 hour). Read-only.

### Connect

Endpoint (Streamable HTTP): `https://mrbridge--dev-communities-mcp.apify.actor/mcp`

Every client authenticates with your Apify API token, found in [Apify Console > Settings > API & Integrations](https://console.apify.com/settings/integrations?fpr=mrbridge). Clients that support custom headers send it as `Authorization: Bearer <token>`. The others use the `?token=` URL variant, which must be treated as a secret: keep it out of commits, screenshots and shared logs.

#### Claude Code

```bash
claude mcp add --transport http dev-communities "https://mrbridge--dev-communities-mcp.apify.actor/mcp" --header "Authorization: Bearer ${APIFY_TOKEN}"
```

#### Cursor, VS Code and other JSON configurations

```json
{
  "mcpServers": {
    "dev-communities": {
      "type": "http",
      "url": "https://mrbridge--dev-communities-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### claude.ai and Claude Desktop

Add a custom connector with the URL `https://mrbridge--dev-communities-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN` and no authentication. Prefilled link (replace the token placeholder before saving): [add Programming Q\&A Search MCP Server to Claude](https://claude.ai/customize/connectors?modal=add-custom-connector\&connectorName=Programming%20Q%26A%20Search%20MCP%20Server\&connectorUrl=https%3A%2F%2Fmrbridge--dev-communities-mcp.apify.actor%2Fmcp%3Ftoken%3DYOUR_APIFY_TOKEN).

#### ChatGPT (developer mode)

Settings > Apps > Create, URL `https://mrbridge--dev-communities-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN`, authentication "No authentication". ChatGPT snapshots the tool list: after a server update, an admin has to click Refresh on the app.

#### OpenAI Responses API

```json
{
  "type": "mcp",
  "server_label": "dev_communities",
  "server_url": "https://mrbridge--dev-communities-mcp.apify.actor/mcp",
  "headers": {
    "Authorization": "Bearer YOUR_APIFY_TOKEN"
  },
  "require_approval": "never"
}
```

Add `allowed_tools` to restrict the tool list. Tool calls must finish within about 60 seconds on this API, and every tool of this server answers in under 50 seconds.

#### Anthropic Messages API

```json
{
  "mcp_servers": [
    {
      "type": "url",
      "url": "https://mrbridge--dev-communities-mcp.apify.actor/mcp",
      "name": "dev-communities",
      "authorization_token": "YOUR_APIFY_TOKEN"
    }
  ],
  "tools": [
    {
      "type": "mcp_toolset",
      "mcp_server_name": "dev-communities"
    }
  ]
}
```

Send the beta header `anthropic-beta: mcp-client-2025-11-20`.

#### One-click OAuth alternative

`https://mcp.apify.com/?tools=mrbridge/dev-communities-mcp` connects through Apify OAuth without a token. It exposes the Actor as a single tool rather than the granular tools listed above.

#### Cost control

Each Standby run has a spending limit (`maxTotalChargeUsd`). When a call uses the last of it, the result is still returned, and later calls in that run answer `CHARGE_LIMIT_REACHED` until the limit is raised.

### Why use Programming Q\&A Search MCP Server

- **Answers, not links.** One call returns a question with its accepted answer and the top voted answers, code blocks kept as Markdown instead of raw HTML.
- **Duplicates from an error message.** The similar-questions tool takes a title or an error line and returns the questions the site itself would suggest.
- **Every site of the network.** Stack Overflow by default, and Super User, Server Fault, Ask Ubuntu, Unix & Linux, Mathematics and the others by code or domain.
- **Tags explained.** What a tag covers, how many questions it has, the tags used with it and its frequently asked questions.
- **Credit built in.** Each post comes with its author's name and profile link, a link to the post and its CC BY-SA licence, as the attribution rules ask.
- **Quota-aware.** Questions are cached for an hour and tags for a day, and when the shared quota runs out you get the cached answer, marked stale, when one exists.

### Pricing (Pay-per-Event)

Programming Q\&A Search MCP Server uses pay-per-event pricing. Each successful tool call is one `tool-read` event at $0.005, so 1,000 answers cost $5 in events. These are the FREE plan prices, and Apify plan discounts lower them. Apify also bills its standard `apify-actor-start` event when a Standby run starts, and you pay the platform usage of your own Standby run on top of the events, as explained below. Calls that end in an error carry no event charge. See the [Pricing tab](https://apify.com/mrbridge/dev-communities-mcp/pricing?fpr=mrbridge) for the price on your Apify plan.

| Event | Charged when | Price |
|---|---|---|
| `apify-actor-start` | run start (platform default) | see the Store page |
| `tool-read` (primary event) | each successful read tool call | see the Store page |

Never charged: initialize, tools/list, pings, readiness probes, and any call that ends in an error (invalid input, not found, upstream failure, timeout, spending limit).

Platform usage comes on top of these events. This server runs in Apify Standby mode, and you also pay the platform usage of your own Standby run, billed to your Apify account like any other run: the memory set for the Standby run, for as long as the server is up, idle time included, until the run stops at its idle timeout.
The [Apify pay-per-event documentation](https://docs.apify.com/actors/publishing/monetize/pay-per-event#platform-usage-costs) says so: "For runs in Standby mode, users always pay the platform usage costs in addition to the event charges."

### Limits, caveats and attribution

- **Attribution.** Questions and answers on the Stack Exchange network are licensed under [CC BY-SA](https://stackoverflow.com/help/licensing) by their authors (version 2.5, 3.0 or 4.0, depending on the date of the revision). Every post in an answer carries `author.name`, `author.profile_url`, its own `url` and its `licence` with `licence_url`. The `attribution` block names the site and the Stack Exchange network as the source. A deleted account has no profile page, so its `profile_url` is null. Keep these fields when you show or reuse the text.
- **Question text and linked questions.** On 2026-10-13, without a key, Stack Exchange sent question 11227809 without its text, while its answers kept theirs. It was the only question read with its text that day, so it is not yet known whether this hits every question. When a question comes without its text, `devcom_get_question` and `fetch` give its title, author, link, tags and counts with `question.body` set to null and a `notice` that links to the question, followed by the accepted and top answers with their code. If no answer comes with it either (`max_answers` 0, or a question without answers), the call ends with `UPSTREAM_SCHEMA_CHANGED`, costs nothing, and gives the link. The same day Stack Exchange answered "no method found" to the method behind `relation: "linked"` of `devcom_get_related_questions`, although its documentation still lists it. Such a call also ends with `UPSTREAM_SCHEMA_CHANGED`, costs nothing, and suggests `relation: "related"` or `devcom_find_similar_questions` instead.
- **Modified text.** Post bodies arrive as HTML. The server turns them into Markdown-style text (code blocks with their language, inline code, links, lists, quotes, tables) and shortens long bodies: about 6,000 characters per answer and 4,000 for the question in `concise` mode, and up to 10,000 per answer and 15,000 for the question in `detailed` mode. `body_truncated` tells you when a body was cut, and the post `url` leads to the full text.
- **Quota.** Without a key, Stack Exchange allows about 300 requests per day for each IP address, and every keyless application on that address draws from the same pool. Apify runs share their addresses, so others may have spent part of it already. The server makes one attempt per request (a retry would spend the quota), caches questions and searches for an hour and tags and sites for a day, and keeps to 15 requests per second and 150 per day per running instance (the count starts again when a new instance starts). When Stack Exchange reports the quota spent, the server stops calling it until the time Stack Exchange gives. Meanwhile a cached answer is returned marked `stale` if one exists, otherwise the call ends with `UPSTREAM_RATE_LIMITED` and costs nothing. `devcom_get_question` uses two requests, up to four when it has to resolve an answer link and fetch the accepted answer separately.
- **Pauses.** When Stack Exchange asks for a pause on one API method (the `backoff` field), the server honours it: cached answers still come back, a short pause is waited out, and a longer one ends the call with `UPSTREAM_RATE_LIMITED`, which costs nothing.
- **No bulk export.** Lists stop at the first 500 results, with at most 50 per call, and `devcom_get_question` reads one question at a time.
- **Pagination.** The API pages by fixed page sizes: `offset` must be a multiple of `limit` (the `next_offset` of the previous answer always is). Totals are not known in advance, so `pagination.total` is a lower bound and `has_more` says whether another page exists.
- **Sites.** Tools default to Stack Overflow. Pass `site` as a code (`superuser`, `unix`, `math`, or the short forms `so`, `su`, `sf`, `au`) or a domain (`unix.stackexchange.com`). `devcom_list_sites` lists the codes, and a question URL sets the site on its own. Codes other than the five best-known ones are checked against the network's site list, read once a day, so a mistyped site costs no question request. `search` and `fetch` cover Stack Overflow only.
- **No affiliation.** Stack Overflow and Stack Exchange are trademarks of Stack Exchange, Inc. This server is not affiliated with or endorsed by Stack Exchange, Inc.

### Data terms

By using this server you agree to reuse what it returns in line with the terms of its source, and to pass the same obligations on to anyone you share it with.

- **Licence.** Questions and answers are licensed under CC BY-SA ([2.5](https://creativecommons.org/licenses/by-sa/2.5/), [3.0](https://creativecommons.org/licenses/by-sa/3.0/) or [4.0](https://creativecommons.org/licenses/by-sa/4.0/), as given for each post). When you reuse a post, name its author with a link to their profile, link to the post, name the licence with its link, say what you changed, and share adapted text under the same licence. The [attribution rules](https://stackoverflow.blog/2009/06/25/attribution-required/) and the [API terms](https://stackoverflow.com/legal/api-terms-of-use) describe these requirements.
- **No AI training.** The [Stack Exchange Acceptable Use Policy](https://stackoverflow.com/legal/acceptable-use-policy) forbids collecting this content to train, test, benchmark or improve AI models without its written consent. Do not use answers from this server for that purpose. The server itself never uses the content to train any model.
- **No bulk collection.** The server does not offer bulk export, and you may not use it to rebuild a copy of a Stack Exchange site.
- **Personal data.** Author names and profile links are personal data under laws such as the GDPR. The server returns them only for attribution and drops every other user field before anything is cached. Use them for attribution only.
- **Source status.** The Acceptable Use Policy also asks for written consent for some uses of its content by other products. Consent for this server was requested from Stack Exchange on 2026-10-06 and has not been answered yet. If Stack Exchange objects, the server will be withdrawn.

The fee for this server pays for the service (hosting, caching, curation, attribution), not for a licence on the content.

### Use cases

- **Debugging in the editor.** Paste a stack trace in Cursor or Claude Code and get the accepted fix from a matching question, with the link to check it.
- **Code review.** "What do the top answers say about mutable default arguments in Python?" before you approve a change.
- **Learning a technology.** "What are the classic questions about Rust lifetimes?" returns the frequently asked questions of the tag.
- **Picking the right tag.** Find the exact tag name and its usage guidance before you post a question yourself.
- **Sysadmin and Linux questions.** Search Server Fault, Ask Ubuntu or Unix & Linux with the same tools.
- **Research with citations.** ChatGPT deep research can search and fetch Stack Overflow questions, each with its link and author.

Answers are community content, credited to their authors under CC BY-SA. Read them and quote them with credit, but do not use them to train AI models or to rebuild a copy of a site.

### FAQ

#### Why is the first call slower?

The server runs in Apify Standby mode. When no request comes in for a while, the run stops at its idle timeout, and the next call starts a new one. On the servers of this family that cold start takes about 4 to 8 seconds. Calls made while the server is warm skip the delay.

#### Do I need a Stack Exchange account or API key?

No. The server reads the public Stack Exchange API without a key.

#### Why do some calls answer UPSTREAM_RATE_LIMITED?

Without a key, Stack Exchange allows about 300 requests a day per IP address, shared by every keyless application on that address, and cloud platforms share their addresses. The server caches answers and keeps to half of that pool, but heavy use can still exhaust it. You then get a cached answer marked stale when one exists, or `UPSTREAM_RATE_LIMITED` with no event charge. Try again later.

#### Which sites are covered?

Every site of the Stack Exchange network: pass its code or domain, or a question URL. Tools default to Stack Overflow, and the ChatGPT search and fetch pair covers Stack Overflow only.

#### Can I reuse the answers?

Yes, under CC BY-SA: keep the author's name and profile link, the link to the post and the licence, say what you changed, and share adaptations under the same licence. The Data terms section above has the details. Do not use the content to train or improve AI models.

#### Is this an official Stack Overflow service?

No. It is an independent server built on the public Stack Exchange API, not affiliated with or endorsed by Stack Exchange, Inc.

#### Your feedback

Found a bug or a wrong answer? Open an issue on the [Issues tab](https://apify.com/mrbridge/dev-communities-mcp/issues?fpr=mrbridge). Programming Q\&A Search MCP Server is built by MrBridge. More servers are listed in the [MCP server catalogue](https://mr-bridge.com/mcp-servers), and more tools and data studies are at [mr-bridge.com](https://mr-bridge.com).

### Changelog

- 0.1.5: Output, dataset and key-value store schemas, as Apify asks for publication: the Output tab of a run started from the Console shows the connection details and one row per tool.
- 0.1.4: the Input tab shows the endpoint and how to connect an AI client, and a run started from the Console outputs the connection details and the tool list
- 0.1.3: pricing events tool-read and tool-action
- 0.1.2: concise `devcom_get_question` keeps up to 6,000 characters per answer (was 3,000), like `fetch`, so a long accepted answer keeps its code blocks
- 0.1.1: fixes from the first deployed run (private): a question that Stack Exchange sends without its text keeps its answers, with a null body and a notice, and a call with no text at all costs nothing, the linked and related errors say what was refused and what to use instead, tags show a last activity only when Stack Exchange sends one, internal site aliases are dropped
- 0.1.0: initial build on the Stack Exchange API, 8 tools plus search and fetch (private, unpublished)
  - server name aligned with the Store title

# Actor input Schema

## `mcpEndpoint` (type: `string`):

Paste this URL into your MCP client (Streamable HTTP). It is shown here for copying only: the server ignores this form, and every parameter goes in your questions.

## Actor input object example

```json
{
  "mcpEndpoint": "https://mrbridge--dev-communities-mcp.apify.actor/mcp"
}
```

# Actor output Schema

## `connection` (type: `string`):

The item written by a run started from the Console: endpoint, token options, client recipes and the list of tools with the event each one bills.

# 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 = {
    "mcpEndpoint": "https://mrbridge--dev-communities-mcp.apify.actor/mcp"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrbridge/dev-communities-mcp").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 = { "mcpEndpoint": "https://mrbridge--dev-communities-mcp.apify.actor/mcp" }

# Run the Actor and wait for it to finish
run = client.actor("mrbridge/dev-communities-mcp").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "mcpEndpoint": "https://mrbridge--dev-communities-mcp.apify.actor/mcp"
}' |
apify call mrbridge/dev-communities-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrbridge/dev-communities-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/WEAio7R4AgaloDEsF/builds/Dx6doNyYGkKQmsDYS/openapi.json