# Stack Overflow Search — Questions to JSON (`oblanceolate_mandola/stackoverflow-search`) Actor

Search Stack Overflow questions by keyword. Score, answer count, tags, views, URL as JSON for developer-support & docs AI agents. $2 per 1,000, no coding.

- **URL**: https://apify.com/oblanceolate_mandola/stackoverflow-search.md
- **Developed by:** [Hassan Hashish](https://apify.com/oblanceolate_mandola) (community)
- **Categories:** Developer tools, AI, Automation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Stack Overflow Search — Questions to JSON

Search Stack Overflow questions by keyword and get title, score, answers, tags, views and URL as JSON — $0.002 per question.

What developers struggle with on Stack Overflow is a map of where a technology is confusing, broken, or trending. This actor turns a keyword into the matching questions with their scores and answer status, so developer-support, documentation, and dev-tool agents can mine real pain points as structured data.

### What this actor does

- Search all Stack Overflow questions by keyword, library, or error
- Each result: title, score, answer count, answered flag, tags, view count, question URL
- Sorted by votes; filter by postedAfter for trend monitoring
- Batch many terms per run; cap spend with maxResults
- Agent-ready: flat JSON with the question URL + scrapedAt for citation

**You only pay for successful results** — failed or empty lookups cost nothing.

### Why pick this Actor

- Score, answer count, accepted-answer flag, tags, and view counts on every question — credibility ranking without a second call
- Per-result pricing ($0.002/result) with a hard `maxResults` spend cap — empty lookups cost $0
- Flat, stable JSON schema with `sourceUrl` + `scrapedAt` on every item — citation-ready for RAG and grounding
- Batch many queries in one run; overlapping results are deduplicated and charged once
- MCP server, OpenAPI schema, and LangChain/CrewAI tool support out of the box — no glue code

### Sample output

Each dataset item is flat, typed JSON with a `sourceUrl` and `scrapedAt` for citation/grounding:

```json
{
  "query": "rust async",
  "source": "stackoverflow",
  "title": "How does async/await work in Rust?",
  "score": 145,
  "answers": 3,
  "tags": [
    "rust",
    "async-await",
    "rust-tokio"
  ],
  "url": "https://stackoverflow.com/questions/...",
  "sourceUrl": "https://api.stackexchange.com/2.3/search/advanced?q=rust+async",
  "scrapedAt": "2026-06-11T09:00:00.000Z"
}
```

### Input

```json
{"queries":["rust async"]}
```

| Field | Type | Description |
|---|---|---|
| `queries` / `query` | array / string | Keyword or technology. One or many. |
| `maxResults` | integer | Hard spend cap (billed per result). |
| `keywords` / `postedAfter` | filters | Narrow results; enable delta/scheduled runs. |

### How much does it cost

Pay-per-result: **$0.002 per successful result.** No subscription, no compute-unit guesswork, no charge for empty results. An orchestrator can cap spend with `maxResults`.

### How to use it with AI agents (MCP), Claude, and the API

#### Claude Desktop / Claude Code via Apify MCP

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "oblanceolate_mandola/stackoverflow-search"],
      "env": { "APIFY_TOKEN": "<YOUR_APIFY_TOKEN>" }
    }
  }
}
```

#### Python (Apify API)

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("oblanceolate_mandola/stackoverflow-search").call(run_input={"queries":["rust async"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### TypeScript (Apify API)

```ts
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('oblanceolate_mandola/stackoverflow-search').call({"queries":["rust async"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### LangChain / CrewAI tool

```python
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("oblanceolate_mandola/stackoverflow-search")  # agent calls it autonomously
```

OpenAPI schema for self-integrating GPT agents is auto-exposed at the Actor's API tab.

### Data & compliance

Reads only publicly accessible endpoints. No login, no credential harvesting, no CAPTCHA bypass. Every result carries its `sourceUrl` so downstream agents can cite and re-verify.

### FAQ

#### Are question titles clean text?

Yes — HTML entities in titles are decoded so you get readable text.

#### Can I monitor a tag or library over time?

Yes — search the term and use postedAfter on a schedule to catch new questions.

#### What is the source?

The official Stack Exchange API for the Stack Overflow site.

#### Can AI agents call this Actor directly?

Yes — via the Apify MCP server (snippet above), the OpenAPI schema on the Actor's API tab, or the LangChain/CrewAI tool wrapper. Results are flat JSON with `sourceUrl` and `scrapedAt` on every item, so downstream agents can cite and re-verify.

#### What happens when there are no results?

You pay nothing. Billing is per dataset item delivered, so an empty lookup costs $0, and the run log states why (no match, source rate limit) instead of failing silently.

### Changelog

- **1.0** — Initial release: stackoverflow.

# Actor input Schema

## `queries` (type: `array`):

Term to search across Stack Overflow questions, e.g. "rust async", "pandas merge", a library or error message. Pass several to batch them in one run. Either this or "query" is required.

## `query` (type: `string`):

Single-value convenience alias for "queries". Term to search across Stack Overflow questions, e.g. "rust async", "pandas merge", a library or error message.

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

Hard cap on results across all queries — bounds spend programmatically (you are billed per result). Note: each query returns at most one page from the source (typically 50–100 results); pass multiple queries to gather more.

## `keywords` (type: `array`):

Only return results whose title/department/team contains one of these as a whole word (case-insensitive) — "ai" matches "AI Engineer" but not "Maintenance".

## `postedAfter` (type: `string`):

Only return results posted on/after this ISO date (strictly YYYY-MM-DD, e.g. 2026-01-01; anything else fails the run). Items with no posted date are excluded. Enables incremental/delta scheduled runs.

## `proxyConfiguration` (type: `object`):

Most sources are public JSON APIs needing no proxy. Configure only if a source geo-restricts.

## Actor input object example

```json
{
  "queries": [
    "rust async"
  ],
  "maxResults": 50
}
```

# Actor output Schema

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

Structured result rows in the default dataset (clean JSON).

# 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 = {
    "queries": [
        "rust async"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("oblanceolate_mandola/stackoverflow-search").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 = { "queries": ["rust async"] }

# Run the Actor and wait for it to finish
run = client.actor("oblanceolate_mandola/stackoverflow-search").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 '{
  "queries": [
    "rust async"
  ]
}' |
apify call oblanceolate_mandola/stackoverflow-search --silent --output-dataset

```

## MCP server setup

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

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/EIzOhkkLhMb5ypBEQ/builds/PwTuzDVx2ST6b2ihn/openapi.json