Forem: Roman Kotenko

GeoJSON Traffic Events API with BBox and Radius Queries

Roman Kotenko — Thu, 07 May 2026 10:00:00 +0000

If you're building a traffic map, the last thing you want is to parse a proprietary format and convert coordinates. Road511's GeoJSON endpoints return standard FeatureCollections that drop directly into Leaflet, Mapbox, MapLibre, ArcGIS, QGIS, or any GeoJSON-compatible tool.

GeoJSON Endpoints

Every list endpoint in Road511 has a /geojson variant:

GET /api/v1/events/geojson
GET /api/v1/features/geojson?type=cameras
GET /api/v1/truck/corridor/geojson

All return Content-Type: application/geo+json with a standard FeatureCollection.

Bounding Box Query

Show events in the current map viewport:

const bounds = map.getBounds();
const bbox = [
  bounds.getWest(), bounds.getSouth(),
  bounds.getEast(), bounds.getNorth()
].join(',');

const res = await fetch(
  `https://api.road511.com/api/v1/events/geojson?bbox=${bbox}&status=active`,
  { headers: { 'X-API-Key': key } }
);
const geojson = await res.json();
L.geoJSON(geojson).addTo(map);

Radius Search

Find everything within 50km of a point:

curl "https://api.road511.com/api/v1/events/geojson?lat=34.05&lng=-118.24&radius_km=50&status=active" \
  -H "X-API-Key: your_key"

Multiple Feature Types

Build a layered map with different feature types:

const types = ['cameras', 'signs', 'weather_stations', 'rest_areas'];

for (const type of types) {
  const res = await fetch(
    `https://api.road511.com/api/v1/features/geojson?type=${type}&jurisdiction=CA`,
    { headers: { 'X-API-Key': key } }
  );
  const geojson = await res.json();
  L.geoJSON(geojson, {
    pointToLayer: (f, latlng) => L.marker(latlng, { icon: icons[type] })
  }).addTo(layerGroups[type]);
}

LineString Geometry

Not everything is a point. Construction events, truck routes, and weight restrictions include polyline geometry:

{
  "type": "Feature",
  "geometry": {
    "type": "LineString",
    "coordinates": [[-87.63, 41.88], [-87.62, 41.89], [-87.60, 41.90]]
  },
  "properties": {
    "id": "fhwa-il-staa-001",
    "feature_type": "truck_routes",
    "name": "I-90 STAA National Network"
  }
}

Spatial Queries Under the Hood

Road511 uses PostGIS for all spatial operations. Every feature has a geometry column with a spatial index. Bounding box queries use ST_Intersects, radius queries use ST_DWithin on geography. The truck corridor endpoint builds a buffer geometry with ST_Buffer and intersects it against all truck-related features.

Try It

Live map — built entirely on Road511's GeoJSON endpoints
API docs
Free API key
Code examples

Real-Time DMS Sign Messages API: What's on the Highway Signs Right Now

Roman Kotenko — Thu, 30 Apr 2026 13:00:00 +0000

Dynamic Message Signs (DMS) — those big electronic boards over highways — display real-time traveler information: incident warnings, travel times, amber alerts, construction notices.

Road511 captures the current message from every DMS sign across 30+ US states and Canadian provinces. Nobody else aggregates this data.

What You Get

curl "https://api.road511.com/api/v1/features?type=signs&jurisdiction=GA&limit=10" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "ga-sign-i85-042",
      "jurisdiction": "GA",
      "name": "I-85 NB at Clairmont Rd",
      "latitude": 33.8103,
      "longitude": -84.3179,
      "properties": {
        "message": "CRASH AHEAD / I-85 NB AT SR 42 / RIGHT LANE BLOCKED"
      }
    }
  ]
}

The message field contains the exact text currently displayed on the sign, including line breaks encoded as /.

Why This Matters

DMS messages are a leading indicator. The sign updates within minutes of an incident, often before the event appears in some 511 feeds. Cross-referencing sign messages with traffic events gives you:

