# Skiplagged Scraper 💰$2.50/1k — Flights & Hotels (`memo23/skiplagged-scraper`) Actor

Skiplagged flights, hidden-city fares, flex calendars, and hotel rates in one actor. One JSON or CSV row per itinerary, date, or hotel — airlines, stops, and times included. Search by route, paste a /flights/ or /hotels/ URL, or set destination to anywhere. $2.50 per 1,000 results.

- **URL**: https://apify.com/memo23/skiplagged-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 result rows

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Skiplagged Scraper — Hidden-City Fares, Calendars, Hotels

Turn a Skiplagged route, `/flights/` URL, or hotel city into structured rows: itineraries (price, airlines, stops, hidden-city flag, booking partners), a flexible-date min/max calendar, or hotel nightly rates. One-way, round-trip, anywhere, or a batch of routes. JSON or CSV out. **$1 / 1,000 results.**

### Why Use This Scraper?

- Search by airport/metro code, a batch of routes, a pasted Skiplagged URL, or `destination: anywhere`
- Hidden-city and self-transfer itineraries, with include/exclude filters
- Flexible-date calendar (`mode: flexible`) and Skiplagged hotel rates (`mode: hotels`)
- Time-of-day, airline allow/deny, price band, nonstop, max stops
- Empty fields are omitted from each row
- Pure HTTP — no browser, no login, proxy optional
- **$1 / 1,000 results**

### Overview

Built for fare monitors, travel agencies, and anyone comparing Skiplagged against Google Flights or Skyscanner.

The dataset is **itinerary-shaped**. A round-trip search returns outbound and inbound rows, each tagged with `legType`. Combined Skiplagged totals land on outbound rows as `minRoundTripPrice`.

Skiplagged prices each leg as its own one-way ticket. That is how hidden-city and self-transfer deals are quoted on the site, and the actor mirrors it.

### Supported Inputs

| Input | Pattern | Example |
|---|---|---|
| Route fields | IATA or metro code + dates | `origin: NYC`, `destination: LON`, `departDate: 2026-10-11` |
| Round-trip | add `returnDate` | `2026-10-18` |
| Batch routes | `mode: byRoutes` | `[{ "origin": "SFO", "destination": "TYO", "departDate": "2026-10-05" }]` |
| Skiplagged URL | `/flights/{ORIG}/{DEST}/{date}[/{return}]` | `https://skiplagged.com/flights/NYC/LON/2026-10-11/2026-10-18` |
| Anywhere | `destination: anywhere` or `/flights/NYC/anywhere/{date}` | popular dests from the origin |
| Flexible dates | `mode: flexible` | one calendar row per date (min/max USD) |
| Hotels | `mode: hotels` + `hotelCity` | nightly + stay total, stars, reviews |

Metro codes work the same as on skiplagged.com: `NYC` covers JFK/LGA/EWR, `LON` covers LHR/LGW/STN/LTN/LCY.

**Not supported:** account/login URLs, or Skiplagged's official MCP server. This actor reads the public search, flex, and hotel JSON endpoints.

#### Copy-pasteable startUrls

```json
{
  "mode": "byUrls",
  "startUrls": [
    "https://skiplagged.com/flights/NYC/LON/2026-10-11/2026-10-18",
    "https://skiplagged.com/flights/JFK/LAX/2026-10-11"
  ]
}
```

### Use Cases

| Who | What they do with the rows |
|---|---|
| Fare-alert products | Track a route over time and fire when price drops |
| Travel agencies | Compare provider quotes across a client batch in one run |
| Corporate travel | Bulk-check employee itineraries |
| Price-comparison tools | Feed live Skiplagged fares into another search product |
| Market research | Airline mix, stop counts, and hidden-city share on a route |

### How It Works

![How the Skiplagged Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-skiplagged.png)

1. **Your input** — origin, destination, and dates; a `routes` array; a Skiplagged `/flights/` or `/hotels/` URL; `anywhere`; or hotel city.
2. **Public JSON** — `search.php?format=v3` for itineraries (polled until complete), `flex.php` for calendars, `hotel_search.php` for hotels. No browser.
3. **Join + flatten** — itineraries join to flight segments. Prices (US cents) become USD; durations (seconds) become minutes.
4. **Filters** — nonstop, stops, price, airline allow/deny, hidden-city, depart/arrive clock, sort, `maxItems`.
5. **Your dataset** — one row per itinerary, calendar date, or hotel. Empty fields are dropped.

