# Google Maps Directions Scraper (`thescrappa/google-maps-directions-scraper`) Actor

Compare driving, walking, cycling, and transit routes between locations through Scrappa. Process up to 10 route requests in one run and receive one dataset row per returned route alternative.

- **URL**: https://apify.com/thescrappa/google-maps-directions-scraper.md
- **Developed by:** [Scrappa](https://apify.com/thescrappa) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 route results

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

## Google Maps Directions Scraper

Compare Google Maps route alternatives through Scrappa. Use driving, walking, cycling, or transit directions for travel planning, delivery estimates, commute comparisons, and logistics workflows.

This is a thin, paid Apify wrapper around Scrappa's Maps Directions endpoint (`/api/maps/directions`). Scraping runs on Scrappa infrastructure; one Apify run can process a batch of route requests.

### Features

- Process up to 10 unique origin/destination requests in one run
- Compare driving, walking, bicycling/cycling, and transit routes
- Receive one dataset row per returned route alternative
- Preserve distance, duration, formatted values, via labels, trips, step coordinates, travel mode, and source request metadata when available
- Continue after an individual route failure and report requested, succeeded, failed, saved, and charged counts in the run log
- Charge **$0.0005 per successfully stored route alternative** through the `route-result` event
- Keep failed requests and empty or malformed responses uncharged

### Input

Use the preferred `routes` array for batches:

```json
{
  "routes": [
    {
      "origin": "Berlin Hauptbahnhof",
      "destination": "Brandenburg Gate",
      "mode": "walking",
      "hl": "en",
      "gl": "de"
    },
    {
      "origin": "Alexanderplatz, Berlin",
      "destination": "Berlin Airport",
      "mode": "transit"
    }
  ]
}
````

`origin` and `destination` are also accepted as singular compatibility fields, together with singular `mode`, `hl`, and `gl`. Locations are trimmed, equivalent requests are deduplicated in first-seen order, and a run accepts at most 10 unique routes. `mode` defaults to `driving`, `hl` defaults to `en`, and `cycling` is sent to Scrappa as `bicycling`.

### Output

Each returned alternative is one dataset item. The row retains the Scrappa alternative payload and includes stable metadata:

```json
{
  "alternative_index": 0,
  "request_index": 0,
  "request_origin": "Berlin Hauptbahnhof",
  "request_destination": "Brandenburg Gate",
  "request_mode": "walking",
  "request_hl": "en",
  "request_gl": "de",
  "travel_mode": "Walking",
  "via": "B2/B5",
  "distance": 1821,
  "duration": 1501,
  "formatted_distance": "1.8 km",
  "formatted_duration": "25 min",
  "step_coordinates": [{ "latitude": 52.52104335, "longitude": 13.37325815 }],
  "trips": []
}
```

Optional response fields are preserved when Scrappa returns them; missing mode-specific details are not fabricated. Failed routes appear in the run summary and do not create charged route rows. Dataset output is the primary result channel and the actor does not write per-item key-value-store records.

### Direct API

For higher-volume routing, recurring logistics workflows, and direct API access, upgrade to Scrappa at https://scrappa.co. The underlying endpoint is `/api/maps/directions`.

# Actor input Schema

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

Preferred batch input. One request is created for each route object; duplicate requests are processed once. Maximum 10 route requests per run.

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

Singular compatibility input. Use routes for batches.

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

Singular compatibility input. Use routes for batches.

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

Travel mode: driving, walking, bicycling/cycling, or transit.

## `hl` (type: `string`):

Language code for route labels, such as en or de-DE.

## `gl` (type: `string`):

Two-letter country or region code for geo-filtering.

## Actor input object example

```json
{
  "mode": "driving",
  "hl": "en"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrappa/google-maps-directions-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thescrappa/google-maps-directions-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 '{}' |
apify call thescrappa/google-maps-directions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Directions Scraper",
        "description": "Compare driving, walking, cycling, and transit routes between locations through Scrappa. Process up to 10 route requests in one run and receive one dataset row per returned route alternative.",
        "version": "1.0",
        "x-build-id": "WyXaXBr5ncpnhxIpl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrappa~google-maps-directions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrappa-google-maps-directions-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/thescrappa~google-maps-directions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrappa-google-maps-directions-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/thescrappa~google-maps-directions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrappa-google-maps-directions-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": {
                    "routes": {
                        "title": "Routes",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Preferred batch input. One request is created for each route object; duplicate requests are processed once. Maximum 10 route requests per run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "origin",
                                "destination"
                            ],
                            "properties": {
                                "origin": {
                                    "title": "Origin",
                                    "description": "Starting address, place name, or coordinates.",
                                    "type": "string",
                                    "editor": "textfield",
                                    "minLength": 1,
                                    "maxLength": 200
                                },
                                "destination": {
                                    "title": "Destination",
                                    "description": "Ending address, place name, or coordinates.",
                                    "type": "string",
                                    "editor": "textfield",
                                    "minLength": 1,
                                    "maxLength": 200
                                },
                                "mode": {
                                    "title": "Mode",
                                    "description": "Travel mode: driving, walking, bicycling/cycling, or transit.",
                                    "type": "string",
                                    "editor": "select",
                                    "enum": [
                                        "driving",
                                        "walking",
                                        "bicycling",
                                        "cycling",
                                        "transit"
                                    ],
                                    "default": "driving"
                                },
                                "hl": {
                                    "title": "Language",
                                    "description": "Language code for route labels, such as en or de-DE.",
                                    "type": "string",
                                    "editor": "textfield",
                                    "pattern": "^[a-zA-Z]{2}(?:-[a-zA-Z]{2})?$",
                                    "maxLength": 5,
                                    "default": "en"
                                },
                                "gl": {
                                    "title": "Region",
                                    "description": "Two-letter country or region code for geo-filtering.",
                                    "type": "string",
                                    "editor": "textfield",
                                    "pattern": "^[a-zA-Z]{2}$",
                                    "maxLength": 2
                                }
                            }
                        }
                    },
                    "origin": {
                        "title": "Origin (compatibility)",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Singular compatibility input. Use routes for batches."
                    },
                    "destination": {
                        "title": "Destination (compatibility)",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Singular compatibility input. Use routes for batches."
                    },
                    "mode": {
                        "title": "Mode (compatibility)",
                        "enum": [
                            "driving",
                            "walking",
                            "bicycling",
                            "cycling",
                            "transit"
                        ],
                        "type": "string",
                        "description": "Travel mode: driving, walking, bicycling/cycling, or transit.",
                        "default": "driving"
                    },
                    "hl": {
                        "title": "Language (compatibility)",
                        "pattern": "^[a-zA-Z]{2}(?:-[a-zA-Z]{2})?$",
                        "maxLength": 5,
                        "type": "string",
                        "description": "Language code for route labels, such as en or de-DE.",
                        "default": "en"
                    },
                    "gl": {
                        "title": "Region (compatibility)",
                        "pattern": "^[a-zA-Z]{2}$",
                        "maxLength": 2,
                        "type": "string",
                        "description": "Two-letter country or region code for geo-filtering."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