Faster incident detection — sign changes before event feeds update
DOT response time analysis — how long after an incident before a sign is posted
Traveler information coverage — which corridors have DMS signs, which are blind spots
Historical message patterns — Road511 now tracks message changes over time

Message History

Road511 records every message change in the sign_message_history table. Only actual changes are stored (not every poll), so you get a clean timeline of what each sign displayed and when.

This is data that doesn't exist anywhere else publicly. No state DOT publishes a historical archive of DMS messages.

Use Cases

Navigation apps — show upcoming sign messages on the route
Traffic management — monitor DMS coverage and response times
Research — analyze traveler information effectiveness
Emergency alerting — detect amber/silver alerts from sign text

Try It

Live map — click any sign marker to see current message
API docs
Free API key

Bridge Clearance Data API for Fleet Routing

Roman Kotenko — Wed, 22 Apr 2026 22:00:00 +0000

If you're routing commercial vehicles, you need to know which bridges your truck can't clear. The FHWA National Bridge Inventory has 621,000 bridges with height and weight data — but it's buried in an ArcGIS FeatureServer with pagination limits and cryptic field codes.

Road511 normalizes all of it into one queryable API. Plus state-level bridge inventories from PA, OH, TX, VA, NY, FL, WA, and IN with enhanced detail.

The Data

Every bridge record includes:

Height clearance — vertical clearance in meters
Weight rating — operating and inventory load ratings in metric tons
Posting status — open, posted, posted_closed, closed
Condition ratings — deck, superstructure, substructure (0-9 scale)
Road carried and feature crossed — "I-80 over Passaic River"
Year built, ADT, inspection date — for infrastructure analysis

Query by Bounding Box

curl "https://api.road511.com/api/v1/features?type=bridge_clearances&bbox=-75.5,39.5,-74.5,40.5&limit=50" \
  -H "X-API-Key: your_key"

Returns every bridge in the Philadelphia metro area with clearance and weight data.

Corridor Search

The killer feature for fleet routing — query all restrictions along a route:

curl "https://api.road511.com/api/v1/truck/corridor?from_lat=41.88&from_lng=-87.63&to_lat=40.71&to_lng=-74.01&buffer_km=5&height=4.2&weight=36" \
  -H "X-API-Key: your_key"

This returns every bridge clearance, weight restriction, and truck restriction within 5km of the Chicago-to-NYC corridor that a 4.2m tall, 36-ton truck can't clear. The height and weight parameters filter results to only show conflicts.

GeoJSON for Route Overlays

curl "https://api.road511.com/api/v1/truck/corridor/geojson?from_lat=41.88&from_lng=-87.63&to_lat=40.71&to_lng=-74.01&buffer_km=5" \
  -H "X-API-Key: your_key"

Drop the response directly onto a map to visualize every restriction along the corridor.

Data Sources

Source	Bridges	Coverage
FHWA NBI	621,000	All US states + DC + PR
Pennsylvania PennDOT	56,000	PA bridges + 3K restricted roads
Texas TxDOT	58,000	TX posted bridges
Ohio ODOT	45,000	OH posted bridges
Virginia VDOT	40,000	VA posted structures
New York NYSDOT	2,300	NY posted load + height bridges
Washington WSDOT	10,800	WA bridge inventory
Indiana INDOT	4,400	IN LiDAR per-lane clearances
Florida FDOT	824	FL weight-posted bridges

Who Uses This

Fleet management software — pre-route clearance checks
Logistics platforms — automated route validation
Oversize/overweight permitting — clearance verification
Engineering firms — infrastructure condition analysis
Insurance — bridge condition risk scoring

Try It

Live map — zoom into any area to see bridge markers
API docs
Free API key

How to Get Real-Time Traffic Camera Feeds via API

Roman Kotenko — Sun, 19 Apr 2026 07:39:52 +0000

