# 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:** 87 total users, 14 monthly users, 100.0% runs succeeded, 2 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/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 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

**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)**

# Changelog

This Actor's version history is a separate document: https://apify.com/sian.agency/waze-traffic-scraper/changelog.md

# 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(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 '{
  "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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/waze-traffic-scraper"
        }
    }
}
```

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

## OpenAPI specification

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