# Waze API — Real-Time Traffic, Alerts & Road Incidents (`sian.agency/waze-traffic-scraper`) Actor

Pull real-time Waze traffic data via API: accidents, hazards, police reports, road closures and live jams in any map area, plus driving directions with on-route alerts and venue search. Clean geo-coded JSON rows for logistics, routing, fleet and mobility analytics. No Waze account needed.

- **URL**: https://apify.com/sian.agency/waze-traffic-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Travel, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.60 / 1,000 alerts & jams queries

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/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

## Waze API — Real-Time Traffic, Alerts & Road Incidents 🚦

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Instagram AI Transcript Extractor](https://img.shields.io/badge/Store-Instagram%20AI%20Transcript-E4405F)](https://apify.com/sian.agency/instagram-ai-transcript-extractor?fpr=sian) [![Dubai Real Estate Scraper](https://img.shields.io/badge/Store-Dubai%20Real%20Estate-93D500)](https://apify.com/sian.agency/bayut-property-scraper?fpr=sian) [![Property Skip Tracing](https://img.shields.io/badge/Store-Property%20Skip%20Tracing-1AE392)](https://apify.com/sian.agency/property-skip-tracing?fpr=sian)

#### 🎉 Real-time road incidents straight from Waze's crowd — accidents, hazards, police, road closures & live jams in any map area, plus driving directions with on-route alerts.
##### Built for logistics, fleet routing, mobility analytics, insurance risk and navigation teams who need live traffic data no Google Maps clone exposes.

---

### 📋 Overview

**Tap the world's largest crowd-sourced traffic network through a clean Waze API** — pull live road incidents, congestion, driving routes and venues into structured, geo-coded datasets, no Waze account or API key of your own required.

**Why teams choose this over a generic maps scraper:**
- ✅ **Crowd-sourced incident data**: accidents, hazards, police reports, road closures and live jams — the exact real-time signal Google Maps/Places scrapers don't carry.
- ⚡ **3 operations in one actor**: Alerts & Jams, Driving Directions, and Venues — one operation per run, one clean dataset out.
- 🎯 **Clean geo on every row**: latitude/longitude on every incident, full jam polylines preserved, GeoJSON venue points normalized — ready to drop on a map.
- 💰 **Predictable per-query pricing**: bounding-box operations are charged once per map area regardless of how busy it is — no sticker shock on dense cities.
- 💎 **Market-exclusive driving directions**: Waze route alternatives *with* on-route alerts, toll pricing, HOV flags and arrival-time targeting — data no standard directions API returns.
- ✨ **No Waze account needed**: just define a map area or route and run.

---

### ✨ Features

- 🚦 **Alerts & Jams by map area** — every accident, hazard, police report, road closure and traffic jam inside a bounding box, one row per incident.
- 🧭 **Driving Directions with incidents** — candidate Waze routes between two points, each carrying its on-route alerts, jams, toll price, HOV flag and arrival-time support.
- 📍 **Venue search** — points of interest inside any map area, with normalized coordinates and categories.
- 🏷️ **Type & subtype filters** — narrow Alerts & Jams to just `POLICE`, `ACCIDENT`, `HAZARD`, `ROAD_CLOSED` and more.
- 🐌 **Congestion metrics** — jam level (0–5), speed (km/h), length (m) and delay on every jam row.
- 🗺️ **Polyline preservation** — full jam and route geometry kept alongside a clean representative point.
- 📊 **One flat dataset per run** — filter by `_operation` and `recordType` to split modes; export to JSON, CSV or Excel.

---

### 🎬 Quick Start

Pick an operation, define a map area (or a route), and run. Each run produces one clean dataset. Below: pull live alerts and jams for a New York City bounding box.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~waze-traffic-scraper/runs?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"operation":"alertsAndJams","bottomLeft":"40.66615,-74.13732","topRight":"40.77278,-73.76818"}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your operation

