# WikiVoyage Travel Guides Scraper (`crawlerbros/wikivoyage-travel-scraper`) Actor

Scrape Wikivoyage, the free travel guide with 30,000+ destination articles. Search destinations, get full travel guides with sections, list countries/cities, and browse featured destinations. Supports 11 languages. No auth or proxy required.

- **URL**: https://apify.com/crawlerbros/wikivoyage-travel-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## WikiVoyage Travel Guides Scraper

Scrape travel guides from [Wikivoyage](https://www.wikivoyage.org/) — the free, open-content travel guide with 30,000+ destination articles in multiple languages. No authentication, no proxy, and no API key required.

### What It Does

This actor fetches structured travel guide data from the public Wikivoyage/Wikimedia REST API, including destination descriptions, coordinates, thumbnail images, and full article sections. It works reliably on the Apify free plan.

### Data Source

Wikivoyage is a Wikimedia project — a freely licensed travel guide written by volunteers. All data is available under the [Creative Commons Attribution-ShareAlike 3.0](https://creativecommons.org/licenses/by-sa/3.0/) license.

API endpoints used (all public, no auth):
- Search: `https://{lang}.wikivoyage.org/w/rest.php/v1/search/page`
- Summary: `https://{lang}.wikivoyage.org/api/rest_v1/page/summary/{title}`
- Content: `https://{lang}.wikivoyage.org/w/rest.php/v1/page/{title}/with_html`
- Category: `https://{lang}.wikivoyage.org/w/api.php` (MediaWiki action API)

---

### Modes

#### `search` (default)
Search for destinations by keyword. Returns matching travel guide articles.

**Required input:** `searchQuery`

**Example:** `{ "mode": "search", "searchQuery": "Paris", "maxItems": 10 }`

---

#### `getGuide`
Fetch the full travel guide for one or more specific destinations.

**Required input:** `destinations` (list of names) and/or `startUrls` (list of Wikivoyage URLs)

**Example:**
```json
{
  "mode": "getGuide",
  "destinations": ["Tokyo", "Rome", "Barcelona"],
  "includeFullContent": true
}
````

***

#### `listCountries`

List all country-level travel guide articles from Wikivoyage.

**Example:** `{ "mode": "listCountries", "maxItems": 200 }`

***

#### `listCities`

List city articles for a specific country.

**Required input:** `country`

**Example:** `{ "mode": "listCities", "country": "France", "maxItems": 100 }`

***

#### `featured`

Get highlighted/featured destination articles from Wikivoyage.

**Example:** `{ "mode": "featured", "maxItems": 25 }`

***

### Input Parameters

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `mode` | select | Operation mode: `search`, `getGuide`, `listCountries`, `listCities`, `featured` | `search` |
| `searchQuery` | string | Destination keyword (mode=search) | — |
| `destinations` | string\[] | Destination names to fetch (mode=getGuide) | — |
| `startUrls` | string\[] | Wikivoyage article URLs (mode=getGuide) | — |
| `country` | string | Country name for city listing (mode=listCities) | — |
| `language` | select | Language edition: `en`, `de`, `fr`, `es`, `it`, `pt`, `nl`, `sv`, `pl`, `ru`, `ja` | `en` |
| `includeFullContent` | boolean | Parse and include full article sections | `false` |
| `maxItems` | integer | Maximum records to return (1–500) | `50` |

***

### Output Fields

Each record in the dataset contains:

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Destination name |
| `description` | string | Short description or article extract |
| `url` | string | Canonical Wikivoyage article URL |
| `type` | string | Article type: `city`, `region`, `country`, `continent`, `itinerary`, or `guide` |
| `thumbnailUrl` | string | Thumbnail image URL (when available) |
| `coordinates` | object | `{ lat, lon }` GPS coordinates (when available) |
| `country` | string | Country name (mode=listCities) |
| `language` | string | Language code (e.g. `en`) |
| `scrapedAt` | string | ISO 8601 timestamp |
| `sections` | array | `[{ heading, content }]` — only with `includeFullContent: true` |

All fields are omit-empty: no `null`, empty strings, or empty arrays will appear in any record.

***

### Example Output

```json
{
  "title": "Paris",
  "description": "Capital city of France, known for the Eiffel Tower.",
  "url": "https://en.wikivoyage.org/wiki/Paris",
  "type": "city",
  "thumbnailUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4b/La_Tour_Eiffel_vue_de_la_Tour_Saint-Jacques%2C_Paris_août_2014_%282%29.jpg/1200px-La_Tour_Eiffel_vue_de_la_Tour_Saint-Jacques%2C_Paris_août_2014_%282%29.jpg",
  "coordinates": { "lat": 48.8566, "lon": 2.3522 },
  "language": "en",
  "scrapedAt": "2026-05-17T10:00:00+00:00"
}
```

***

### Multi-Language Support

Change the `language` parameter to scrape any of 11 Wikivoyage language editions:

| Code | Language | Wikivoyage articles |
|------|----------|---------------------|
| `en` | English | ~30,000 |
| `de` | German | ~25,000 |
| `fr` | French | ~15,000 |
| `es` | Spanish | ~10,000 |
| `it` | Italian | ~8,000 |
| `pt` | Portuguese | ~7,000 |
| `nl` | Dutch | ~5,000 |
| `sv` | Swedish | ~3,000 |
| `pl` | Polish | ~3,000 |
| `ru` | Russian | ~3,000 |
| `ja` | Japanese | ~2,000 |

***

### Use Cases

- **Travel planning apps** — build destination databases from open content
- **Chatbots and AI assistants** — enrich travel queries with real guide data
- **Research and datasets** — aggregate travel information at scale
- **SEO content** — discover destination articles and related topics
- **Map applications** — extract coordinates for destinations worldwide

***

### FAQs

**Does this require an API key or account?**
No. Wikivoyage is an open Wikimedia project and all API endpoints are public.

**Is there a rate limit?**
Wikivoyage APIs are generous for reasonable use. The actor includes automatic retry with backoff on 429/5xx responses.

**Can I scrape non-English guides?**
Yes — use the `language` parameter to switch to any of 11 supported Wikivoyage language editions.

**How fresh is the data?**
Wikivoyage is continuously updated by volunteers. Data is fetched live on each run.

**What is `includeFullContent`?**
When enabled, the actor fetches the full article HTML and parses it into sections (e.g., "Understand", "Get in", "See", "Do", "Buy", "Eat", "Drink", "Stay safe"). This is slower but provides complete travel guide text.

**What does the `type` field mean?**

- `city` — a city or town article
- `region` — a regional destination (e.g., Tuscany, Patagonia)
- `country` — a country-level guide
- `continent` — a continent-level guide
- `itinerary` — a travel route or road trip guide
- `guide` — other article types not matching the above

***

### Technical Notes

- Pure HTTP (`httpx`) — no browser or proxy needed
- Works on the Apify free plan with zero configuration
- Output is omit-empty at every depth: no null fields in any record
- Respects Wikimedia API best practices (User-Agent header, retry on 429)

# Actor input Schema

## `mode` (type: `string`):

What to fetch from Wikivoyage.

## `searchQuery` (type: `string`):

Destination name or keyword to search for (used in mode=search).

## `destinations` (type: `array`):

List of destination names to fetch full guides for (e.g. `Paris`, `Tokyo`, `Rome`).

## `startUrls` (type: `array`):

Direct Wikivoyage article URLs to scrape (e.g. `https://en.wikivoyage.org/wiki/Paris`).

## `country` (type: `string`):

Country name whose city articles to list (e.g. `France`, `Japan`).

## `language` (type: `string`):

Wikivoyage language edition to use.

## `includeFullContent` (type: `boolean`):

If enabled, parse and include the full article text as structured sections (heading + content). Slower but provides complete travel guide text.

## `maxItems` (type: `integer`):

Maximum number of travel guide records to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Paris",
  "destinations": [],
  "startUrls": [],
  "language": "en",
  "includeFullContent": false,
  "maxItems": 50
}
```

# Actor output Schema

## `guides` (type: `string`):

Dataset containing all scraped Wikivoyage travel guide records.

# 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 = {
    "mode": "search",
    "searchQuery": "Paris",
    "destinations": [],
    "startUrls": [],
    "language": "en",
    "includeFullContent": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/wikivoyage-travel-scraper").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 = {
    "mode": "search",
    "searchQuery": "Paris",
    "destinations": [],
    "startUrls": [],
    "language": "en",
    "includeFullContent": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/wikivoyage-travel-scraper").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 '{
  "mode": "search",
  "searchQuery": "Paris",
  "destinations": [],
  "startUrls": [],
  "language": "en",
  "includeFullContent": false,
  "maxItems": 50
}' |
apify call crawlerbros/wikivoyage-travel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WikiVoyage Travel Guides Scraper",
        "description": "Scrape Wikivoyage, the free travel guide with 30,000+ destination articles. Search destinations, get full travel guides with sections, list countries/cities, and browse featured destinations. Supports 11 languages. No auth or proxy required.",
        "version": "1.0",
        "x-build-id": "UvOdFk5kHfUu6oX1v"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~wikivoyage-travel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-wikivoyage-travel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~wikivoyage-travel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-wikivoyage-travel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~wikivoyage-travel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-wikivoyage-travel-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "getGuide",
                            "listCountries",
                            "listCities",
                            "featured"
                        ],
                        "type": "string",
                        "description": "What to fetch from Wikivoyage.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Destination name or keyword to search for (used in mode=search).",
                        "default": "Paris"
                    },
                    "destinations": {
                        "title": "Destinations (mode=getGuide)",
                        "type": "array",
                        "description": "List of destination names to fetch full guides for (e.g. `Paris`, `Tokyo`, `Rome`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (mode=getGuide)",
                        "type": "array",
                        "description": "Direct Wikivoyage article URLs to scrape (e.g. `https://en.wikivoyage.org/wiki/Paris`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country (mode=listCities)",
                        "type": "string",
                        "description": "Country name whose city articles to list (e.g. `France`, `Japan`)."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "sv",
                            "pl",
                            "ru",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Wikivoyage language edition to use.",
                        "default": "en"
                    },
                    "includeFullContent": {
                        "title": "Include full section content",
                        "type": "boolean",
                        "description": "If enabled, parse and include the full article text as structured sections (heading + content). Slower but provides complete travel guide text.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of travel guide records to return.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