### Input Configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byRoutes` / `byUrls` / `flexible` / `hotels` |
| `origin` | string | `NYC` | Origin IATA or metro code |
| `destination` | string | `LON` | Destination IATA, metro code, or `anywhere` |
| `departDate` | string | 6 weeks out | `YYYY-MM-DD` |
| `returnDate` | string | — | `YYYY-MM-DD`; omit for one-way |
| `routes` | array | — | `{origin, destination, departDate, returnDate}` objects |
| `startUrls` | array | — | Skiplagged `/flights/` URLs |
| `tripType` | string | `auto` | `auto` / `one-way` / `round-trip` |
| `cabinClass` | string | `economy` | Requested cabin; real `fareClass` is always on the row |
| `adults` / `children` / `infantsLap` / `infantsSeat` | int | 1 / 0 / 0 / 0 | Passenger mix (see FAQ) |
| `directOnly` | bool | `false` | Nonstop only |
| `maxStops` | int | — | Drop itineraries with more stops |
| `minPrice` / `maxPrice` | int | — | USD band |
| `airlines` | array | — | IATA allow-list (`AA`, `BA`, …) |
| `excludeAirlines` | array | — | IATA deny-list |
| `hiddenCityOnly` / `excludeHiddenCity` | bool | false | Keep or drop hidden-city rows |
| `departAfter` / `departBefore` / `arriveAfter` / `arriveBefore` | string | — | Local `HH:MM` clock filters |
| `flexDays` | int | — | Also search ±N days (max 7) |
| `hotelCity` / `rooms` | string / int | — | Hotel city (or slug / id) and room count |
| `sortBy` | string | `price` | `price` / `duration` / `departureTime` / `stops` |
| `maxItems` | int | `50` | Cap across all routes (1–1000) |
| `proxy` | object | off | Optional; the public API answers without a proxy |

#### Example: one-way

```json
{
  "mode": "search",
  "origin": "JFK",
  "destination": "LAX",
  "departDate": "2026-10-11",
  "directOnly": true,
  "maxItems": 20
}
```

#### Example: round-trip with a price cap

```json
{
  "mode": "search",
  "origin": "NYC",
  "destination": "LON",
  "departDate": "2026-10-11",
  "returnDate": "2026-10-18",
  "maxPrice": 800,
  "sortBy": "duration"
}
```

#### Example: batch routes

```json
{
  "mode": "byRoutes",
  "routes": [
    { "origin": "NYC", "destination": "LON", "departDate": "2026-10-11" },
    { "origin": "SFO", "destination": "TYO", "departDate": "2026-10-05", "returnDate": "2026-10-19" }
  ],
  "maxItems": 100
}
```