Pick **Alerts & Jams** for incidents in an area, **Driving Directions** for route-level traffic, or **Venues** for points of interest.

#### Step 2: Define the area or route

For area operations, set the bottom-left and top-right corners (`latitude,longitude`). For directions, set source and destination coordinates.

#### Step 3: Run and export

Start the run and collect your geo-coded rows from the dataset — export as JSON, CSV or Excel.

**That's it! In under a minute, you'll have:**

- Live road incidents with coordinates, street, city and reliability score
- Traffic jams with level, speed, length and full polyline
- Clean rows ready for mapping, routing or analytics dashboards

***

### 📥 Input Configuration

Pick **one operation per run**. Fields are used only by the operations noted.

| Field | Type | Required | Used by | Description |
|-------|------|----------|---------|-------------|
| `operation` | enum | **Yes** | all | `alertsAndJams` · `drivingDirections` · `venues` |
| `bottomLeft` | string | Yes\* | Alerts & Jams, Venues | Bottom-left map corner, `latitude,longitude` |
| `topRight` | string | Yes\* | Alerts & Jams, Venues | Top-right map corner, `latitude,longitude` |
| `maxAlerts` | integer | No | Alerts & Jams | Max alerts to fetch (default 20) |
| `maxJams` | integer | No | Alerts & Jams | Max jams to fetch (default 20) |
| `alertTypes` | string | No | Alerts & Jams | Comma list: `ACCIDENT,HAZARD,POLICE,ROAD_CLOSED`… |
| `alertSubtypes` | string | No | Alerts & Jams | Comma list of alert subtypes |
| `sourceCoordinates` | string | Yes\* | Driving Directions | Route start, `latitude,longitude` |
| `destinationCoordinates` | string | Yes\* | Driving Directions | Route end, `latitude,longitude` |
| `returnRouteCoordinates` | boolean | No | Driving Directions | Include the full route polyline |
| `arrivalTimestamp` | integer | No | Driving Directions | Desired arrival time (Unix seconds) |
| `venueCategories` | string | No | Venues | Comma list of venue categories |
| `zoomLevel` | string | No | Venues | Waze zoom level 1–4 |

\*Required for the operations listed in the "Used by" column.

