# Polarsteps Trip Scraper: Steps, Photos, GPS Track & GPX (`alexmorain/polarsteps-trip-scraper`) Actor

Export a full Polarsteps trip: every step with text, photos, videos and weather, the GPS track, routes with transport mode, the planned itinerary and comments. Public trips, private share links and whole profiles. GPX and GeoJSON files included.

- **URL**: https://apify.com/alexmorain/polarsteps-trip-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Travel, Social media, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 steps

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Polarsteps Trip Scraper do?

**Polarsteps Trip Scraper** exports everything a [Polarsteps](https://www.polarsteps.com/) trip contains. You get **one row per step**, roughly one per travel day, with its story, date, place, **weather**, **photos and videos** in full resolution and, if you want them, the **comments**. The rest of the trip comes as files: the **GPS track** recorded by the app, the **routes** between steps with their transport mode, the **planned itinerary**, and a **GPX** and a **GeoJSON** file ready for a map.

It works on public trips, on **private trips through their share link** (the `?s=...` link from the app, no login needed) and on whole **profiles** (every public trip of a traveler). It reads the same JSON API as the Polarsteps website, over plain HTTP, so it is fast. There is no official Polarsteps API: this is the closest thing to one.

#### The GPS track most tools miss

Polarsteps stopped sending the tracker points in recent versions of its API. A tool that asks for the latest version gets the steps and an empty track, with no error. Measured on 17 October 2026 on a public trip:

| Polarsteps API version | Steps | GPS track points |
|---|---|---|
| 51 to 64 | 188 | 7,424 |
| 65 and later | 188 | **0** |

This Actor asks for version 62, the one the Polarsteps website uses, and gets the full track. If Polarsteps retires that version, it steps down to the next one that still answers.

### Why scrape Polarsteps?

- **Back up your own trips.** The official data export is a zip of folders that nothing can open. This gives you one readable table per trip, a line per step, with links to every photo in full resolution.
- **Put a trip on a map.** Load the GPX in Google Earth, Komoot, Strava or Garmin, or the GeoJSON in QGIS, Mapbox, Leaflet or kepler.gl.
- **Build a travel blog or a site.** Pull a trip's steps, texts and photos into WordPress, Notion, Airtable or your own page, and schedule the run to keep it in sync while you travel.
- **Research travel and mobility.** Routes with transport modes, time spent per place and country sequences, from trips that travelers chose to publish.
- **Plan from real trips.** Planned itineraries, stops, nights and the spots travelers recommend.

On Apify you also get scheduling, an API for every run, webhooks, and integrations with Make, Zapier, n8n, Google Sheets and more.

### What data can Polarsteps Trip Scraper extract?

Each dataset row is one step:

| Field | What it holds |
|---|---|
| `tripName`, `tripUrl`, `stepNumber`, `tripStepCount` | The trip the step belongs to, and its position in it |
| `name`, `description`, `url` | Step title, the story written by the traveler, public page |
| `startTime`, `endTime`, `timezone` | When the step happened |
| `locality`, `region`, `country`, `countryCode`, `lat`, `lon` | Where |
| `weatherCondition`, `temperatureC` | Weather recorded by Polarsteps |
| `photoCount`, `videoCount`, `mainPhotoUrl` | Media counts and the first photo |
| `media[]` | Every photo and video: full resolution URL, thumbnails, width, height, video duration |
| `spots[]` | Places the traveler recommends, with category, tip and address |
| `comments[]` | Text, date, author username and name (when comments are switched on) |
| `tripFileUrl`, `gpxUrl`, `geojsonUrl` | Links to the trip files |

The trip file `trip-<id>.json` holds the trip summary (dates, distance, views, likes, countries, traveler), the GPS track (time, latitude, longitude, place of every point), the routes with transport mode and decoded path, and the planned itinerary.

### How to scrape a Polarsteps trip

1. Open the trip on polarsteps.com or in the app and copy its link. For a private trip, tap **Share** in the app and copy the link that ends with `?s=...`.
2. Paste it in **Trip URLs**. To get every public trip of someone, put their username in **Profiles** instead.
3. Pick what to include: GPS track, routes, planned itinerary, comments.
4. Click **Start**.
5. Download the trips as JSON, CSV or Excel from the **Output** tab, and the GPX and GeoJSON files from the run's key-value store.

### How much does it cost to scrape Polarsteps?

You pay per step: **$0.01 per step**, so **$1 for a 100-step trip**, plus $0.005 when the run starts. The GPS track, routes, planned itinerary, comments and the GPX, GeoJSON and trip files are included. Private trips without a valid link and unknown trips are not charged.

A trip of 90 steps and 3,000 GPS points takes a few seconds. A four-year world trip of 548 steps, 11,000 photos and 47,000 GPS points takes under a minute without comments, and about 13 minutes with the comments of its 385 commented steps. To cap the cost of a run, set a maximum charge in the run options: the Actor stops cleanly when it is reached.

### Input

See the **Input** tab for every option. The only required thing is at least one trip link or one username.

```json
{
    "tripUrls": ["https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip"],
    "profiles": ["takemeeverywhere"],
    "maxTripsPerProfile": 3,
    "includeTrackPoints": true,
    "includeComments": false
}
```

Trip links can be the trip page, a private share link, the link of any step of the trip, or the bare trip ID.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. One row per step, shortened here:

```json
{
    "tripId": "11306874",
    "tripName": "Clark Family 2024 Around the World Trip",
    "tripUrl": "https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip",
    "stepNumber": 1,
    "tripStepCount": 93,
    "name": "Bloomington",
    "description": "Fully packed and ready to go...",
    "startTime": "2024-05-25T12:13:44.650000+00:00",
    "locality": "Bloomington",
    "country": "USA",
    "countryCode": "US",
    "lat": 40.483433,
    "lon": -88.91467,
    "weatherCondition": "partly-cloudy-day",
    "temperatureC": 25.0,
    "photoCount": 4,
    "mainPhotoUrl": "https://polarsteps.s3.amazonaws.com/user_images/steps/full_res/...",
    "media": [{"type": "photo", "url": "https://polarsteps.s3.amazonaws.com/...", "width": 2631, "height": 3508}],
    "tripFileUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/trip-11306874.json",
    "gpxUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/trip-11306874.gpx",
    "geojsonUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/trip-11306874.geojson"
}
```

The trip file, shortened:

```json
{
    "tripId": "11306874",
    "name": "Clark Family 2024 Around the World Trip",
    "startDate": "2024-05-25T05:00:00+00:00",
    "endDate": "2024-08-04T04:59:59+00:00",
    "totalKm": 73450.7,
    "stepCount": 93,
    "countryCount": 13,
    "trackPoints": [{"time": "2024-05-25T05:46:25+00:00", "lat": 40.426905, "lon": -88.878988, "locality": "Bloomington", "countryCode": "US"}],
    "routeSegments": [{"transportMode": "flight", "toStepId": "103606406", "coordinates": [[41.98008, -87.89111], [37.61741, -122.38283]]}],
    "plannedSteps": [{"name": "Bloomington", "plannedDate": "2024-08-03T05:00:00+00:00", "nights": null}]
}
```

The **Steps** view of the dataset shows the trip as a table, one line per step with its photo, ready to read or paste in a spreadsheet.

### Tips and advanced options

- **Very long trips.** When the trip file would pass 8.5 MB (years of travel, tens of thousands of GPS points), the GPS track and then the routes go to their own files, linked in `splitFields` of the trip file. Nothing is dropped.
- **Steps only.** Switch off the GPS track and routes for a lighter trip file. The GPX and GeoJSON files keep the full track anyway.
- **Comments are slower.** Polarsteps limits how fast comments can be read, so a trip with hundreds of commented steps takes several minutes. They cost nothing extra.
- **Keep a live trip in sync.** Schedule the Actor every day on an ongoing trip and send the result to your site with a webhook or an integration.

### FAQ

#### Can it scrape a private Polarsteps trip?

Yes, if you have its share link. In the Polarsteps app, open the trip, tap Share and copy the link with `?s=...`. Without that link a private trip answers "private" and is not charged.

#### Does it download the photos?

It gives the full resolution URL of every photo and video, plus two thumbnail sizes. Feed those URLs to any downloader to save the files.

#### Do I need a Polarsteps account or cookies?

No. Public trips and share links are read without any login.

#### Is there an official Polarsteps API?

No public one. This Actor reads the JSON API behind polarsteps.com, the same one the website uses.

#### Is it legal to scrape Polarsteps?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Comments only carry the author's public username and name, never their picture or home town.

#### Something is missing or broken?

Open an issue in the **Issues** tab and it gets fixed. To call the Actor from your code, see the **API** tab.

This Actor is not affiliated with, endorsed by or connected to Polarsteps.

# Actor input Schema

## `tripUrls` (type: `array`):

Polarsteps trip links or trip IDs. Accepted forms:<br>• <code>https://www.polarsteps.com/\<user>/\<tripId>-\<name></code><br>• the share link of a private trip, ending with <code>?s=...</code><br>• the link of a single step (the whole trip is collected)<br>• a numeric trip ID such as <code>11306874</code>

## `profiles` (type: `array`):

Polarsteps usernames or profile links, such as <code>takemeeverywhere</code> or <code>https://www.polarsteps.com/takemeeverywhere</code>. Every public trip of each profile is collected, most recent first.

## `maxTripsPerProfile` (type: `integer`):

Stop after this many trips for each profile, most recent first. 0 collects them all.

## `includeTrackPoints` (type: `boolean`):

Every point recorded by the Polarsteps tracker (time, coordinates, place), saved in the trip file <code>trip-\<id>.json</code>. Often thousands of points per trip. The GPX and GeoJSON files keep the track either way.

## `includeRouteSegments` (type: `boolean`):

The legs between steps with their transport mode (flight, car, train, motorbike...) and the decoded path, saved in the trip file.

## `includePlannedSteps` (type: `boolean`):

The planned stops of the trip, with planned date, nights and visit date, saved in the trip file.

## `includeComments` (type: `boolean`):

Comments left on each step, with the author's username and name, in the step rows. Included in the step price. Polarsteps limits how fast comments can be read, so a trip with hundreds of commented steps takes several minutes.

## `exportGpxGeojson` (type: `boolean`):

Saves <code>trip-\<id>.gpx</code> and <code>trip-\<id>.geojson</code> in the run's key-value store, ready for Google Earth, Komoot, Strava, QGIS or Mapbox. Links are in <code>gpxUrl</code> and <code>geojsonUrl</code> of every row.

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

Not needed: Polarsteps answers without a proxy. Use it only if your runs get refused.

## Actor input object example

```json
{
  "tripUrls": [
    "https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip"
  ],
  "maxTripsPerProfile": 0,
  "includeTrackPoints": true,
  "includeRouteSegments": true,
  "includePlannedSteps": true,
  "includeComments": false,
  "exportGpxGeojson": true
}
```

# Actor output Schema

## `results` (type: `string`):

All steps, one row each, with their trip, place, weather, photos and videos.

## `files` (type: `string`):

trip-<id>.json (summary, GPS track, routes, planned itinerary), trip-<id>.gpx and trip-<id>.geojson for each trip.

# 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 = {
    "tripUrls": [
        "https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/polarsteps-trip-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 = { "tripUrls": ["https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip"] }

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/polarsteps-trip-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 '{
  "tripUrls": [
    "https://www.polarsteps.com/clarkrtwtravel/11306874-clark-family-2024-around-the-world-trip"
  ]
}' |
apify call alexmorain/polarsteps-trip-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/polarsteps-trip-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/Mt2XIqJOIPJ5w8iww/builds/t3ePe8tBcQvVXpkNq/openapi.json