No major traffic data provider gives you camera feeds. Not HERE, not TomTom, not Google, not INRIX. They all sell traffic flow from probe data, but live camera images? Nobody aggregates that.

Road511 does. 10,000+ traffic cameras across 40+ US states and Canadian provinces, all accessible through one REST API.

The Problem

Every state DOT publishes camera images, but every one does it differently:

Georgia — JSON array with ImageUrl field, refreshes every 30 seconds
California — Caltrans CWWP2 SOAP-like API with district iteration
Ontario — Transnomis map markers with lazy-loaded detail popups
Kentucky — ArcGIS FeatureServer with paginated queries
Wyoming — XOR-encrypted protobuf binary files

Want cameras for a cross-state route? You're looking at 5+ separate integrations with different auth, formats, and update schedules.

One API Call

curl "https://api.road511.com/api/v1/features?type=cameras&jurisdiction=CA&limit=20" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "ca-cam-d7-101-001",
      "jurisdiction": "CA",
      "feature_type": "cameras",
      "name": "US-101 at Ventura Blvd",
      "latitude": 34.1583,
      "longitude": -118.4686,
      "is_active": true,
      "properties": {
        "image_url": "https://cwwp2.dot.ca.gov/data/d7/cctv/image/us101atventurabl/us101atventurabl.jpg",
        "direction": "Northbound",
        "highway": "US-101"
      }
    }
  ],
  "total": 1847,
  "has_more": true
}

The image_url is a direct link to the camera image. Most refresh every 30-120 seconds. Some cameras also have video_url for live streams.

GeoJSON for Maps

Want to drop every camera in a state directly onto a Leaflet map?

curl "https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA" \
  -H "X-API-Key: your_key"

Returns a standard GeoJSON FeatureCollection. Add it to your map layer with zero transformation:

const response = await fetch(
  'https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA',
  { headers: { 'X-API-Key': 'your_key' } }
);
const geojson = await response.json();

L.geoJSON(geojson, {
  onEachFeature: (feature, layer) => {
    const { name, image_url } = feature.properties;
    layer.bindPopup(`
      <strong>${name}</strong><br>
      <img src="${image_url}" width="320" loading="lazy">
    `);
  }
}).addTo(map);

Bounding Box Queries

Don't know which states your route crosses? Use a bounding box:

curl "https://api.road511.com/api/v1/features?type=cameras&bbox=-118.5,33.7,-117.8,34.3&limit=50" \
  -H "X-API-Key: your_key"

This returns cameras within the LA metro area regardless of jurisdiction.

Lazy-Loaded Details

Some cameras return compact data in list mode but have richer detail available on demand:

curl "https://api.road511.com/api/v1/features/ab-cam-001/details" \
  -H "X-API-Key: your_key"

The detail endpoint fetches the latest image URL and any additional metadata directly from the upstream source, cached in Redis for performance.

What's Available

State/Province	Camera Count	Refresh Rate
California	~1,800	1-5 min
Ontario	~800	2-5 min
Georgia	~700	30 sec
Michigan	~780	2-5 min
Texas	~600+	1-5 min
Pennsylvania	~500+	2-5 min
And 35+ more...

Use Cases

Navigation apps — show live camera views at upcoming interchanges
Fleet dispatch — verify conditions before routing a truck
Traffic dashboards — wall of cameras for control rooms
Weather verification — ground-truth current road conditions
ML training — traffic density estimation from camera images

Try It

How to Get Real-Time Traffic Camera Feeds via API

Roman Kotenko — Sun, 19 Apr 2026 07:32:36 +0000

No major traffic data provider gives you camera feeds. Not HERE, not TomTom, not Google, not INRIX. They all sell traffic flow from probe data, but live camera images? Nobody aggregates that.

Road511 does. 10,000+ traffic cameras across 40+ US states and Canadian provinces, all accessible through one REST API.

The Problem

Every state DOT publishes camera images, but every one does it differently:

