# Touring Scraper — Belgian Travel & Automobile Club Info (`studio-amba/touring-scraper`) Actor

Extract articles, FAQs, and travel guides from Touring.be — Belgium's automobile club. Travel guides, vehicle advice, insurance info, and border crossing data.

- **URL**: https://apify.com/studio-amba/touring-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Touring Scraper -- Belgian Automobile Club Articles, FAQs & Travel Guides

Extract articles, frequently asked questions, and cross-border travel information from [Touring.be](https://www.touring.be) -- Belgium's leading automobile club and roadside assistance provider, serving over 1.5 million members with travel advice, vehicle guides, and insurance information.

### What is Touring Scraper?

Touring is the Belgian automobile club equivalent of the AA (UK) or ADAC (Germany). Beyond roadside assistance, Touring.be is a massive content platform: thousands of articles about vehicle maintenance, road trip planning, border crossing regulations, insurance advice, and mobility trends. This content is authoritative, regularly updated, and referenced by Belgian media and government agencies.

This actor discovers content via Touring's XML sitemap and scrapes articles, FAQs, and travel information pages. It extracts structured data including titles, body text, metadata, publication dates, and breadcrumb navigation. What people do with it:

- **Content analysis** -- automotive media companies and content agencies analyse Touring's editorial strategy to inform their own Belgian automotive content.
- **Travel regulation monitoring** -- logistics companies and travel agencies track Touring's country-specific border crossing guides for regulatory changes (vignettes, environmental zones, required equipment by country).
- **Insurance market research** -- comparison sites and insurance brokers monitor Touring's FAQ content to understand what questions Belgian drivers ask most.
- **Knowledge base construction** -- companies building Belgian mobility products use Touring's content as source material for their own knowledge bases and chatbots.
- **SEO competitive analysis** -- digital agencies analyse Touring's content taxonomy, keyword targeting, and information architecture for automotive clients.

### What data does Touring Scraper extract?

Each content item is returned as a structured JSON object:

- :newspaper: **Title** -- the article, FAQ, or guide headline
- :label: **Content type** -- `"article"`, `"faq"`, or `"travel-info"` classification
- :page_facing_up: **Full text content** -- the complete body text, cleaned of HTML tags
- :memo: **Description** -- meta description or summary paragraph
- :calendar: **Publication and modification dates** -- when the content was first published and last updated
- :bust_in_silhouette: **Author** -- content author (typically "Touring" for institutional content)
- :framed_picture: **Image** -- hero image URL from the article
- :bookmark: **Tags** -- keyword tags from meta data
- :compass: **Breadcrumbs** -- full navigation path from the site hierarchy
- :globe_with_meridians: **Language** -- `"nl"` (Dutch) or `"fr"` (French)
- :link: **URL** -- direct link to the original article

### How to scrape Touring.be

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `contentType` | String | No | What to scrape: `"articles"`, `"faqs"`, `"travel-info"`, or `"all"` (default: `"articles"`) |
| `startUrls` | Array | No | Specific Touring.be URLs to scrape directly (overrides contentType) |
| `maxResults` | Integer | No | Maximum items to return (default: 100, max: 5,000) |
| `language` | String | No | Content language: `"nl"` (default) or `"fr"` |
| `proxyConfiguration` | Object | No | Proxy settings (usually not needed) |

**Tips:**

- Use `contentType: "all"` with a high `maxResults` to get a complete content snapshot of everything Touring publishes.
- For cross-border travel regulations, use `contentType: "travel-info"` -- this captures country-specific driving requirements.
- The actor uses sitemap discovery, so it can find all indexed content without you needing to provide specific URLs.
- Set `language: "fr"` to get the French-language version of articles (Touring publishes in both Dutch and French).

### Output

```json
{
    "title": "Milieuzones in Europa: waar heb je een vignet nodig?",
    "contentType": "article",
    "url": "https://www.touring.be/nl/artikels/milieuzones-in-europa",
    "description": "Steeds meer Europese steden voeren milieuzones in. Ontdek waar je een vignet nodig hebt en hoe je er een aanvraagt.",
    "content": "Milieuzones zijn gebieden in stadscentra waar alleen voertuigen met een bepaalde milieunorm mogen binnenrijden. In Belgie kennen we de lage-emissiezones (LEZ) in Antwerpen, Gent en Brussel. Maar ook in het buitenland zijn er steeds meer steden met milieuzones...",
    "datePublished": "2026-02-15T10:00:00+01:00",
    "dateModified": "2026-03-20T14:30:00+01:00",
    "author": "Touring",
    "imageUrl": "https://www.touring.be/sites/default/files/milieuzones-europa.jpg",
    "tags": ["milieuzones", "vignet", "Europa", "LEZ"],
    "breadcrumbs": ["Home", "Artikels", "Mobiliteit", "Milieuzones in Europa"],
    "language": "nl",
    "scrapedAt": "2026-04-03T10:45:00.000Z"
}
````

### How much does it cost?

Touring Scraper uses lightweight CheerioCrawler (no browser required):

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 100 articles | ~0.03 | ~$0.015 |
| 500 articles | ~0.10 | ~$0.05 |
| 1,000 articles | ~0.20 | ~$0.10 |
| All content (~3,000) | ~0.50 | ~$0.25 |

The sitemap discovery step adds minimal overhead. Most compute goes to fetching individual content pages.

### Can I integrate?

Push Touring content into your tools:

- **Google Sheets** -- maintain a spreadsheet of all Touring articles with metadata for content auditing
- **Slack** -- get notified when Touring publishes new articles on topics you care about
- **Zapier / Make** -- trigger workflows when travel regulation content is updated
- **Webhooks** -- stream content to your CMS or knowledge base
- **Elasticsearch** -- build a full-text searchable index of Belgian automotive and travel content
- **Amazon S3** -- archive historical content snapshots for trend analysis

### Can I use it as an API?

Yes. Integrate Touring content extraction into your pipeline:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/touring-scraper").call(run_input={
    "contentType": "travel-info",
    "language": "nl",
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['contentType']}] {item['title']}")
    print(f"  Published: {item.get('datePublished', 'Unknown')}")
```

**JavaScript:**

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/touring-scraper").call({
    contentType: "all",
    language: "fr",
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`[${item.contentType}] ${item.title}`);
});
```

### FAQ

**What types of content does Touring publish?**
Three main categories: articles (vehicle advice, road trip guides, mobility news), FAQs (insurance questions, membership questions, roadside assistance), and travel info (country-specific border crossing requirements, environmental zone regulations).

**Is the content copyrighted?**
Yes. Touring owns the copyright on their content. This actor extracts the text for analytical and research purposes. Republishing the content verbatim may require permission from Touring.

**Does it scrape the full article body or just summaries?**
Full body text. The actor visits each individual content page and extracts the complete article text, stripped of HTML formatting.

**Can I track when articles are updated?**
Yes. Both `datePublished` and `dateModified` are extracted from the page metadata when available. Run the actor periodically and compare modification dates to detect updates.

**Is content available in both Dutch and French?**
Yes. Touring.be publishes most content in both languages. Use the `language` parameter to select `"nl"` or `"fr"`.

**Does it include Touring's membership pricing or services?**
No. The actor focuses on editorial content (articles, FAQs, guides), not on membership plans or service booking pages.

**How much content does Touring publish?**
Touring.be has several thousand indexed content pages across articles, FAQs, and travel information. With `contentType: "all"` and a high `maxResults`, you can capture the entire editorial catalogue.

**Can I use this for SEO competitive analysis?**
Yes. The breadcrumb data, meta descriptions, tags, and content structure are all extracted. This gives you a complete picture of how Touring organises and targets their content.

**Does it capture structured FAQ schema?**
The actor extracts FAQ content from the page body. If Touring uses structured FAQ schema (FAQPage JSON-LD), that data is also parsed alongside the HTML content.

### Limitations

- Content extraction relies on Touring's Drupal CMS structure. Major site redesigns may require actor updates.
- Not all pages have structured publication dates or author information in their metadata.
- FAQ pages often have simpler content structures than full articles -- body text may be shorter.
- The sitemap may not include every page on the site. Very new content might take time to appear in the sitemap.
- Only extracts text content, not embedded videos, interactive calculators, or downloadable PDFs.

### Related Belgian travel and transport scrapers

- [NMBS Scraper](https://apify.com/studio-amba/nmbs-scraper) -- Belgian train connections, departures, and station data
- [Scandlines Scraper](https://apify.com/studio-amba/scandlines-scraper) -- ferry routes between Denmark and Germany
- [AutoVlan Scraper](https://apify.com/studio-amba/autovlan-scraper) -- Belgian used car marketplace listings
- [Norauto Scraper](https://apify.com/studio-amba/norauto-scraper) -- French car parts and accessories prices

### Your feedback

Need specific content categories, want to scrape Touring's service centre locations, or found a parsing issue? Open an issue on GitHub or reach out through Apify. User feedback directly drives our improvement priorities.

# Actor input Schema

## `contentType` (type: `string`):

What type of content to scrape. 'articles' = magazine articles & guides, 'faqs' = frequently asked questions, 'travel-info' = border crossing & country guides, 'all' = everything.

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

Specific Touring.be URLs to scrape. Overrides Content Type if provided. Example: https://www.touring.be/nl/artikels/kies-je-voor-tweedehands-nieuw

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

Maximum number of items to return.

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

Language for content. Dutch (nl) or French (fr).

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

Proxy settings. Usually not needed for Touring.be.

## Actor input object example

```json
{
  "contentType": "articles",
  "startUrls": [],
  "maxResults": 100,
  "language": "nl"
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/touring-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 = { "startUrls": [] }

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/touring-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 '{
  "startUrls": []
}' |
apify call studio-amba/touring-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Touring Scraper — Belgian Travel & Automobile Club Info",
        "description": "Extract articles, FAQs, and travel guides from Touring.be — Belgium's automobile club. Travel guides, vehicle advice, insurance info, and border crossing data.",
        "version": "0.1",
        "x-build-id": "haWhclaiY4IRkvmTU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~touring-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-touring-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/studio-amba~touring-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-touring-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/studio-amba~touring-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-touring-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",
                "properties": {
                    "contentType": {
                        "title": "Content Type",
                        "enum": [
                            "articles",
                            "faqs",
                            "travel-info",
                            "all"
                        ],
                        "type": "string",
                        "description": "What type of content to scrape. 'articles' = magazine articles & guides, 'faqs' = frequently asked questions, 'travel-info' = border crossing & country guides, 'all' = everything.",
                        "default": "articles"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Specific Touring.be URLs to scrape. Overrides Content Type if provided. Example: https://www.touring.be/nl/artikels/kies-je-voor-tweedehands-nieuw",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of items to return.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "nl",
                            "fr"
                        ],
                        "type": "string",
                        "description": "Language for content. Dutch (nl) or French (fr).",
                        "default": "nl"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Usually not needed for Touring.be."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
