# Wikipedia Search — Article Lookup to JSON (`oblanceolate_mandola/wikipedia-search`) Actor

Search Wikipedia by keyword. Article title, short description, matching snippet as JSON for grounding & research AI agents. $1 per 1,000, no coding.

- **URL**: https://apify.com/oblanceolate\_mandola/wikipedia-search.md
- **Developed by:** [Hassan Hashish](https://apify.com/oblanceolate_mandola) (community)
- **Categories:** AI, News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Wikipedia Search — Article Lookup to JSON

Search Wikipedia by keyword and get matching article titles, descriptions and snippets as JSON — $0.001 per result.

Agents grounding their answers need fast, structured access to encyclopedic facts. This actor turns a query into the matching Wikipedia articles with their short descriptions and snippets, so research and RAG agents can disambiguate entities and cite a stable source.

### What this actor does

- Search Wikipedia by keyword for matching articles
- Each result: page title, short description, matching snippet (clean text), page key
- Open any article at en.wikipedia.org/wiki/{key}
- Batch many terms per run; cap spend with maxResults
- Agent-ready: flat JSON with sourceUrl + scrapedAt for citation

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

### Why pick this Actor

- Clean entity grounding: title, stable page key, one-line description, and excerpt — disambiguation-ready for RAG pipelines
- Per-result pricing ($0.001/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": "agentic commerce",
  "source": "wikipedia",
  "title": "Agentic commerce",
  "description": "Form of automated electronic commerce",
  "key": "Agentic_commerce",
  "sourceUrl": "https://en.wikipedia.org/w/rest.php/v1/search/page?q=agentic+commerce",
  "scrapedAt": "2026-06-11T15:00:00.000Z"
}
```

### Input

```json
{"queries":["agentic commerce"]}
```

| Field | Type | Description |
|---|---|---|
| `queries` / `query` | array / string | Search term. 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.001 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/wikipedia-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/wikipedia-search").call(run_input={"queries":["agentic commerce"]})
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/wikipedia-search').call({"queries":["agentic commerce"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### LangChain / CrewAI tool

```python
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("oblanceolate_mandola/wikipedia-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

#### How do I open the article?

Each result includes its page key; the article is at en.wikipedia.org/wiki/{key}.

#### Are snippets clean text?

Yes — search-match HTML in excerpts is stripped to readable text.

#### What is the source?

The official Wikimedia REST search API for English Wikipedia.

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

# Actor input Schema

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

Term to look up on Wikipedia, e.g. a person, company, concept, or place — for grounding and disambiguation. 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 look up on Wikipedia, e.g. a person, company, concept, or place — for grounding and disambiguation.

## `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": [
    "agentic commerce"
  ],
  "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": [
        "agentic commerce"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("oblanceolate_mandola/wikipedia-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": ["agentic commerce"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/l89YWBhMpBnKmRTeY/builds/SJCYd63M0CIXHkPGc/openapi.json