# Travel Budget Planner (`inovaflow/travel-planner`) Actor

Plan any trip: aggregates whole-market Airbnb & Booking.com nightly-price stats (median & average over the full market, via a price-histogram Actor) plus flights, buses and trains, in your chosen currency, and writes a formatted itinerary into your Notion via an MCP Connector.

- **URL**: https://apify.com/inovaflow/travel-planner.md
- **Developed by:** [inovaflow](https://apify.com/inovaflow) (community)
- **Categories:** Travel, MCP servers, Integrations
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / actor start

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

**Plan a whole trip in one run — honest, whole-market accommodation prices plus the cheapest flights, in the currency you pick, and written straight into Notion if you like.**

If you've ever planned a trip, you know the tab-juggling: flights in one tab, Airbnb in another, Booking.com in a third — then you redo it all for different dates. And that "average price" on the first screen of listings? It's a handful of places, not the real market.

We just wanted one honest answer to *"what will this trip actually cost?"* So Travel Budget Planner takes an **origin, a destination, and your dates**, and in one run gives you the **typical nightly price for accommodation across the whole market** — median and average over every listing, not a sample — plus the **cheapest flights** for those dates. It prices **Airbnb** by default; add **Booking.com** for a second opinion, plus buses, trains, or a Notion page if you like, and pick your currency.

**Behind the scenes, Travel Budget Planner is an orchestrator** — it runs other specialized Apify Actors for you in the background and merges their results into one trip. Accommodation comes from our [Airbnb & Booking Price Index](https://apify.com/inovaflow/airbnb-booking-price-index) (a real market price — every listing's price distribution, not 20 averaged); flights from [Skyscanner Scraper](https://apify.com/memo23/skyscanner-scraper). Optional sources add [Airbnb](https://apify.com/automation-lab/airbnb-listing) / [Booking.com](https://apify.com/voyager/booking-scraper) listings, [FlixBus + FlixTrain](https://apify.com/jungle_synthesizer/flixbus-multi-country-scraper), and [Rome2Rio](https://apify.com/parseforge/rome2rio-scraper). Those background runs are billed to you too — see **Costs**.

> 🧪 **Early access.** This is new — give it a go and tell us what to add next (more transport, more cities, richer output), or if anything (price included) feels off. **Your feedback shapes the roadmap** → open an issue on the **Issues** tab. 🙏

### Who it's for

- **Digital nomads** — compare the real cost of basing somewhere for a month, in one run.
- **Anyone budgeting a trip** — one honest number, not a guess from the first page of results.
- **Travel & tour companies** — fast, whole-market cost checks for client trips and itineraries.
- **AI assistants & agents** — one *"price this trip"* call from any AI tool (over MCP — see below).

### Input

Four are required; the rest have sensible defaults.

- **Origin** — where you start (city or airport code, e.g. `Berlin` or `BER`).
- **Destination** — where you're going, as `City, Country` (e.g. `Lisbon, Portugal`).
- **Check-in & check-out** — your dates (today or later, up to 90 nights).
- **Guests** / **Passengers** — how many the *stay* / the *transport* is priced for (1–16, default 1).
- **Currency** — EUR, USD, GBP, CHF, or PLN (default EUR; no conversion).
- **Which prices to fetch** — default: **Airbnb prices + flights** (the cheapest start). Add **Booking.com prices** for a second opinion (slower & costlier — it runs a browser), buses + trains, Rome2Rio routes, or the "listings" options for a few clickable places.
- **Notion** *(optional)* — connect it to have the trip written to a page.

### How to set it up

1. **Create a free Apify account** and open this Actor — no travel-site logins, no API keys.
2. Click **Try for free / Start**.
3. Enter your **origin, destination, and dates** (tweak guests, currency, or sources if you like) and click **Start**.
4. Open the **Output** tab — your trip overview, accommodation prices, and transport options appear in seconds.

*(Optional)* Connect **Notion** for a formatted itinerary page, and use the **Schedule** tab to re-price a trip over time.

### Output

One tidy result per run:

- **Accommodation prices** — per platform, the **market-wide median and average** nightly price, how many listings that covers (the whole market), the rough price range, and one-click links to the live searches for your exact dates.
- **Transport options** — cheapest-first flights (and buses/trains if enabled), with operator, price, duration, stops, and a booking link where available.
- **A trip overview** — your trip at a glance, which sources worked, and the Notion status.
- **A Notion page** *(if connected)* — the same itinerary, formatted in your workspace. Each run creates a fresh page.

Download the dataset as JSON, CSV, or Excel, or pull it from the API.

### Costs

A flat **$0.10 per run** — one trip, one answer — plus Apify's **platform usage** (compute) and the **price-check Actors' own fees**. In practice that's usually a few tens of cents all-in, most of it the **Booking.com** step (it runs a real browser to clear anti-bot protection); flights are cheap, and each extra source adds a little. A blocked source is simply skipped, and the rest of the plan still comes back.

We treat this as a **one-time task for personal use — no subscriptions, no recurring costs**: plan a trip, get your answer, done. If the price ever feels high, tell us on the **Issues** tab and we'll dig into cost-saving opportunities — we'd rather keep it lean than lose your trust.

### Use it from your AI assistant (MCP)

Call Travel Budget Planner as a tool from any MCP client (Claude, Cursor, …) through **Apify's MCP server** — just ask *"plan Berlin → Lisbon, July 1–4 for two."* The only credential is your **Apify API token** (Console → **Settings → Integrations → API tokens**).

```bash
claude mcp add --transport http apify-travel-planner \
  "https://mcp.apify.com?tools=inovaflow/travel-planner" \
  --header "Authorization: Bearer <YOUR_APIFY_TOKEN>"
````

Any MCP client works the same way (OAuth too). Travel Budget Planner can also **write to your Notion** through a Notion MCP connector — set it up once and every trip lands on a page.

### Notes

Travel Budget Planner reads **publicly visible prices** and aggregates results from specialized Apify Actors — it logs into nothing on your behalf and books nothing. Accommodation figures cover the **whole** market (the lowest/highest are approximate ends of the price range, not specific listings); transport comes from third-party scrapers, and Rome2Rio prices are rough and may be in another currency. Please respect each site's Terms of Service.

Found a bug, or want another route type, city, or currency? Open an issue on the **Issues** tab — custom tweaks on request.

# Actor input Schema

## `origin` (type: `string`):

Required. Where the trip starts — a city name or airport code.

## `destination` (type: `string`):

Required. Where you're going, as City, Country (e.g. Lisbon, Portugal).

## `checkIn` (type: `string`):

Required. First night of the stay.

## `checkOut` (type: `string`):

Required. Last morning of the stay. Must be after check-in, up to 90 nights.

## `guests` (type: `integer`):

Number of people the accommodation price is for. Default 1.

## `passengers` (type: `integer`):

Number of people the transport price is for. Default 1.

## `currency` (type: `string`):

Currency for all displayed prices. Default EUR.

## `sources` (type: `array`):

Which price sources to fetch. Leave empty to use the defaults (Airbnb prices + flights).

## `notionMcpConnector` (type: `string`):

The Notion MCP connector to save the itinerary to. Leave empty to skip Notion.

## `notionParentPageId` (type: `string`):

Notion page to file the itinerary under. Paste the full page link or bare ID. Leave empty to create a standalone page in your workspace.

## `apifyMcpConnector` (type: `string`):

Apify MCP connector whose account runs and pays for the price checks. Leave empty to run on your own Apify account.

## Actor input object example

```json
{
  "origin": "Berlin",
  "destination": "Lisbon, Portugal",
  "guests": 1,
  "passengers": 1,
  "currency": "EUR",
  "sources": [
    "price_index_airbnb",
    "flights"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per run: whole-market accommodation prices, the cheapest transport options, and a trip overview. Open the Accommodation and Transport views, or download as JSON, CSV, or Excel.

# 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 = {
    "origin": "Berlin",
    "destination": "Lisbon, Portugal"
};

// Run the Actor and wait for it to finish
const run = await client.actor("inovaflow/travel-planner").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 = {
    "origin": "Berlin",
    "destination": "Lisbon, Portugal",
}

# Run the Actor and wait for it to finish
run = client.actor("inovaflow/travel-planner").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 '{
  "origin": "Berlin",
  "destination": "Lisbon, Portugal"
}' |
apify call inovaflow/travel-planner --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Travel Budget Planner",
        "description": "Plan any trip: aggregates whole-market Airbnb & Booking.com nightly-price stats (median & average over the full market, via a price-histogram Actor) plus flights, buses and trains, in your chosen currency, and writes a formatted itinerary into your Notion via an MCP Connector.",
        "version": "0.1",
        "x-build-id": "2dW7x77whfQ7d3FkZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/inovaflow~travel-planner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-inovaflow-travel-planner",
                "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/inovaflow~travel-planner/runs": {
            "post": {
                "operationId": "runs-sync-inovaflow-travel-planner",
                "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/inovaflow~travel-planner/run-sync": {
            "post": {
                "operationId": "run-sync-inovaflow-travel-planner",
                "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": [
                    "origin",
                    "destination",
                    "checkIn",
                    "checkOut"
                ],
                "properties": {
                    "origin": {
                        "title": "From",
                        "type": "string",
                        "description": "Required. Where the trip starts — a city name or airport code."
                    },
                    "destination": {
                        "title": "To",
                        "type": "string",
                        "description": "Required. Where you're going, as City, Country (e.g. Lisbon, Portugal)."
                    },
                    "checkIn": {
                        "title": "Check-in",
                        "type": "string",
                        "description": "Required. First night of the stay."
                    },
                    "checkOut": {
                        "title": "Check-out",
                        "type": "string",
                        "description": "Required. Last morning of the stay. Must be after check-in, up to 90 nights."
                    },
                    "guests": {
                        "title": "Guests",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of people the accommodation price is for. Default 1.",
                        "default": 1
                    },
                    "passengers": {
                        "title": "Passengers",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of people the transport price is for. Default 1.",
                        "default": 1
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "EUR",
                            "USD",
                            "GBP",
                            "CHF",
                            "PLN"
                        ],
                        "type": "string",
                        "description": "Currency for all displayed prices. Default EUR.",
                        "default": "EUR"
                    },
                    "sources": {
                        "title": "Which prices to fetch",
                        "type": "array",
                        "description": "Which price sources to fetch. Leave empty to use the defaults (Airbnb prices + flights).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "price_index_airbnb",
                                "price_index_booking",
                                "flights",
                                "bus",
                                "rome2rio",
                                "airbnb",
                                "booking"
                            ],
                            "enumTitles": [
                                "Airbnb prices — typical (median & average) across the whole market",
                                "Booking.com prices — same, but slower & costlier (uses a browser)",
                                "Flights — cheapest fares",
                                "Buses + trains — bookable fares with times",
                                "Rome2Rio — rough route prices (often USD)",
                                "Airbnb listings — a few real places, with links",
                                "Booking.com listings — a few real places, with links"
                            ]
                        },
                        "default": [
                            "price_index_airbnb",
                            "flights"
                        ]
                    },
                    "notionMcpConnector": {
                        "title": "Save the trip to Notion",
                        "type": "string",
                        "description": "The Notion MCP connector to save the itinerary to. Leave empty to skip Notion."
                    },
                    "notionParentPageId": {
                        "title": "Notion page to file it under",
                        "type": "string",
                        "description": "Notion page to file the itinerary under. Paste the full page link or bare ID. Leave empty to create a standalone page in your workspace."
                    },
                    "apifyMcpConnector": {
                        "title": "Run the price checks under a different Apify account",
                        "type": "string",
                        "description": "Apify MCP connector whose account runs and pays for the price checks. Leave empty to run on your own Apify account."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```