# Fandom Cross-Wiki Search - Full Result Details (`ryyos/community-fandom`) Actor

\[$0.5/1000] Search any keyword across every Fandom wiki at once and get titles, snippets, source wikis, and full page detail (article text, infoboxes, categories, post replies) for every result

- **URL**: https://apify.com/ryyos/community-fandom.md
- **Developed by:** [Rio Dwi Saputra](https://apify.com/ryyos) (community)
- **Categories:** News, Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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

## Fandom Cross-Wiki Search Scraper - Full Result Details

**Search any keyword across every Fandom wiki at once** and get back both the full
result list and the complete detail of each item - article text and infobox data,
Discussions post replies, file info, blog posts, user profiles, and help pages - in
one run. No manual clicking through hundreds of wikis, no rate-limit guesswork.
\[$1.5/1000]

### What does Fandom Cross-Wiki Search Scraper do?

This Actor drives the same cross-wiki search that powers
[community.fandom.com/wiki/Special:Search](https://community.fandom.com/wiki/Special:Search),
the search box used by every Fandom/Wikia wiki, and turns it into structured JSON.
Give it a keyword and it returns every matching result - title, snippet, source
wiki, thumbnail - across as many of the seven Fandom result categories (Articles,
Posts, Photos and Videos, Blogs, People, Help pages, Everything) as you choose.
Optionally, it then visits each result's own page (or the Fandom Discussions API
for Posts) to pull the full detail: article body text and infobox fields, post
reply/upvote counts and author, file description, and MediaWiki categories.

Run it on-demand via the Apify Console or API, schedule it to track how search
results for a name, character, or franchise change over time, and pipe results
straight into your own database or BI tool through Apify's integrations
(Zapier, Make, webhooks, and more) - no proxy setup or anti-bot tuning required.

### Why use Fandom Cross-Wiki Search Scraper?

- **Competitive/brand monitoring** - track every Fandom wiki mentioning a
  celebrity, game, or show in one query instead of searching wiki by wiki.
- **Content research** - pull well-organized article and infobox data for a topic
  across dozens of fan wikis at once.
- **Community sentiment** - collect Discussions posts (with reply counts,
  upvotes, and author) mentioning a keyword to gauge fan reaction.
- **Media discovery** - find every file/image across Fandom matching a keyword,
  with direct thumbnail URLs.

### How to use Fandom Cross-Wiki Search Scraper

1. Click **Try for free** (or **Run**) on this Actor's page.
2. Enter your **Search keyword** (e.g. `sadie sink`).
3. Pick one or more **Search categories** - Articles, Posts, Photos and Videos,
   Blogs, People, Help pages, or Everything.
4. Optionally adjust the max results per category, whether to fetch full detail
   pages, and concurrency.
5. Click **Start** and download your results as JSON, CSV, or Excel once the run
   finishes.

### Input

| Field | Description | Default |
|---|---|---|
| `query` | Search keyword, exactly as typed into Fandom's search box | - (required) |
| `categories` | Which of the 7 Fandom search tabs to fetch (Articles, Posts, Photos and Videos, Blogs, People, Help pages, Everything) | `["articles"]` |
| `maxItemsPerCategory` | Max results to collect per selected category | `50` |
| `fetchDetails` | Visit each result's page/API for full detail, not just the search snippet | `true` |
| `maxDetailTextLength` | Truncate extracted body/post text to this many characters (`0` = no limit) | `3000` |
| `maxConcurrency` | Max pages fetched in parallel | `5` |
| `proxyConfiguration` | Optional Apify Proxy settings for extra reliability on large runs | disabled |

See the **Input** tab for the full interactive form.

### Output

Each dataset item represents one search result, merged with its detail fields
(when `fetchDetails` is enabled). Example for an Articles result:

```json
{
  "searchQuery": "sadie sink",
  "category": "articles",
  "kind": "article",
  "position": 1,
  "title": "Sadie Sink",
  "url": "https://strangerthings.fandom.com/wiki/Sadie_Sink",
  "snippet": "Sadie Sink Birth name Sadie Elizabeth Sink Birth date April 16, 2002 ...",
  "sourceWikiName": "Stranger Things Wiki",
  "sourceWikiUrl": "http://strangerthings.fandom.com/",
  "detailFetched": true,
  "detailText": "Sadie Elizabeth Sink (born April 16, 2002) is an American actress ...",
  "detailInfobox": { "Birth name": "Sadie Elizabeth Sink", "Nationality": "American" },
  "detailCategories": ["Real-world articles", "Cast", "Cast/Season 2"]
}
```

For a Posts result, the detail fields are populated from Fandom's Discussions API
instead (article/infobox fields stay `null`):

```json
{
  "category": "posts",
  "kind": "post",
  "title": "Why I feel Sadie Sink as Jean Grey is highly unlikely and unrealistic",
  "url": "https://marvelcinematicuniverse.fandom.com/f/p/4400000000003877609",
  "detailFetched": true,
  "detailText": "Since Sadie Sink joined MCU in Spider-man: Brand New Day, ...",
  "detailAuthor": "Xfantasyland2111",
  "detailReplyCount": 7,
  "detailUpvoteCount": 4,
  "detailForumName": "General"
}
```

For a Photos and Videos result, detail comes from the official MediaWiki file API
instead of the file's own page (Fandom often 301-redirects file pages - especially
videos - to an unrelated host article, so this Actor queries file metadata
directly by page ID rather than following that redirect):