Georgia — JSON array with ImageUrl field, refreshes every 30 seconds
California — Caltrans CWWP2 SOAP-like API with district iteration
Ontario — Transnomis map markers with lazy-loaded detail popups
Kentucky — ArcGIS FeatureServer with paginated queries
Wyoming — XOR-encrypted protobuf binary files

Want cameras for a cross-state route? You're looking at 5+ separate integrations with different auth, formats, and update schedules.

One API Call

curl "https://api.road511.com/api/v1/features?type=cameras&jurisdiction=CA&limit=20" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "ca-cam-d7-101-001",
      "jurisdiction": "CA",
      "feature_type": "cameras",
      "name": "US-101 at Ventura Blvd",
      "latitude": 34.1583,
      "longitude": -118.4686,
      "is_active": true,
      "properties": {
        "image_url": "https://cwwp2.dot.ca.gov/data/d7/cctv/image/us101atventurabl/us101atventurabl.jpg",
        "direction": "Northbound",
        "highway": "US-101"
      }
    }
  ],
  "total": 1847,
  "has_more": true
}

The image_url is a direct link to the camera image. Most refresh every 30-120 seconds. Some cameras also have video_url for live streams.

GeoJSON for Maps

Want to drop every camera in a state directly onto a Leaflet map?

curl "https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA" \
  -H "X-API-Key: your_key"

Returns a standard GeoJSON FeatureCollection. Add it to your map layer with zero transformation:

const response = await fetch(
  'https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA',
  { headers: { 'X-API-Key': 'your_key' } }
);
const geojson = await response.json();

L.geoJSON(geojson, {
  onEachFeature: (feature, layer) => {
    const { name, image_url } = feature.properties;
    layer.bindPopup(`
      <strong>${name}</strong><br>
      <img src="${image_url}" width="320" loading="lazy">
    `);
  }
}).addTo(map);

Bounding Box Queries

Don't know which states your route crosses? Use a bounding box:

curl "https://api.road511.com/api/v1/features?type=cameras&bbox=-118.5,33.7,-117.8,34.3&limit=50" \
  -H "X-API-Key: your_key"

This returns cameras within the LA metro area regardless of jurisdiction.

Lazy-Loaded Details

Some cameras return compact data in list mode but have richer detail available on demand:

curl "https://api.road511.com/api/v1/features/ab-cam-001/details" \
  -H "X-API-Key: your_key"

The detail endpoint fetches the latest image URL and any additional metadata directly from the upstream source, cached in Redis for performance.

What's Available

State/Province	Camera Count	Refresh Rate
California	~1,800	1-5 min
Ontario	~800	2-5 min
Georgia	~700	30 sec
Michigan	~780	2-5 min
Texas	~600+	1-5 min
Pennsylvania	~500+	2-5 min
And 35+ more...

Use Cases

Navigation apps — show live camera views at upcoming interchanges
Fleet dispatch — verify conditions before routing a truck
Traffic dashboards — wall of cameras for control rooms
Weather verification — ground-truth current road conditions
ML training — traffic density estimation from camera images

Try It

How to Get Real-Time Traffic Camera Feeds via API

Roman Kotenko — Wed, 15 Apr 2026 14:30:36 +0000

No major traffic data provider gives you camera feeds. Not HERE, not TomTom, not Google, not INRIX. They all sell traffic flow from probe data, but live camera images? Nobody aggregates that.

Road511 does. 10,000+ traffic cameras across 40+ US states and Canadian provinces, all accessible through one REST API.

The Problem

Every state DOT publishes camera images, but every one does it differently:

Georgia — JSON array with ImageUrl field, refreshes every 30 seconds
California — Caltrans CWWP2 SOAP-like API with district iteration
Ontario — Transnomis map markers with lazy-loaded detail popups
Kentucky — ArcGIS FeatureServer with paginated queries
Wyoming — XOR-encrypted protobuf binary files

Want cameras for a cross-state route? You're looking at 5+ separate integrations with different auth, formats, and update schedules.

One API Call

