# Waze Real-time API (`parsebird/waze-api`) Actor

Live Waze traffic data API: accidents, hazards, police, road closures and traffic jams in any map area, Waze driving directions with ETA, tolls and on-route alerts, venues by category and place autocomplete.

- **URL**: https://apify.com/parsebird/waze-api.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 driving routes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### Waze Real-time API

**Waze Real-time API** gets live data from [Waze](https://www.waze.com/live-map/): accidents, hazards, police, road closures and traffic jams in any map area, Waze driving directions with travel time, tolls and incidents on the route, venues by category, and place autocomplete. Results come back as clean JSON, CSV or Excel, or through the Apify API.

<table><tr>
<td style="border-left:4px solid #33CCFF;padding:12px 16px;font-weight:600">
Draw a map rectangle anywhere Waze covers and get every live incident and jam with type, subtype, street, coordinates, jam level, speed, length and full polyline, or send start and end coordinates and get up to five Waze routes with ETA, distance, toll price, HOV flags and the alerts and jams on each route.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/waze-api (Waze Real-time API). Gets live Waze Live Map data. Call via ApifyClient: client.actor("parsebird/waze-api").call(run_input={"operation": "alertsAndJams", "bottomLeft": "40.66615,-74.13732", "topRight": "40.77278,-73.76818", "maxAlerts": 20, "maxJams": 20, "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED"}). Pick one operation per run: "alertsAndJams" | "drivingDirections" | "venues" | "autocomplete". Coordinates are strings "latitude,longitude". alertsAndJams and venues inputs: bottomLeft, topRight (map rectangle corners), mapAreas (array of extra areas "lat,lng;lat,lng"), maxAlerts (int, default 20, 0 skips alerts; Waze returns at most 200 per request and the actor splits large areas automatically), maxJams (int, default 20), alertTypes (comma list: ACCIDENT, HAZARD, POLICE, ROAD_CLOSED, JAM), alertSubtypes (comma list, e.g. HAZARD_ON_ROAD_CONSTRUCTION). drivingDirections inputs: sourceCoordinates, destinationCoordinates, routePairs (array "startLat,startLng;endLat,endLng"), maxRoutes (1-5, default 3), returnRouteCoordinates (bool, default false), arrivalTimestamp or departureTimestamp (Unix seconds). venues inputs: venueCategories (comma list, e.g. "gas station,parking,ev charging station"), maxVenues (default 100), onlyInsideArea (default true). autocomplete inputs: autocompleteQuery, autocompleteQueries (array), searchNear ("lat,lng"), maxResultsPerQuery (default 10), language (default "en"). Output: one flat row per item in the default dataset, tagged by recordType ("alert" | "jam" | "route" | "venue" | "place", plus "empty" or "error" rows for areas or queries without results). Alert fields: alertId, alertType, alertSubtype, alertDescription, street, latitude, longitude, reportBy, provider, numThumbsUp, publishDatetimeUtc, wazeUrl. Jam fields: jamId, street, city, endNode, jamLevel (0-5), speedKmh, lengthMeters, lineCoordinates, isBlocked, causeAlertType, updateDatetimeUtc. Route fields: routeName, durationSeconds, durationMinutes, lengthMeters, lengthKm, isFastest, isToll, tollPrice, tollCurrency, isHov, routeAlerts, routeJams, routeCoordinates. Venue/place fields: venueName, address, latitude, longitude, venueId, venueSource, venueCategory or query. Pricing: pay per event: "alert-query" per map area, "driving-route" per route returned, "venues-query" per map area, "autocomplete-query" per query. Full API spec: https://apify.com/parsebird/waze-api/api. Get your token: https://console.apify.com/settings/integrations.
```

### What is Waze Real-time API?

**Waze Real-time API** turns the [Waze Live Map](https://www.waze.com/live-map/) into structured data. Waze is a navigation app whose drivers report accidents, police, hazards and closures as they happen, and whose traffic layer shows where cars are moving slowly. This actor gives you that live Waze traffic data for any area you choose, plus Waze driving directions, without a Waze partnership or a Waze API key.

The easiest way to try it: keep **Alerts & Jams** selected with the prefilled New York City rectangle and click **Start**. In a minute or so you get the latest incidents and jams in Manhattan, Brooklyn, Queens and Jersey City as a table you can download. It works as a **Waze API alternative** for live traffic, incident monitoring and routing.

### What can Waze Real-time API do?

- 🚨 **Live alerts.** Accidents, hazards (construction, potholes, stopped cars, emergency vehicles...), police, road closures and jam reports in a map rectangle, newest first.
- 🚗 **Traffic jams.** Jam level from 0 to 5, average speed, length, street, city, the full jam polyline, and the alert that caused a closure.
- 🔍 **Filters.** Keep only the alert types or subtypes you need, for example `ACCIDENT,POLICE` or `HAZARD_ON_ROAD_CONSTRUCTION`.
- 🧩 **Past the 200-item limit.** Waze returns at most 200 alerts and 200 jams for one map view. When you ask for more, the actor splits the area into smaller tiles and merges the results without duplicates.
- 🗺️ **Driving directions.** Up to five Waze route alternatives per trip with travel time, distance, toll price (with and without a toll pass where Waze shows it), HOV requirements and the alerts and jams on each route. Plan for a departure or arrival time.
- 📍 **Venues and autocomplete.** Find gas stations, parking, EV chargers, restaurants and other places in an area, or get the same place suggestions as the Waze search box.
- 📦 **Batch runs.** Add many map areas, routes or search queries to one run.
- 🌍 **Worldwide.** Works in all three Waze regions (North America, Israel and the rest of the world); the actor picks the right one from your coordinates.
- 📅 **Scheduling, API and integrations.** Run every few minutes with [Apify Schedules](https://docs.apify.com/platform/schedules), call it from the [Apify API](https://docs.apify.com/api/v2), or send results to Google Sheets, Slack, Zapier, Make or webhooks with [Apify integrations](https://docs.apify.com/platform/integrations). Export as JSON, CSV, Excel, XML or HTML.

### What data can you extract from Waze?

| Field | Record type | Description |
|-------|-------------|-------------|
| `recordType` | all | `alert`, `jam`, `route`, `venue` or `place` (`empty` / `error` rows explain areas or queries with no result) |
| `alertType`, `alertSubtype` | alert | `ACCIDENT`, `HAZARD`, `POLICE`, `ROAD_CLOSED`, `JAM` and subtypes such as `HAZARD_ON_ROAD_CONSTRUCTION` |
| `alertDescription` | alert | Text description, when the reporter or partner added one |
| `street`, `latitude`, `longitude` | alert, jam | Location of the incident or the start of the jam |
| `reportBy`, `provider` | alert | Partner that reported the alert (e.g. a city or a towing service), when it isn't a regular Waze user |
| `publishDatetimeUtc` | alert | When the alert was reported |
| `jamLevel` | jam | Congestion level from 0 (free flow) to 5 (blocked) |
| `speedKmh`, `lengthMeters` | jam | Average speed on the jam and its length |
| `lineCoordinates` | jam | Full jam polyline as latitude/longitude points |
| `city`, `endNode` | jam | City and the street where the jam ends |
| `isBlocked`, `causeAlertType` | jam | Whether the road is closed, and the alert behind the closure |
| `routeName`, `durationMinutes`, `lengthKm` | route | Waze's route name, travel time and distance |
| `isFastest`, `isToll`, `tollPrice`, `tollCurrency`, `isHov` | route | Route flags and the estimated toll |
| `routeAlerts`, `routeJams` | route | Incidents and jams on the route |
| `routeCoordinates` | route | Full route polyline (when **Include route coordinates** is on) |
| `venueName`, `address`, `venueSource` | venue, place | Place name, address and whether it is a Waze or Google place |
| `wazeUrl` | alert, venue, place | Link that opens the point in Waze |

### How to use Waze Real-time API

1. Open [Waze Real-time API](https://apify.com/parsebird/waze-api) in Apify Console and sign in (or create a free Apify account).
2. Choose an **Operation**: Alerts & Jams, Driving Directions, Venues or Autocomplete.
3. For **Alerts & Jams** or **Venues**, enter the **Bottom-left corner** and **Top-right corner** of a rectangle as `latitude,longitude`. In Google Maps, right-click a point to copy its coordinates. Add more rectangles in **More map areas**.
4. For **Driving Directions**, enter a **Start point** and a **Destination**, and optionally an arrival or departure time.
5. For **Autocomplete**, type a search text and a **Search near** location.
6. Click **Start**, then download the results from the **Output** tab as JSON, CSV or Excel, or read them through the API.

### How much does Waze Real-time API cost?

Waze Real-time API uses **pay-per-event** pricing. Compute and proxy costs are included in the event prices; there are no other usage charges for the run.

| Event | When it's charged | Free | Bronze | Silver | Gold |
|-------|-------------------|------|--------|--------|------|
| `alert-query` | Once per successful Alerts & Jams query (one map area), with all its alerts and jams | $0.00999 | $0.00699 | $0.00599 | $0.00499 |
| `driving-route` | Per route returned by Driving Directions, including its on-route alerts and jams | $0.00399 | $0.00349 | $0.00299 | $0.00249 |
| `venues-query` | Once per successful Venues query (one map area), with all its venues | $0.00899 | $0.00799 | $0.00749 | $0.00699 |
| `autocomplete-query` | Once per successful Autocomplete query | $0.00899 | $0.00599 | $0.00499 | $0.00399 |

Per 1,000 events on the Free plan: $9.99 per 1,000 map areas, $3.99 per 1,000 routes, $8.99 per 1,000 venue areas and $8.99 per 1,000 autocomplete queries. For example, checking 50 delivery zones for incidents costs 50 × $0.00999 = $0.50 on the Free plan, and one trip with 3 alternative routes costs 3 × $0.00399 = $0.012. A map area is charged once, however many alerts it holds, including large areas the actor splits into tiles. Areas or queries that fail are not charged. Set a maximum cost per run in Apify Console and the actor stops when it's reached.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `operation` | string | **Yes** | `alertsAndJams` | `alertsAndJams`, `drivingDirections`, `venues` or `autocomplete` |
| `bottomLeft` | string | Yes\* | — | South-west corner, `latitude,longitude` (Alerts & Jams, Venues) |
| `topRight` | string | Yes\* | — | North-east corner, `latitude,longitude` (Alerts & Jams, Venues) |
| `mapAreas` | string\[] | No | — | More areas, each `bottomLeftLat,bottomLeftLng;topRightLat,topRightLng` |
| `maxAlerts` | integer | No | `20` | Max alerts per area (0 skips alerts) |
| `maxJams` | integer | No | `20` | Max jams per area (0 skips jams) |
| `alertTypes` | string | No | all | Comma list: `ACCIDENT,HAZARD,POLICE,ROAD_CLOSED,JAM` |
| `alertSubtypes` | string | No | all | Comma list of alert subtypes |
| `sourceCoordinates` | string | Yes\* | — | Route start, `latitude,longitude` (Driving Directions) |
| `destinationCoordinates` | string | Yes\* | — | Route end, `latitude,longitude` (Driving Directions) |
| `routePairs` | string\[] | No | — | More routes, each `startLat,startLng;endLat,endLng` |
| `maxRoutes` | integer | No | `3` | Alternative routes per trip (1-5) |
| `returnRouteCoordinates` | boolean | No | `false` | Include the full route polyline and jam polylines |
| `arrivalTimestamp` | integer | No | — | Arrive by this time (Unix seconds) |
| `departureTimestamp` | integer | No | — | Depart at this time (Unix seconds) |
| `venueCategories` | string | No | 6 common categories | Comma list, e.g. `gas station,parking,ev charging station` (Venues) |
| `maxVenues` | integer | No | `100` | Max venues per area (Venues) |
| `onlyInsideArea` | boolean | No | `true` | Drop venues just outside the rectangle (Venues) |
| `autocompleteQuery` | string | Yes\* | — | Search text (Autocomplete) |
| `autocompleteQueries` | string\[] | No | — | More search texts (Autocomplete) |
| `searchNear` | string | Yes\* | — | Location to search around, `latitude,longitude` (Autocomplete; falls back to the map area's center) |
| `maxResultsPerQuery` | integer | No | `10` | Max suggestions per query (Autocomplete) |
| `language` | string | No | `en` | Language for place names (Venues, Autocomplete) |

\*Required for the operation that uses it.

Alerts & Jams:

```json
{
    "operation": "alertsAndJams",
    "bottomLeft": "40.66615,-74.13732",
    "topRight": "40.77278,-73.76818",
    "maxAlerts": 20,
    "maxJams": 20,
    "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED"
}
```

Driving Directions:

```json
{
    "operation": "drivingDirections",
    "sourceCoordinates": "32.0853,34.781767",
    "destinationCoordinates": "32.794046,34.989571",
    "returnRouteCoordinates": true
}
```

Venues:

```json
{
    "operation": "venues",
    "bottomLeft": "40.745,-74.0",
    "topRight": "40.765,-73.97",
    "venueCategories": "parking,ev charging station"
}
```

Autocomplete:

```json
{
    "operation": "autocomplete",
    "autocompleteQuery": "JFK airport",
    "searchNear": "40.758,-73.9855"
}
```

### Output example

An alert (empty fields left out):

```json
{
    "recordType": "alert",
    "alertId": "alert-223130808/ff9e343d-5f67-4ba7-b241-3acf4a74485c",
    "uuid": "ff9e343d-5f67-4ba7-b241-3acf4a74485c",
    "alertType": "HAZARD",
    "alertSubtype": "HAZARD_ON_ROAD_EMERGENCY_VEHICLE",
    "alertDescription": "Responding ambulance nearby",
    "street": "Logan St",
    "latitude": 40.680104,
    "longitude": -73.877415,
    "reportBy": "HAAS Alert",
    "provider": "HAAS Alert 2",
    "publishDatetimeUtc": "2026-10-19T23:36:37.000Z",
    "wazeUrl": "https://www.waze.com/ul?ll=40.680104,-73.877415&navigate=yes",
    "areaIndex": 0,
    "mapArea": "40.55,-74.25;40.92,-73.7",
    "_operation": "alertsAndJams",
    "status": "success",
    "scrapedAt": "2026-10-19T23:36:46.109Z"
}
```

A jam caused by a road closure:

```json
{
    "recordType": "jam",
    "jamId": 1683499950,
    "street": "S 14th St",
    "city": "Newark, NJ",
    "endNode": "Madison Ave",
    "jamLevel": 5,
    "speedKmh": 0,
    "speedMetersPerSecond": 0,
    "lengthMeters": 302,
    "latitude": 40.722991,
    "longitude": -74.211216,
    "lineCoordinates": [
        { "latitude": 40.722991, "longitude": -74.211216 },
        { "latitude": 40.725601, "longitude": -74.210219 }
    ],
    "numSegments": 1,
    "isBlocked": true,
    "causeAlertId": "alert-223174678/27b05a40-9c98-41a8-a393-41c613f3d1b0",
    "causeAlertType": "ROAD_CLOSED",
    "causeAlertReliability": 5,
    "country": "US",
    "updateDatetimeUtc": "2026-10-20T00:22:55.539Z",
    "blockedSinceUtc": "2026-10-19T23:50:44.456Z",
    "areaIndex": 0,
    "mapArea": "40.55,-74.25;40.92,-73.7",
    "_operation": "alertsAndJams",
    "status": "success",
    "scrapedAt": "2026-10-20T00:23:34.948Z"
}
```

A route (lists shortened):

```json
{
    "recordType": "route",
    "routeIndex": 0,
    "routeName": "I-495 / Qns-Midtown Tun Queens (12.03)",
    "durationSeconds": 3476,
    "durationMinutes": 57.9,
    "lengthMeters": 27685,
    "lengthKm": 27.68,
    "lengthMiles": 17.2,
    "isFastest": true,
    "isToll": true,
    "isHov": false,
    "tollPrice": 12.03,
    "tollCurrency": "USD",
    "tollPassName": "E-ZPass - NY",
    "tollPriceWithPass": 7.46,
    "routeLabel": "Best route with toll",
    "trafficStatus": "despite heavier traffic than usual",
    "routeAlerts": [
        { "alertId": "221602133", "alertType": "POLICE", "alertSubtype": "NO_SUBTYPE", "latitude": 40.674009, "longitude": -73.84331 }
    ],
    "routeJams": [
        { "jamId": 1665013358, "severity": 0, "startLatitude": 40.753517, "startLongitude": -73.988787, "endLatitude": 40.752317, "endLongitude": -73.985947 }
    ],
    "numRouteAlerts": 5,
    "numRouteJams": 6,
    "sourceCoordinates": "40.758,-73.9855",
    "destinationCoordinates": "40.6413,-73.7781",
    "_operation": "drivingDirections",
    "status": "success"
}
```

A venue:

```json
{
    "recordType": "venue",
    "rank": 5,
    "venueName": "Tesla Destination Charger - GGMC 217 E 44th St",
    "venueId": "venues.187433368.1874530283.9033685",
    "venueSource": "waze",
    "address": "E 44th St, Manhattan",
    "latitude": 40.7519,
    "longitude": -73.9726372,
    "wazeUrl": "https://www.waze.com/ul?ll=40.7519,-73.9726372&navigate=yes",
    "areaIndex": 0,
    "mapArea": "40.745,-74;40.765,-73.97",
    "venueCategory": "ev charging station",
    "insideMapArea": true,
    "_operation": "venues",
    "status": "success",
    "scrapedAt": "2026-10-20T00:24:10.617Z"
}
```

Download the dataset in JSON, CSV, Excel, XML or HTML from the **Output** tab. The Console has separate table views for alerts, jams, routes and venues.

### Use the Waze Real-time API from your code

Start the actor and read its results with the Apify API clients. Find your token in [Apify Console → Settings → Integrations](https://console.apify.com/settings/integrations).

**Python** ([apify-client](https://docs.apify.com/api/client/python/)):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("parsebird/waze-api").call(run_input={
    "operation": "alertsAndJams",
    "bottomLeft": "34.0,-118.35",
    "topRight": "34.1,-118.2",
    "maxAlerts": 100,
    "maxJams": 50,
    "alertTypes": "ACCIDENT,ROAD_CLOSED",
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["recordType"] == "alert":
        print(row["alertType"], row["street"], row["latitude"], row["longitude"])
    elif row["recordType"] == "jam":
        print("jam", row["street"], row["jamLevel"], row["speedKmh"])
```

**JavaScript** ([apify-client](https://docs.apify.com/api/client/js/)):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('parsebird/waze-api').call({
    operation: 'drivingDirections',
    sourceCoordinates: '40.758,-73.9855',
    destinationCoordinates: '40.6413,-73.7781',
    maxRoutes: 3,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items
    .filter((r) => r.recordType === 'route')
    .forEach((r) => console.log(r.routeName, r.durationMinutes, 'min', r.isToll ? `toll ${r.tollPrice} ${r.tollCurrency}` : 'no toll'));
```

### Use cases

- **Logistics and fleet routing:** check delivery corridors for closures and accidents, and compare Waze route alternatives with on-route alerts before dispatching drivers.
- **Mobility and traffic analytics:** run a grid of map areas on a schedule and build congestion datasets from jam level, speed and length.
- **Insurance and risk monitoring:** count accidents and hazards per zone over time as a road-risk signal.
- **News and public safety:** watch an area for road closures, police activity and major hazards with street names and coordinates.
- **Navigation and mapping products:** add Waze's crowd-sourced incidents, toll estimates and HOV information to your own routing.

### How it works

1. You choose an operation and give coordinates or search texts.
2. The actor works out which Waze region each point belongs to (North America, Israel or the rest of the world) and requests the same live data that the [Waze Live Map](https://www.waze.com/live-map/) shows.
3. For Alerts & Jams, if a map area hits Waze's limit of 200 alerts or 200 jams and you asked for more, the area is split into four tiles (and those again, if needed) and the results are merged without duplicates.
4. Each alert, jam, route, venue or suggestion is saved as one flat row with a `recordType`, and each query is charged once it succeeds.

### FAQ

**How fresh is the data?**
It is live: each run returns what Waze shows at that moment. Alerts include their report time (`publishDatetimeUtc`) and jams their last update time (`updateDatetimeUtc`). To track changes, schedule the actor to run every few minutes.

**How big can a map area be?**
Any size, but Waze returns at most 200 alerts and 200 jams per map view, which a busy city fills easily. If **Max alerts** or **Max jams** is above what one request returns, the actor splits the area into tiles automatically (up to 64 requests per area), still charged as one query. For a whole metro area, several smaller areas in **More map areas** give you more even coverage.

**Which alerts come first?**
Alerts are sorted newest first and jams by severity (jam level, then length) before **Max alerts** and **Max jams** are applied.

**Why are some alert fields empty?**
Waze fills `alertDescription`, `reportBy` and `provider` only for some alerts, mostly ones from partners such as cities and road services. Waze's area view doesn't include a city, country or reliability score for individual alerts. Jams have a `city`, and jams caused by a closure carry the closure's country and reliability.

**Can I get directions between any two points?**
Within one Waze region, yes. Waze doesn't return a route for very long or impossible trips (in our tests New York to Los Angeles returned no route); the actor then saves an `error` row with the reason and doesn't charge for it.

**What does the Venues operation return?**
Venues searches the area for each category you list (for example `parking`) using Waze's place search and keeps the places inside your rectangle. Waze returns a limited number of places per search, so it finds the main places for each category rather than every business in a city. Use more specific categories or smaller areas for more results.

**How long does a run take?**
The first result usually arrives within a minute, because the actor first opens a session with Waze. After that, each extra map area, route or query takes a few seconds. Batch many areas or routes into one run rather than starting one run per query.

**Can I schedule runs and connect them to other tools?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) for recurring runs and [integrations](https://docs.apify.com/platform/integrations) for Google Sheets, Slack, Zapier, Make, n8n or webhooks. Results are also available through the [API](https://apify.com/parsebird/waze-api/api).

**Something doesn't work or a field is missing?**
Open an issue on the actor's **Issues** tab with the input you used, and we'll look into it.

### Is it legal to get data from Waze?

This actor reads traffic information that Waze shows publicly on its Live Map to anyone, without logging in. Alerts and jams describe road conditions, not people, and the actor doesn't collect user names or accounts. You are still responsible for how you use the data: follow Waze's terms of service and the laws that apply to you. Read more in Apify's blog post [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/), and ask a lawyer if you're unsure.

### Other maps scrapers

| Actor | What it does |
|-------|-------------|
| [Apple Maps Scraper](https://apify.com/parsebird/apple-maps-scraper) | Places from Apple Maps with address, phone, ratings, hours and coordinates |
| [NAVER Map Scraper](https://apify.com/parsebird/naver-map-scraper) | Places and reviews from NAVER Map in Korea |
| [Yandex Maps Scraper](https://apify.com/parsebird/yandex-maps-scraper) | Businesses, phones and emails from Yandex Maps |
| [Yandex Maps Reviews Scraper](https://apify.com/parsebird/yandex-maps-reviews-scraper) | Reviews from Yandex Maps |

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/waze-api/changelog.md

# Actor input Schema

## `operation` (type: `string`):

Choose what to get from Waze. Each operation uses only its own fields below.

## `bottomLeft` (type: `string`):

South-west corner of the map area as <code>latitude,longitude</code>. Used by Alerts & Jams and Venues.

## `topRight` (type: `string`):

North-east corner of the map area as <code>latitude,longitude</code>. Used by Alerts & Jams and Venues.

## `mapAreas` (type: `array`):

Add more areas to run in the same run, one per line as <code>bottomLeftLat,bottomLeftLng;topRightLat,topRightLng</code>. Each area is a separate query.

## `maxAlerts` (type: `integer`):

Maximum alerts (accidents, hazards, police, closures...) to return per map area. Waze sends up to 200 per request; above that the area is split into smaller tiles automatically. Set 0 to skip alerts.

## `maxJams` (type: `integer`):

Maximum traffic jams to return per map area, most severe first. Set 0 to skip jams.

## `alertTypes` (type: `string`):

Only return these alert types, comma-separated: <code>ACCIDENT</code>, <code>HAZARD</code>, <code>POLICE</code>, <code>ROAD_CLOSED</code>, <code>JAM</code>. Leave empty for all.

## `alertSubtypes` (type: `string`):

Only return these subtypes, comma-separated, e.g. <code>HAZARD_ON_ROAD_CONSTRUCTION,HAZARD_ON_ROAD_POT_HOLE,ACCIDENT_MAJOR</code>. Leave empty for all.

## `sourceCoordinates` (type: `string`):

Where the drive starts, as <code>latitude,longitude</code>.

## `destinationCoordinates` (type: `string`):

Where the drive ends, as <code>latitude,longitude</code>.

## `routePairs` (type: `array`):

Add more start/destination pairs, one per line as <code>startLat,startLng;endLat,endLng</code>.

## `maxRoutes` (type: `integer`):

How many alternative routes to request (1-5). Each route returned is charged.

## `returnRouteCoordinates` (type: `boolean`):

Add the full route polyline (and the polyline of each jam on the route). Makes each row much larger.

## `arrivalTimestamp` (type: `integer`):

Plan the route to arrive at this time, in Unix seconds (e.g. <code>1792512000</code>). Leave empty to leave now.

## `departureTimestamp` (type: `integer`):

Plan the route for a future departure time, in Unix seconds. Ignored when Arrive by is set.

## `venueCategories` (type: `string`):

What to look for in the map area, comma-separated, e.g. <code>gas station,parking,ev charging station</code>. Leave empty for gas stations, parking, EV charging, restaurants, coffee shops and hotels.

## `maxVenues` (type: `integer`):

Maximum venues to return per map area.

## `onlyInsideArea` (type: `boolean`):

Drop suggestions that Waze returns just outside the rectangle.

## `autocompleteQuery` (type: `string`):

Text to search for, like you would type in the Waze search box (an address, a place name or a category).

## `autocompleteQueries` (type: `array`):

Add more search texts, one per line. Each is a separate query.

## `searchNear` (type: `string`):

Location to rank suggestions around, as <code>latitude,longitude</code>. If empty, the center of the map area above is used.

## `maxResultsPerQuery` (type: `integer`):

Maximum suggestions to keep per query.

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

Language code for place names and addresses in Venues and Autocomplete, e.g. <code>en</code>, <code>es</code>, <code>fr</code>, <code>he</code>.

## Actor input object example

```json
{
  "operation": "alertsAndJams",
  "bottomLeft": "40.66615,-74.13732",
  "topRight": "40.77278,-73.76818",
  "maxAlerts": 20,
  "maxJams": 20,
  "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED",
  "sourceCoordinates": "32.0853,34.781767",
  "destinationCoordinates": "32.794046,34.989571",
  "maxRoutes": 3,
  "returnRouteCoordinates": false,
  "maxVenues": 100,
  "onlyInsideArea": true,
  "maxResultsPerQuery": 10,
  "language": "en"
}
```

# Actor output Schema

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

No description

# 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 = {
    "operation": "alertsAndJams",
    "bottomLeft": "40.66615,-74.13732",
    "topRight": "40.77278,-73.76818",
    "maxAlerts": 20,
    "maxJams": 20,
    "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED",
    "sourceCoordinates": "32.0853,34.781767",
    "destinationCoordinates": "32.794046,34.989571"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/waze-api").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 = {
    "operation": "alertsAndJams",
    "bottomLeft": "40.66615,-74.13732",
    "topRight": "40.77278,-73.76818",
    "maxAlerts": 20,
    "maxJams": 20,
    "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED",
    "sourceCoordinates": "32.0853,34.781767",
    "destinationCoordinates": "32.794046,34.989571",
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/waze-api").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 '{
  "operation": "alertsAndJams",
  "bottomLeft": "40.66615,-74.13732",
  "topRight": "40.77278,-73.76818",
  "maxAlerts": 20,
  "maxJams": 20,
  "alertTypes": "ACCIDENT,HAZARD,POLICE,ROAD_CLOSED",
  "sourceCoordinates": "32.0853,34.781767",
  "destinationCoordinates": "32.794046,34.989571"
}' |
apify call parsebird/waze-api --silent --output-dataset

```

## MCP server setup

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

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/x7a1JcODHFaxTNbQG/builds/ZbyxmHorXs7ZMBvB7/openapi.json