**Example — 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"
}
```

**Example — Driving Directions:**

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

***

### 📤 Output

Results are saved to the Apify dataset, one flat row per item, tagged by `recordType` (`alert`, `jam`, `route`, `venue`). Each row spreads the raw upstream fields alongside clean camelCase aliases.

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | `alert` / `jam` / `route` / `venue` |
| `latitude` / `longitude` | number | Clean point coordinates |
| `alertType` | string | `ACCIDENT`, `HAZARD`, `POLICE`, `ROAD_CLOSED`, … |
| `alertDescription` | string | Human-readable incident description |
| `street` / `city` / `country` | string | Location |
| `alertReliability` | integer | Crowd reliability score |
| `jamLevel` | integer | Congestion level 0–5 |
| `speedKmh` | number | Average jam speed |
| `lengthMeters` | integer | Jam / route length |
| `lineCoordinates` | array | Full jam polyline |
| `routeName` | string | Driving route name |
| `durationSeconds` | integer | Route travel time |
| `isToll` / `isHov` | boolean | Route flags |
| `tollPrice` | number | Toll cost (toll routes) |
| `routeAlerts` | array | On-route incidents |
| `venueName` | string | Venue / POI name |

**Example row (alert):**

```json
{
  "recordType": "alert",
  "alertType": "HAZARD",
  "alertSubtype": "HAZARD_ON_ROAD_CONSTRUCTION",
  "alertDescription": "Construction Pulaski Skyway NB ramp lane closed",
  "city": "Kearny",
  "latitude": 40.734439,
  "longitude": -74.104087,
  "alertReliability": 0,
  "publishDatetimeUtc": "2026-06-05T13:00:29.000Z",
  "_operation": "alertsAndJams",
  "status": "success"
}
```

***

### 💼 Use Cases & Examples

#### 1. Logistics & Fleet Routing

**Dispatchers rerouting delivery fleets around live disruptions.**

**Input:** Bounding boxes along delivery corridors (Alerts & Jams) + source/destination pairs (Driving Directions)
**Output:** Live accidents, closures and jams plus route alternatives with on-route alerts
**Use:** Detect a closure on a planned route and switch drivers to a clear alternative in real time.

#### 2. Mobility & Traffic Analytics

**Urban-mobility researchers building congestion datasets.**

**Input:** A city-wide grid of bounding boxes, run on a schedule
**Output:** Jam level, speed, length and delay per area
**Use:** Aggregate congestion over time into heatmaps and mobility reports.

#### 3. Insurance & Risk Monitoring

**Underwriters scoring accident and hazard density.**

**Input:** Defined zones, filtered to `ACCIDENT,HAZARD`
**Output:** Incident counts and locations per area
**Use:** Feed claims triage and underwriting signals with road-risk data.

#### 4. News & Incident Monitoring

**Local newsrooms and public-safety teams surfacing road events.**

**Input:** Bounding boxes over a coverage area
**Output:** Road closures, police activity and major hazards with street and coordinates
**Use:** Power live traffic alerts and breaking-incident desks.

#### 5. Navigation-Product Enrichment

**Routing and mapping apps adding crowd-sourced intelligence.**

**Input:** Source/destination coordinate pairs
**Output:** Waze route alternatives with on-route alerts, toll/HOV flags and arrival-time estimates
**Use:** Surface incident-aware routes that standard directions APIs can't provide.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/waze-traffic-scraper').call({
  operation: 'alertsAndJams',
  bottomLeft: '40.66615,-74.13732',
  topRight: '40.77278,-73.76818',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/waze-traffic-scraper').call(
    run_input={
        'operation': 'drivingDirections',
        'sourceCoordinates': '32.0853,34.781767',
        'destinationCoordinates': '32.794046,34.989571',
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~waze-traffic-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"operation":"venues","bottomLeft":"48.851,2.334","topRight":"48.853,2.354"}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. every 15 min) or webhook
2. **HTTP Request**: Call the actor API with your operation + map area
3. **Process**: Handle the JSON rows (filter by `recordType`)
4. **Action**: Save to a database, push to a map, or alert on new closures

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- Full feature access across all four operations, same data quality
- No credit card required
- Perfect for testing a map area or route

#### PAID Tier (Production Ready)

- Run any volume of map areas and routes
- Pay-per-result: charged only for successful queries (driving routes charged per route)
- Predictable per-query billing on bounding-box operations

💰 **Transparent, predictable pricing** — a busy city bounding box costs the same as a quiet one.

🔗 [View current pricing](https://apify.com/sian.agency/waze-traffic-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: What data does the Alerts & Jams operation return?**
A: Every real-time alert (accidents, hazards, police reports, road closures) and traffic jam inside your map area, one row per incident with coordinates, street, city and a reliability score.

**Q: How is billing calculated?**
A: Bounding-box operations (Alerts & Jams, Venues) are charged once per successful query regardless of how many incidents are returned. Driving Directions is charged per route returned.

**Q: Does the actor support place autocomplete?**
A: Not at the moment. The autocomplete operation is temporarily disabled while we validate its upstream data availability — it will return in a future release. Use Alerts & Jams, Driving Directions or Venues for production data.

**Q: What output formats are available?**
A: JSON, CSV and Excel — export directly from the Apify dataset.

**Q: Do I need a Waze account or API key?**
A: No. Just define a map area or route and run.

**Q: What coordinate format should I use?**
A: A `latitude,longitude` pair, e.g. `40.66615,-74.13732`. Bounding boxes use a bottom-left and top-right corner.

**Q: Is this legal?**
A: We help you collect publicly available traffic data. See the legal section below.

***

### 🐛 Troubleshooting

**No rows returned for a map area**

- The area may genuinely have no active incidents — try a larger box or a busier city.
- Verify your `bottomLeft` and `topRight` are in `latitude,longitude` order and that bottom-left is south-west of top-right.

**"must be a latitude,longitude pair" error**

- Check your coordinate strings contain exactly two numbers separated by a comma (no spaces required, e.g. `40.66615,-74.13732`).

**Data source temporarily unavailable**

- The actor retries transient upstream errors automatically. If it persists, wait a moment and re-run.

***

### ⚠️ Trademark Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Waze Mobile Ltd. or Google LLC.** "Waze" and related marks are trademarks of their respective owners and are used here only to describe the data this tool helps you collect. Use this actor responsibly and in compliance with applicable laws, Waze's and Google's terms of service, and data-protection regulations (including GDPR and CCPA where applicable). You are responsible for how you use the data you extract.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location of individuals. They only extract what has been 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. You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's Issues tab
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

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

🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.

- **🚦 Alerts & Jams** — all real-time alerts (accidents, hazards, police, road closures) AND traffic jams in a map area (bounding box). One row per incident, tagged `recordType`.
- **🧭 Driving Directions** — candidate Waze routes between two points, each with on-route alerts, toll/HOV flags and arrival-time support. One row per route.
- **📍 Venues** — venues / points of interest inside a map area (bounding box). One row per venue.

💡 **TIP:** Alerts & Jams is the core real-time-traffic operation. Use Driving Directions for route-level incident enrichment.

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

↙️ **Required for `Alerts & Jams` and `Venues`.**

Bottom-left corner of the map area (bounding box) as a `latitude,longitude` pair.

- `40.66615,-74.13732` — lower-left of a New York City box

💡 **TIP:** Keep the box small (a few km across) for dense, fast results. Pair with the top-right corner to define the rectangle.

⚠️ **Ignored** for Driving Directions.

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

↗️ **Required for `Alerts & Jams` and `Venues`.**

Top-right corner of the map area (bounding box) as a `latitude,longitude` pair.

- `40.77278,-73.76818` — upper-right of a New York City box

⚠️ **Ignored** for Driving Directions.

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

For `Alerts & Jams` — maximum number of alerts to fetch (accidents, hazards, police, road closures). Set to `0` to fetch jams only. Default 20.

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

For `Alerts & Jams` — maximum number of traffic jams to fetch. Set to `0` to fetch alerts only. Default 20.

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

Optional. For `Alerts & Jams` — only return alerts of specific types, as a comma-separated list. Values: `ACCIDENT`, `HAZARD`, `JAM`, `ROAD_CLOSED`, `POLICE`, `CONSTRUCTION`, `MISC`.

- `POLICE,HAZARD`

Leave blank for all types.

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

Optional. For `Alerts & Jams` — only return alerts of specific subtypes, as a comma-separated list (e.g. `POLICE_HIDING`, `ROAD_CLOSED_EVENT`, `HAZARD_ON_ROAD_CONSTRUCTION`). Leave blank for all subtypes.

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

Optional. For `Venues` — only return venues in specific categories, as a comma-separated list (e.g. `RESTAURANT,PARKING_LOT,ICE_CREAM`). Leave blank for all categories.

## `zoomLevel` (type: `string`):

Optional. For `Venues` — Waze zoom level 1–4 (4 is most zoomed in). Default 1. Higher zoom returns more granular venues.

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

🟢 **Required for `Driving Directions`.**

Starting point as a `latitude,longitude` pair.

- `32.0853,34.781767`

⚠️ **Ignored** for other operations.

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

🔴 **Required for `Driving Directions`.**

Destination as a `latitude,longitude` pair.

- `32.794046,34.989571`

⚠️ **Ignored** for other operations.

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

Optional. For `Driving Directions` — when enabled, each route row includes the full route polyline (`routeCoordinates`). Off by default to keep rows compact.

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

Optional. For `Driving Directions` — desired arrival time as a Unix timestamp (seconds since epoch). When set, directions are calculated for that arrival time. Leave blank for current time.

## Actor input object example

```json
{
  "operation": "alertsAndJams",
  "bottomLeft": "40.66615,-74.13732",
  "topRight": "40.77278,-73.76818",
  "maxAlerts": 20,
  "maxJams": 20,
  "alertTypes": "POLICE,HAZARD",
  "alertSubtypes": "ROAD_CLOSED_EVENT",
  "venueCategories": "RESTAURANT,PARKING_LOT",
  "zoomLevel": "1",
  "sourceCoordinates": "32.0853,34.781767",
  "destinationCoordinates": "32.794046,34.989571",
  "returnRouteCoordinates": false
}
```

# Actor output Schema

## `output` (type: `string`):

Per-row results — one flat row per upstream item with clean geo-coded fields (latitude, longitude, alertType, alertDescription, jamLevel, routeName, venueName, …) plus the raw upstream fields spread alongside. Tagged by `recordType`.

## `report` (type: `string`):

HTML report with run status, success/error row counts, success rate, duration, and the inputs used — written even on fatal crash.

# 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 = {
    "bottomLeft": "40.66615,-74.13732",
    "topRight": "40.77278,-73.76818",
    "sourceCoordinates": "32.0853,34.781767",
    "destinationCoordinates": "32.794046,34.989571"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/waze-traffic-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 = {
    "bottomLeft": "40.66615,-74.13732",
    "topRight": "40.77278,-73.76818",
    "sourceCoordinates": "32.0853,34.781767",
    "destinationCoordinates": "32.794046,34.989571",
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/waze-traffic-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 '{
  "bottomLeft": "40.66615,-74.13732",
  "topRight": "40.77278,-73.76818",
  "sourceCoordinates": "32.0853,34.781767",
  "destinationCoordinates": "32.794046,34.989571"
}' |
apify call sian.agency/waze-traffic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/waze-traffic-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Waze API — Real-Time Traffic, Alerts & Road Incidents",
        "description": "Pull real-time Waze traffic data via API: accidents, hazards, police reports, road closures and live jams in any map area, plus driving directions with on-route alerts and venue search. Clean geo-coded JSON rows for logistics, routing, fleet and mobility analytics. No Waze account needed.",
        "version": "1.0",
        "x-build-id": "GSpW2gpLDSxIW1TbV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~waze-traffic-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-waze-traffic-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/sian.agency~waze-traffic-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-waze-traffic-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/sian.agency~waze-traffic-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-waze-traffic-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",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "🎯 Operation — what do you want to pull?",
                        "enum": [
                            "alertsAndJams",
                            "drivingDirections",
                            "venues"
                        ],
                        "type": "string",
                        "description": "🎯 **PICK ONE OPERATION PER RUN.** Each run produces one clean dataset matching the chosen mode.\n\n- **🚦 Alerts & Jams** — all real-time alerts (accidents, hazards, police, road closures) AND traffic jams in a map area (bounding box). One row per incident, tagged `recordType`.\n- **🧭 Driving Directions** — candidate Waze routes between two points, each with on-route alerts, toll/HOV flags and arrival-time support. One row per route.\n- **📍 Venues** — venues / points of interest inside a map area (bounding box). One row per venue.\n\n💡 **TIP:** Alerts & Jams is the core real-time-traffic operation. Use Driving Directions for route-level incident enrichment.",
                        "default": "alertsAndJams"
                    },
                    "bottomLeft": {
                        "title": "↙️ Bottom-Left corner (lat,lng)",
                        "type": "string",
                        "description": "↙️ **Required for `Alerts & Jams` and `Venues`.**\n\nBottom-left corner of the map area (bounding box) as a `latitude,longitude` pair.\n- `40.66615,-74.13732` — lower-left of a New York City box\n\n💡 **TIP:** Keep the box small (a few km across) for dense, fast results. Pair with the top-right corner to define the rectangle.\n\n⚠️ **Ignored** for Driving Directions."
                    },
                    "topRight": {
                        "title": "↗️ Top-Right corner (lat,lng)",
                        "type": "string",
                        "description": "↗️ **Required for `Alerts & Jams` and `Venues`.**\n\nTop-right corner of the map area (bounding box) as a `latitude,longitude` pair.\n- `40.77278,-73.76818` — upper-right of a New York City box\n\n⚠️ **Ignored** for Driving Directions."
                    },
                    "maxAlerts": {
                        "title": "🚧 Max alerts",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "For `Alerts & Jams` — maximum number of alerts to fetch (accidents, hazards, police, road closures). Set to `0` to fetch jams only. Default 20.",
                        "default": 20
                    },
                    "maxJams": {
                        "title": "🐌 Max jams",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "For `Alerts & Jams` — maximum number of traffic jams to fetch. Set to `0` to fetch alerts only. Default 20.",
                        "default": 20
                    },
                    "alertTypes": {
                        "title": "🏷️ Alert types filter",
                        "type": "string",
                        "description": "Optional. For `Alerts & Jams` — only return alerts of specific types, as a comma-separated list. Values: `ACCIDENT`, `HAZARD`, `JAM`, `ROAD_CLOSED`, `POLICE`, `CONSTRUCTION`, `MISC`.\n- `POLICE,HAZARD`\n\nLeave blank for all types."
                    },
                    "alertSubtypes": {
                        "title": "🏷️ Alert subtypes filter",
                        "type": "string",
                        "description": "Optional. For `Alerts & Jams` — only return alerts of specific subtypes, as a comma-separated list (e.g. `POLICE_HIDING`, `ROAD_CLOSED_EVENT`, `HAZARD_ON_ROAD_CONSTRUCTION`). Leave blank for all subtypes."
                    },
                    "venueCategories": {
                        "title": "🏷️ Venue categories filter",
                        "type": "string",
                        "description": "Optional. For `Venues` — only return venues in specific categories, as a comma-separated list (e.g. `RESTAURANT,PARKING_LOT,ICE_CREAM`). Leave blank for all categories."
                    },
                    "zoomLevel": {
                        "title": "🔍 Zoom level (Venues)",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "Optional. For `Venues` — Waze zoom level 1–4 (4 is most zoomed in). Default 1. Higher zoom returns more granular venues.",
                        "default": "1"
                    },
                    "sourceCoordinates": {
                        "title": "🟢 Source coordinates (lat,lng)",
                        "type": "string",
                        "description": "🟢 **Required for `Driving Directions`.**\n\nStarting point as a `latitude,longitude` pair.\n- `32.0853,34.781767`\n\n⚠️ **Ignored** for other operations."
                    },
                    "destinationCoordinates": {
                        "title": "🔴 Destination coordinates (lat,lng)",
                        "type": "string",
                        "description": "🔴 **Required for `Driving Directions`.**\n\nDestination as a `latitude,longitude` pair.\n- `32.794046,34.989571`\n\n⚠️ **Ignored** for other operations."
                    },
                    "returnRouteCoordinates": {
                        "title": "📐 Return route polyline",
                        "type": "boolean",
                        "description": "Optional. For `Driving Directions` — when enabled, each route row includes the full route polyline (`routeCoordinates`). Off by default to keep rows compact.",
                        "default": false
                    },
                    "arrivalTimestamp": {
                        "title": "🕒 Arrival time (unix seconds)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional. For `Driving Directions` — desired arrival time as a Unix timestamp (seconds since epoch). When set, directions are calculated for that arrival time. Leave blank for current time."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```