#### Example: hidden-city only, mornings

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departDate": "2026-10-11",
  "hiddenCityOnly": true,
  "departAfter": "06:00",
  "departBefore": "12:00"
}
```

#### Example: flexible-date calendar

```json
{
  "mode": "flexible",
  "origin": "JFK",
  "destination": "LAX",
  "departDate": "2026-10-23",
  "maxItems": 40
}
```

#### Example: anywhere from NYC

```json
{
  "origin": "NYC",
  "destination": "anywhere",
  "departDate": "2026-10-23",
  "maxItems": 40
}
```

#### Example: hotels

```json
{
  "mode": "hotels",
  "hotelCity": "New York",
  "departDate": "2026-10-23",
  "returnDate": "2026-10-30",
  "rooms": 1,
  "adults": 2,
  "maxItems": 30
}
```

### Output Overview

`recordType` is `skiplaggedFlight`, `skiplaggedCalendar`, or `skiplaggedHotel`. Round-trips emit outbound and inbound flight rows. Segments and layovers stay nested; empty fields are omitted.

Prices are USD. Skiplagged's API stores cents; the actor divides by 100.

### Output Samples

One-way JFK → LAX (live search, October 2026):

```json
{
  "flightId": "8b83695",
  "recordType": "skiplaggedFlight",
  "legType": "outbound",
  "originAirport": "JFK",
  "originCity": "New York",
  "destinationAirport": "LAX",
  "destinationCity": "Los Angeles",
  "departureTime": "2026-10-11T06:00:00-04:00",
  "arrivalTime": "2026-10-11T09:11:00-07:00",
  "duration": "6h 11m",
  "durationMinutes": 371,
  "stops": 0,
  "direct": true,
  "hiddenCity": false,
  "primaryAirline": "American Airlines",
  "airlineCodes": ["AA"],
  "price": 254,
  "currency": "USD",
  "fareClass": "economy",
  "bookingProviders": ["FAST"],
  "sourceUrl": "https://skiplagged.com/flights/JFK/LAX/2026-10-11"
}
```

Connecting NYC → LON (2 stops, round-trip quote on the outbound row):

```json
{
  "flightId": "001ada3",
  "legType": "outbound",
  "originAirport": "LGA",
  "destinationAirport": "LHR",
  "stops": 2,
  "direct": false,
  "duration": "29h",
  "primaryAirline": "Air Canada",
  "price": 298,
  "minRoundTripPrice": 706,
  "layovers": [
    { "airport": "YUL", "durationMinutes": 915, "duration": "15h 15m" },
    { "airport": "YOW", "durationMinutes": 297, "duration": "4h 57m" }
  ]
}
```

### Key Output Fields

**Route** — `originAirport`, `originCity`, `originState`, `originCountry`, `destinationAirport`, `destinationCity`, `legType`, `sourceUrl`

**Schedule** — `departureTime`, `arrivalTime`, `duration`, `durationMinutes`, `stops`, `direct`, `segments[]`, `layovers[]`

**Money** — `price`, `currency`, `minRoundTripPrice`, `fareClass`, `requestedCabinClass`

**Carriers** — `primaryAirline`, `airlines[]`, `airlineCodes[]`, `bookingProviders[]` (names), `bookingProviderCodes[]`

**Flags** — `hiddenCity`, `recordType`, `flightId`, `bookingUrl`, `scrapedAt`

**Calendar** — `departDate`, `returnDate`, `minPrice`, `maxPrice`

**Hotel** — `hotelId`, `name`, `nightlyPrice`, `price`, `starRating`, `reviewScore`, `photos[]`

### FAQ

#### Which Skiplagged URLs are supported?

Flight-search pages: `https://skiplagged.com/flights/{ORIG}/{DEST}/{YYYY-MM-DD}` (including `/anywhere/`). Hotel pages: `https://skiplagged.com/hotels/{city}/{checkin}/{checkout}`. Homepage and account URLs are ignored.

#### Why does a round-trip return two rows?

Skiplagged prices each leg as its own one-way ticket. Outbound rows carry `minRoundTripPrice` when Skiplagged quoted a combined total.

#### What is `hiddenCity`?

`true` when the last landing airport is not one of the airports for the destination you asked for — the classic “fly toward X, get off at Y” pattern Skiplagged is known for. Baggage and missed-leg rules still apply; confirm on skiplagged.com before booking.

#### Why is `fareClass` still economy when I asked for business?

Skiplagged's public search mostly returns economy inventory. The row always reports the cabin Skiplagged actually sent (`fareClass`) next to your `requestedCabinClass`.

#### Why don't passenger counts change the price?

Passenger counts are sent on the search URL. The logged-out API often still prices 1 adult. Output `adults` / `children` / `infantsLap` / `infantsSeat` are whatever Skiplagged returned for that itinerary.

#### What does `bookingProviders` mean?

Partner names (Fast, Orbitz, Expedia, …) mapped from Skiplagged's source codes. `bookingProviderCodes` keeps the raw codes (`FAST`, `ORB`). `bookingUrl` is the Skiplagged search or hotel page where you complete the booking — book.php is a POST form, not a GET deep link.

#### Do I need a proxy?

Locally, usually no. On the Apify platform the actor uses a RESIDENTIAL proxy on its own — Skiplagged 403s datacenter IPs. Override `proxy` if you want different groups.

#### How fresh are the prices?

They match what skiplagged.com shows at the moment the run hits the API. Fares move quickly; confirm before booking.

### Support