```json
{
  "category": "photos_and_videos",
  "kind": "file",
  "title": "File:Sadie Sink.jpg",
  "url": "https://to-hollywood-and-beyond.fandom.com/wiki/File:Sadie_Sink.jpg",
  "detailFetched": true,
  "detailFileUploader": "Mikex20",
  "detailFileUploadedAt": "2021-08-24T00:58:19Z",
  "detailFileUrl": "https://static.wikia.nocookie.net/to-hollywood-and-beyond/images/4/48/Sadie_Sink.jpg/revision/latest?cb=20210824005819",
  "detailFileSize": 26701,
  "detailFileMime": "image/jpeg"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data table

| Field | Description |
|---|---|
| `category` / `kind` | Which search tab the result came from, and its inferred type (article, post, file, blog, user, help) |
| `title`, `url`, `snippet` | Core search-result fields |
| `sourceWikiName`, `sourceWikiUrl` | The Fandom wiki the result belongs to |
| `thumbnailUrl` | Result thumbnail image, if any |
| `detailText`, `detailDescription` | Full body text / meta description (articles, files, blogs, help pages) |
| `detailInfobox`, `detailCategories` | Infobox key/value pairs and MediaWiki categories (article/blog/user/help pages only) |
| `detailAuthor`, `detailCreatedAt`, `detailReplyCount`, `detailUpvoteCount`, `detailForumName` | Discussions post detail (posts only) |
| `detailFileUploader`, `detailFileUploadedAt`, `detailFileUrl`, `detailFileSize`, `detailFileMime` | File metadata from the MediaWiki API (files only) |

### Pricing / Cost estimation

This Actor is billed on the Apify **Pay per result** model at **$1.5 per 1,000
results**. A typical run of 100 results with `fetchDetails` enabled uses a bit
more compute than list-only mode (one extra page fetch per result), which is
already reflected in the price - you don't pay extra to enable it. Apify's free
tier includes monthly platform credits that cover light, exploratory runs.

### Tips for faster, cheaper runs

- Disable `fetchDetails` if you only need the search-result summary (title,
  snippet, source wiki) - this roughly halves the number of requests.
- Lower `maxDetailTextLength` if you don't need the full article/post body.
- Select only the categories you actually need instead of `everything`.
- Keep `maxConcurrency` moderate (the default of 5 is a good balance) - Fandom
  sits behind Cloudflare and can show a bot-check page if hit too aggressively
  without session/cookie continuity, which this Actor already handles for you.

### FAQ, disclaimers, and support

This Actor only reads publicly accessible Fandom search results and wiki pages;
it does not bypass logins, paywalls, or CAPTCHAs. Fandom's page layout and
Discussions API can change without notice, which may require an update to this
Actor - please report issues via the **Issues** tab on this Actor's Apify Store
page. Use of this Actor is subject to Fandom's Terms of Use; you are responsible
for how you use the data it collects. Need a custom variant (different site,
extra fields, scheduled monitoring)? Reach out via the Issues tab.

### Environment variables

None required. This Actor's only reverse-engineered endpoint (the Fandom
Discussions "get thread" API) is not authenticated and needs no token - its
configuration lives in `my_actor/config_local.py` (see
`my_actor/config_schema.py` for the documented structure).

### Development

```bash
pytest tests/
apify validate-schema
apify run --input-file test-inputs/search.json --purge
```

# Actor input Schema

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

The keyword or phrase to search for across all Fandom wikis, exactly as you would type it into the Fandom search box (e.g. "sadie sink").

## `categories` (type: `array`):

Which result categories to fetch, matching the tabs on the Fandom search page (Articles, Posts, Photos and Videos, Blogs, People, Help pages, Everything). Selecting more than one category runs one search per category.

## `maxItemsPerCategory` (type: `integer`):

Maximum number of search results to collect for each selected category. Pagination stops automatically once this limit is reached or Fandom runs out of results.

## `fetchDetails` (type: `boolean`):

When enabled, the Actor also visits each result's own page (or the Discussions API for Posts) to collect full body text, infobox data, categories, author and other detail fields. Disable for a faster run that only returns the search-result summary.

## `maxDetailTextLength` (type: `integer`):

Truncates the extracted article/post body text to this many characters, to keep dataset items compact. Set to 0 for no limit.

## `maxConcurrency` (type: `integer`):

Maximum number of pages fetched in parallel. Keep this moderate to stay within Fandom's fair-use limits and avoid triggering Cloudflare's anti-bot challenge.

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

Optional proxy settings. Fandom is served through Cloudflare - enabling Apify Proxy can improve reliability on large runs.

## Actor input object example

```json
{
  "query": "sadie sink",
  "categories": [
    "articles"
  ],
  "maxItemsPerCategory": 50,
  "fetchDetails": true,
  "maxDetailTextLength": 3000,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "query": "sadie sink"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ryyos/community-fandom").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 = { "query": "sadie sink" }

# Run the Actor and wait for it to finish
run = client.actor("ryyos/community-fandom").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 '{
  "query": "sadie sink"
}' |
apify call ryyos/community-fandom --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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