curl "https://api.road511.com/api/v1/features?type=cameras&jurisdiction=CA&limit=20" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "ca-cam-d7-101-001",
      "jurisdiction": "CA",
      "feature_type": "cameras",
      "name": "US-101 at Ventura Blvd",
      "latitude": 34.1583,
      "longitude": -118.4686,
      "is_active": true,
      "properties": {
        "image_url": "https://cwwp2.dot.ca.gov/data/d7/cctv/image/us101atventurabl/us101atventurabl.jpg",
        "direction": "Northbound",
        "highway": "US-101"
      }
    }
  ],
  "total": 1847,
  "has_more": true
}

The image_url is a direct link to the camera image. Most refresh every 30-120 seconds. Some cameras also have video_url for live streams.

GeoJSON for Maps

Want to drop every camera in a state directly onto a Leaflet map?

curl "https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA" \
  -H "X-API-Key: your_key"

Returns a standard GeoJSON FeatureCollection. Add it to your map layer with zero transformation:

const response = await fetch(
  'https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA',
  { headers: { 'X-API-Key': 'your_key' } }
);
const geojson = await response.json();

L.geoJSON(geojson, {
  onEachFeature: (feature, layer) => {
    const { name, image_url } = feature.properties;
    layer.bindPopup(`
      <strong>${name}</strong><br>
      <img src="${image_url}" width="320" loading="lazy">
    `);
  }
}).addTo(map);

Bounding Box Queries

Don't know which states your route crosses? Use a bounding box:

curl "https://api.road511.com/api/v1/features?type=cameras&bbox=-118.5,33.7,-117.8,34.3&limit=50" \
  -H "X-API-Key: your_key"

This returns cameras within the LA metro area regardless of jurisdiction.

Lazy-Loaded Details

Some cameras return compact data in list mode but have richer detail available on demand:

curl "https://api.road511.com/api/v1/features/ab-cam-001/details" \
  -H "X-API-Key: your_key"

The detail endpoint fetches the latest image URL and any additional metadata directly from the upstream source, cached in Redis for performance.

What's Available

State/Province	Camera Count	Refresh Rate
California	~1,800	1-5 min
Ontario	~800	2-5 min
Georgia	~700	30 sec
Michigan	~780	2-5 min
Texas	~600+	1-5 min
Pennsylvania	~500+	2-5 min
And 35+ more...

Use Cases

Navigation apps — show live camera views at upcoming interchanges
Fleet dispatch — verify conditions before routing a truck
Traffic dashboards — wall of cameras for control rooms
Weather verification — ground-truth current road conditions
ML training — traffic density estimation from camera images

Try It

How I Normalized 30+ Different 511 Traffic APIs Into One REST Endpoint

Roman Kotenko — Thu, 09 Apr 2026 11:50:10 +0000

Every US state and Canadian province runs its own 511 traveler information system. They all serve the same kind of data — traffic incidents, cameras, road conditions, message signs — but every single one does it differently.

I spent the past year building Road511, a unified API that normalizes data from 57 jurisdictions into one consistent REST endpoint. Here's what I learned about wrangling 30+ incompatible APIs into a single schema.

The Problem

Let's say you want traffic camera feeds for a route from New York to Chicago. You'll need to integrate:

New York — ibi511 REST API with custom JSON
Pennsylvania — ASP.NET map layer markers
Ohio — OHGO Public API with api-key param auth
Indiana — CARS platform REST microservices
Illinois — Travel Midwest POST endpoints with bbox body

Five states, five completely different APIs. Different authentication, different response formats, different field names for the same data. And that's just cameras — add events, road conditions, and message signs, and you're looking at 20+ integrations for one cross-state route.

Now multiply that by the entire continent.

The Format Zoo

Here's a sample of what "traffic event" looks like across different platforms:

Transnomis (GA, ID, WI, and 15 more states) — flat JSON with FlexString fields that can be either strings or numbers:

{
  "ID": "12345",
  "Head": "Crash on I-85 NB",
  "EventType": "incidents",
  "Severity": "Major",
  "Latitude": "33.7590",
  "Longitude": "-84.3880"
}

WZDx (24 US states) — GeoJSON with deeply nested properties:

{
  "type": "Feature",
  "geometry": { "type": "LineString", "coordinates": [...] },
  "properties": {
    "core_details": {
      "event_type": "work-zone",
      "road_names": ["I-95"],
      "direction": "northbound",
      "description": "Lane closure for bridge repair"
    }
  }
}

ArcGIS FeatureServer (KY, OH, TX, and 15 more) — Esri's paginated query format:

{
  "features": [{
    "attributes": {
      "OBJECTID": 456,
      "INCIDENTTYPE": 2,
      "DESCRIPTION": "Multi-vehicle crash",
      "LATITUDE": 38.0406,
      "LONGITUDE": -84.5037
    },
    "geometry": { "x": -84.5037, "y": 38.0406 }
  }],
  "exceededTransferLimit": false
}

Wyoming — Protobuf binary files, Base64-encoded and XOR'd with a static key. Seriously.

CARS GraphQL (NE, CO) — a GraphQL BFF layered over REST microservices.

Quebec — WFS GeoJSON from one endpoint, ASP.NET Element.ashx markers from another.

New England Compass (ME, NH, VT) — C2C XML portal with ATMS-format feeds.

That's 8+ distinct protocols. Same data, wildly different delivery.

The Architecture

The solution is a plugin registry with a single function signature:

type FetchFunc func(ctx context.Context, sr SourceResource) (*FetchResult, error)

type FetchResult struct {
    Events        []TrafficEvent
    Features      []Feature
    ResponseBytes int
}

Every adapter — whether it's parsing Transnomis JSON, decoding Wyoming protobuf, or querying ArcGIS pagination — implements this one interface. It takes a source resource config (URL, credentials, jurisdiction code) and returns normalized events and features.

Registration happens at init time:

func init() {
    Register("ky_arcgis", "events", fetchKYArcGISEvents)
    Register("ky_arcgis", "cameras", fetchKYArcGISCameras)
    Register("ky_arcgis", "rest_areas", fetchKYArcGISRestAreas)
    Register("ky_arcgis", "ferries", fetchKYArcGISFerries)
    Register("ky_arcgis", "signs", fetchKYArcGISSigns)
}

523 Register() calls across 76 adapter files. The scheduler doesn't know or care what format each source uses — it just calls Fetch() and gets back normalized data.

The Normalized Model

Everything converges into two tables:

traffic_events — time-bounded incidents with lifecycle tracking:

type TrafficEvent struct {
    ID                 string
    Source             string      // "on", "ga", "tx"
    Jurisdiction       string      // "ON", "GA", "TX"
    Type               EventType   // incident, construction, closure, weather
    Severity           Severity    // minor, moderate, major, critical
    Status             EventStatus // active, archived
    Title              string
    Description        string
    AffectedRoads      []string
    Direction          string
    LanesAffected      string
    Latitude, Longitude float64
    StartTime          time.Time
    EndTime            *time.Time
    EstimatedEndTime   *time.Time
    RoadClass          string      // interstate, us_highway, state_highway, local
    Metadata           json.RawMessage // source-specific fields preserved
}

features — generic table for everything else. Cameras, signs, weather stations, rest areas, bridge clearances, truck routes, EV charging — all use the same table with a feature_type discriminator and type-specific fields in a JSONB properties column. Adding a new data type requires zero schema migrations.

The Hard Parts

1. Lifecycle Tracking

A traffic incident isn't a static record. It escalates (minor to major), lanes change, ETAs shift, and eventually it clears. Each source reports the current state differently — some send updates, some just stop including the event.

The solution: diff the current state against the previous fetch. Track every change in an event_history table — severity changes, description updates, lane changes, archival. This enables analytics like clearance time percentiles and corridor reliability scoring.

2. Coordinate Chaos