Found a bug or need a field that isn't exposed? Open an issue on the actor's [Issues tab](https://apify.com/memo23/skiplagged-scraper/issues) or reach out via the [Apify Store profile](https://apify.com/memo23). Include your input JSON and the run ID.

### Additional Services

Need a custom flight pipeline, a different source, scheduled delivery, or fare-alert wiring? Custom scraping work is available via the Apify Store profile.

### Explore More Scrapers

- [Google Flights Scraper](https://apify.com/memo23/google-flights-scraper) — fares, multi-city, booking options
- [Skyscanner Flight Scraper](https://apify.com/memo23/skyscanner-scraper) — 180+ fields, Best/Cheapest/Fastest tags
- [Ryanair Scraper](https://apify.com/memo23/ryanair-scraper) — budget fares Google under-shows
- [Award Flights Scraper](https://apify.com/memo23/award-flights-scraper) — miles and points availability

Full list at [apify.com/memo23](https://apify.com/memo23).

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/skiplagged-scraper`).

**Purpose:** Scrapes Skiplagged — one dataset row per priced itinerary, flexible-date calendar cell, or hotel.

**Minimal input:**

```json
{
  "origin": "JFK",
  "destination": "LAX",
  "departDate": "2026-10-11",
  "maxItems": 20
}
```

**Output:** `recordType=skiplaggedFlight|skiplaggedCalendar|skiplaggedHotel`. Flight rows include `flightId`, `legType`, airports, times, `duration`, `stops`, `hiddenCity`, `primaryAirline`, `segments`, `layovers`, `price`, `bookingProviders`, `bookingUrl`, `sourceUrl`.

**Behaviors an agent should know:**

- Always set `maxItems` (default 50, max 1000). A busy round-trip or hotel city can return hundreds of rows.
- `destination: anywhere` expands to popular dests via hint.php (origin metro/airports dropped).
- `mode=flexible` hits flex.php (min/max per date). `mode=hotels` hits hotel\_search.php.
- `mode=byUrls` reads `/flights/…` and `/hotels/…` paths.
- Round-trip searches emit separate outbound and inbound rows.
- Billing is pay-per-event: actor start + $0.001 per dataset row ($1 / 1,000).
- No login, no browser. Passenger mix is sent on the URL; logged-out pricing is often still 1 adult.

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Skiplagged, Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Skiplagged flight-search results — no authenticated endpoints, paid features, or content behind a login wall. Users are responsible for ensuring their use complies with skiplagged.com's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

***

### SEO Keywords

Skiplagged scraper, scrape Skiplagged, Skiplagged API, Skiplagged flight scraper, hidden city flight scraper, Skiplagged.com scraper, Apify Skiplagged, flight fare scraper, cheap flight data API, hidden-city itinerary export, fare monitoring scraper, travel price comparison data, airline route intelligence, self-transfer flight scraper, flight search API

# Actor input Schema

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

How to build the search. `search` uses origin/destination. `byRoutes` reads the Routes array. `byUrls` reads pasted Skiplagged /flights/ or /hotels/ URLs. `flexible` returns a date-by-date min/max price calendar. `hotels` searches Skiplagged hotel rates.

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

Origin IATA airport code (e.g. `JFK`) or metro/city code (e.g. `NYC` covers JFK, LGA, EWR). Defaults to NYC if empty.

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

Destination IATA airport code (e.g. `LHR`) or metro/city code (e.g. `LON` covers LHR, LGW, STN, LTN, LCY). Use `anywhere` to fan out to popular destinations from the origin. Defaults to LON if empty.

## `departDate` (type: `string`):

Departure date as YYYY-MM-DD. Leave blank to default to 6 weeks from today so a bare Start always searches a future date.

## `returnDate` (type: `string`):

Return date as YYYY-MM-DD for a round-trip search. Leave blank for one-way.

## `routes` (type: `array`):

Batch of routes for one run. Each item: `{"origin":"NYC","destination":"LON","departDate":"2026-10-11","returnDate":"2026-10-18"}` (`returnDate` optional).

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

Skiplagged flight or hotel URLs, e.g. `https://skiplagged.com/flights/NYC/LON/2026-10-11/2026-10-18` or `https://skiplagged.com/hotels/new-york-ny/2026-10-23/2026-10-30`.

## `tripType` (type: `string`):

One-way or round-trip. `auto` follows whether a return date is present. `round-trip` with no return date adds a +7 day return.

## `cabinClass` (type: `string`):

Preferred cabin. Skiplagged's public search mostly returns economy; each row still reports the real `fareClass` Skiplagged sent back.

## `adults` (type: `integer`):

Adult passengers (12+). Passed through on the search URL. Logged-out Skiplagged often still prices 1 adult; the row reports whatever came back.

## `children` (type: `integer`):

Child passengers (2–11).

## `infantsLap` (type: `integer`):

Lap infants (under 2, no seat).

## `infantsSeat` (type: `integer`):

Infants (under 2) with their own seat.

## `directOnly` (type: `boolean`):

Only emit nonstop itineraries.

## `maxStops` (type: `integer`):

Drop itineraries with more stops than this. Leave empty for any number of stops.

## `minPrice` (type: `integer`):

Drop itineraries cheaper than this (whole USD).

## `maxPrice` (type: `integer`):

Drop itineraries pricier than this (whole USD).

## `airlines` (type: `array`):

Only emit itineraries that include at least one of these 2-letter IATA airline codes, e.g. `AA`, `BA`, `DL`.

## `excludeAirlines` (type: `array`):

Drop itineraries that include any of these 2-letter IATA codes.

## `hiddenCityOnly` (type: `boolean`):

Only emit rows where the last landing airport is not the destination you asked for.

## `excludeHiddenCity` (type: `boolean`):

Drop hidden-city / skiplag itineraries. Ignored when Hidden-city only is on.

## `departAfter` (type: `string`):

Keep itineraries whose first-segment departure is at or after this local time, e.g. `08:00`.

## `departBefore` (type: `string`):

Keep itineraries whose first-segment departure is at or before this local time, e.g. `22:00`.

## `arriveAfter` (type: `string`):

Keep itineraries whose last-segment arrival is at or after this local time.

## `arriveBefore` (type: `string`):

Keep itineraries whose last-segment arrival is at or before this local time.

## `flexDays` (type: `integer`):

In search / byRoutes / byUrls, also search this many days before and after `departDate` (max 7). Ignored in flexible-calendar mode (that mode already returns a date window).

## `hotelCity` (type: `string`):

City name, Skiplagged city slug (`new-york-ny`), or numeric city id. Falls back to `destination` if empty.

## `rooms` (type: `integer`):

Rooms for hotel search. Default 1.

## `sortBy` (type: `string`):

Order of emitted records.

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

Hard cap on emitted records (per run, across all routes). Default 50.

## `proxy` (type: `object`):

Optional locally. On the Apify platform the actor uses a RESIDENTIAL proxy automatically — Skiplagged 403s datacenter IPs. Override here if you want your own groups or proxy URLs.

## Actor input object example

```json
{
  "mode": "search",
  "origin": "NYC",
  "destination": "LON",
  "departDate": "2026-10-11",
  "returnDate": "2026-10-18",
  "routes": [],
  "startUrls": [
    "https://skiplagged.com/flights/NYC/LON/2026-10-11/2026-10-18"
  ],
  "tripType": "auto",
  "cabinClass": "economy",
  "adults": 1,
  "children": 0,
  "infantsLap": 0,
  "infantsSeat": 0,
  "directOnly": false,
  "airlines": [
    "AA",
    "BA"
  ],
  "excludeAirlines": [
    "FR",
    "W6"
  ],
  "hiddenCityOnly": false,
  "excludeHiddenCity": false,
  "departAfter": "08:00",
  "departBefore": "22:00",
  "arriveAfter": "10:00",
  "arriveBefore": "18:00",
  "hotelCity": "New York",
  "rooms": 1,
  "sortBy": "price",
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `flights` (type: `string`):

Dataset containing all scraped Skiplagged flight itineraries.

# 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",
    "origin": "NYC",
    "destination": "LON",
    "routes": [],
    "startUrls": [],
    "tripType": "auto",
    "cabinClass": "economy",
    "sortBy": "price"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/skiplagged-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",
    "origin": "NYC",
    "destination": "LON",
    "routes": [],
    "startUrls": [],
    "tripType": "auto",
    "cabinClass": "economy",
    "sortBy": "price",
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/skiplagged-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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",
  "origin": "NYC",
  "destination": "LON",
  "routes": [],
  "startUrls": [],
  "tripType": "auto",
  "cabinClass": "economy",
  "sortBy": "price"
}' |
apify call memo23/skiplagged-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/skiplagged-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/LL3cenmaTXUft2DjG/builds/OpAX9s8wtLCLxTnXw/openapi.json