Most sources send WGS84 (lat/lng). Some send Web Mercator (EPSG:3857). Some send state plane coordinates. Wyoming sends coordinates embedded in XOR'd protobuf. ArcGIS returns coordinates in its own spatial reference that may or may not be 4326.

PostGIS handles the heavy lifting, but each adapter has to know what it's receiving and transform accordingly.

3. Rate Limiting at Scale

57 jurisdictions, each with multiple resource types (events, cameras, signs, weather), each polling every 1-5 minutes. That's hundreds of outbound requests per minute to external 511 systems.

The scheduler uses per-server semaphores with configurable concurrency limits and request gaps. Circuit breakers back off on repeated failures. Adaptive backoff increases poll intervals when a source is slow or returning errors.

4. Schema-Free Feature Types

When I started, I had separate tables for cameras, signs, rest areas. Every new data type meant a migration. The pivot to a generic features table with JSONB properties was the best architectural decision in the project. Adding EV charging stations (100k+ from NREL) or bridge clearances (621k from FHWA) required zero schema changes.

The API

After all that normalization work, the API is straightforward:

Get active incidents in Ontario:

curl "https://api.road511.com/api/v1/events?jurisdiction=ON&type=incident&status=active" \
  -H "X-API-Key: your_key"

{
  "data": [
    {
      "id": "on_ev_12345",
      "jurisdiction": "ON",
      "type": "incident",
      "severity": "major",
      "title": "Multi-vehicle collision on Highway 401 WB",
      "affected_roads": ["Highway 401"],
      "direction": "Westbound",
      "lanes_affected": "2 of 4 lanes closed",
      "latitude": 43.6532,
      "longitude": -79.3832,
      "start_time": "2026-03-29T08:15:00Z",
      "estimated_end_time": "2026-03-29T12:00:00Z"
    }
  ],
  "total": 85,
  "limit": 100,
  "offset": 0,
  "has_more": false
}

Get traffic cameras in Georgia as GeoJSON:

curl "https://api.road511.com/api/v1/features/geojson?type=cameras&jurisdiction=GA" \
  -H "X-API-Key: your_key"

Drop that response directly into Leaflet, Mapbox, or any GeoJSON-compatible tool.

Query truck restrictions along a corridor:

curl "https://api.road511.com/api/v1/truck/corridor?from_lat=41.88&from_lng=-87.63&to_lat=40.71&to_lng=-74.01&buffer_km=5&height=4.2&weight=36" \
  -H "X-API-Key: your_key"

Returns every bridge clearance, weight restriction, and truck route segment within 5km of the Chicago-to-NYC corridor that your truck can't clear.

What's in the Data

This isn't just traffic events. The normalized dataset includes:

10,000+ live cameras with direct image/stream URLs
Dynamic message signs with current displayed text
621,000 bridges from the FHWA National Bridge Inventory (height, weight, condition)
479,000 truck route segments from the FHWA National Network
100,000+ EV charging stations from NREL
Weather stations with real-time RWIS readings
Rest areas and truck parking with amenity data
Seasonal weight restrictions (spring load limits from multiple states)
Road conditions (surface state, chain requirements)
Work zones, ferries, weigh stations, service vehicles, and more

Tech Stack

Go — chi router, pgx v5, slog
PostgreSQL + PostGIS — spatial queries, GeoJSON generation, corridor intersection
Redis — response caching, feature detail caching (nil-safe, optional)
Vue 3 + Leaflet — live traffic map

Try It

The API is live with a free tier (no credit card):

Live map — explore the data visually
API docs — full endpoint reference
Developer portal — sign up and get an API key
GitHub examples — Python, JavaScript, Go, curl, Postman collection
Also available on RapidAPI if that's your preferred marketplace

If you're building anything with traffic data — fleet routing, navigation, insurance risk, smart city dashboards — I'd love to hear what data you need. The hardest part isn't the code, it's knowing which 511 systems have which data in which format. After 57 jurisdictions, I've got a pretty good map.