# UK Road Traffic Flow Records — DfT AADF (`nexgensignal/uk-road-traffic-flow-records`) Actor

Keyless pay-per-record UK DfT AADF traffic flows — count point, road, year, and vehicle-class counts. No persons. OGL v3.0. GOLD $0.05 ladder.

- **URL**: https://apify.com/nexgensignal/uk-road-traffic-flow-records.md
- **Developed by:** [NexGen Signal](https://apify.com/nexgensignal) (community)
- **Categories:** Business, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $33.50 / 1,000 aadf records

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## UK Road Traffic Flow Records — DfT AADF

**Keyless. Pay per record. Every UK road count point's annual average daily traffic, by vehicle class, year by year.**

This actor turns the **UK Department for Transport (DfT) road traffic statistics** into clean, per-flow records — the Annual Average Daily Flow (AADF) at every count point on the UK's road network. Each run reads the DfT's keyless AADF API and delivers one row per count point / road / year: the count point and its location, the road name, category, and type, the junctions the link runs between, the link length, the estimation method, and the average daily vehicle counts broken down by class (pedal cycles, two-wheeled motor vehicles, cars and taxis, buses and coaches, LGVs, HGVs, and all motor vehicles). Count-point / road / year grain, structured for engineering use, under the Open Government Licence v3.0, with no personal data of any kind.

### What this is, in one paragraph

The DfT publishes the Annual Average Daily Flow — the estimated average number of vehicles using a road link on a typical day — for every count point on the UK network, back to 2000. This actor reads that dataset and flattens each count-point-year into a single analysis-ready record: the count point id, the year, the region and local authority, the road name, category (principal / trunk / motorway), and type, the start and end junctions of the link, the count point's coordinates and the link length, the estimation method, and the average daily counts for each vehicle class. Values are official statistics, carried **verbatim** as published. It is the traffic-volume layer of the UK road network. You are billed only for records actually delivered.

### Who buys this and for what job

- **Transport-planning, logistics, and infrastructure teams** analysing traffic volumes and vehicle mix by road, region, and year.
- **Retail-siting, out-of-home advertising, and property teams** scoring locations by passing traffic.
- **Environmental, active-travel, and policy products** studying modal share and HGV / cycle volumes over time.
- **Data engineers** who want the AADF series as clean rows without paging a 600k-record API by hand.

### Open Government Licence v3.0 — free commercial reuse

One licence rider travels on every record. DfT road traffic statistics are published under the **Open Government Licence v3.0 (OGL v3.0)** — free to reuse, including commercially, with attribution: "Contains public sector information licensed under the Open Government Licence v3.0." That attribution travels on every record. One honest caveat rides too: AADF figures are official statistics, some estimated (see `estimation_method`), carried verbatim — not a real-time traffic measurement.

### Count-point grain — no person data

The unit of every record is a count point on a road for a year — infrastructure, never a person. The coordinates are the count point's own fixed location, not anyone's. The dataset carries no natural-person fields — roads, count points, and vehicle-class volumes are the entire payload — and a person-key guard runs on every record as a pure backstop.

### Pricing

| Event | Free plan | Bronze | Silver | Gold / Platinum / Diamond |
|-------|-----------|--------|--------|---------------------------|
| `aadf_record` | $0.05 | $0.045 | $0.04 | $0.0335 |

Delivered before charged. Blocked runs and empty results cost nothing.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `year` | integer | — | Optional year to filter (e.g. 2023). |
| `regionId` | string | — | Optional DfT region id to filter. |
| `roadNameContains` | string | — | Optional. Keep only rows whose road name contains this text (e.g. A1, M25). |
| `maxRecords` | integer | 500 | Ceiling on records delivered and billed. |

### Output

One JSON object per count-point-year. Real example (values as published):

```json
{
  "record_id": "1",
  "count_point_id": "51",
  "year": 2000,
  "region_id": "1",
  "road_name": "A3111",
  "road_category": "PA",
  "road_type": "Major",
  "start_junction_road_name": "Pierhead, Hugh Town",
  "end_junction_road_name": "A3112",
  "latitude": 49.91501492,
  "longitude": -6.31713812,
  "link_length_km": 0.3,
  "estimation_method": "Estimated",
  "cars_and_taxis": 837,
  "all_hgvs": 12,
  "all_motor_vehicles": 1061,
  "source": "UK DfT road traffic statistics (AADF)",
  "licence": "UK Department for Transport ... Open Government Licence v3.0 ...",
  "disclaimer": "Annual Average Daily Flow (AADF) records at count-point / road / year grain ...",
  "observed_at": "2026-08-22T00:00:00Z"
}
```

An unbilled `RUN_RECEIPT` records the robots check, the filters, rows matched and delivered, and whether charged equals delivered.

### Field reference

Each record is one count-point-year. Identity and place: `record_id`, `count_point_id`, `year`, `region_id`, `local_authority_id`, `easting`, `northing`, `latitude`, and `longitude`. Road: `road_name`, `road_category`, `road_type`, `start_junction_road_name`, `end_junction_road_name`, `link_length_km`, and `link_length_miles`. Method: `estimation_method` and `estimation_method_detailed`. Vehicle-class counts: `pedal_cycles`, `two_wheeled_motor_vehicles`, `cars_and_taxis`, `buses_and_coaches`, `lgvs`, `all_hgvs`, and `all_motor_vehicles`. Provenance: `source`, `source_url`, `licence`, `attribution`, `disclaimer`, and `observed_at`.

### How a run works

A run first re-reads the source host's robots posture from your runtime — the DfT road-traffic host, whose robots is an explicit allow-all — and stops at the door if that ever changes. It pages the keyless AADF API, applies your optional year, region, and road-name filters, and flattens each count-point-year to one record — carrying the counts **verbatim**, never anything person-shaped — delivered **before** it is charged, so a blocked or empty run costs you nothing. The actor stops at your `maxRecords` ceiling and records `charge_equals_delivered` in the receipt.

### Coverage and scope

The AADF series holds on the order of **600,000+ count-point-years** across the UK network, back to 2000. Because each record carries the `year`, `road_category`, `region_id`, and the vehicle-class counts, segmenting by road class, region, or year — and building a traffic time series for any count point — is straightforward. Pull one year, one road, or the whole series to seed a traffic warehouse.

### Working with the flows

The series is a time series waiting to be assembled, and the identifiers make it mechanical. Every record carries the `count_point_id` and `year`, so a single filtered pull sorted by year reconstructs a count point's traffic trajectory, and the per-class counts let an analyst track how the vehicle mix — cars versus HGVs versus cycles — shifted over two decades. The `road_category` and `road_type` roll individual links up to the motorway, trunk, or principal-road network, while the coordinates place each count point for a spatial join to catchments or sites. Because the `estimation_method` travels on every row, a careful consumer can separate directly-counted links from estimated ones, and two annual pulls can be diffed to see where traffic grew or fell.

### Cost guidance

One `aadf_record` per delivered count-point-year: cost = rows delivered × your plan's per-record price. Scope with `year`, `regionId`, or `roadNameContains` to keep runs bounded. The whole series is ~600,000 rows; 1,000 rows is **$50** (Free) / **$33.50** (Gold).

### Honest limitations

- **Official statistics, as published.** AADF figures are annual averages, some estimated; this actor reformats, it does not recompute or measure in real time.
- **Count points, not every road.** The dataset covers the DfT count-point network at the published grain.
- **Attribute the DfT.** The OGL v3.0 attribution travels on every record.
- **No person data** of any kind.

### Differentiation

This is a **net-new** category for the NexGenData fleet — no existing fleet actor covers UK road traffic flows. It is distinct from the fleet's **uk-road-collision-records** (STATS19 collisions — *where crashes happened*, an incident feed) — this cell is traffic **volumes** (how many vehicles use a link), a different dataset at a different grain. Its specific job is the **DfT AADF count-point series**.

### The NexGen Signal family

Part of the NexGen Signal family of pay-per-record data products:

- [UK Road Collision Records — DfT STATS19](https://apify.com/nexgensignal/uk-road-collision-records)
- [GB NaPTAN Transit Node Records — DfT](https://apify.com/nexgensignal/gb-naptan-transit-node-records)
- [UK Port Freight Flow Records — DfT PORT0499](https://apify.com/nexgensignal/uk-port-freight-flow-records)
- [EU Vehicle CO2 Records — EEA](https://apify.com/nexgensignal/eu-vehicle-co2-records)
- [UK Company Status Records — Companies House](https://apify.com/nexgensignal/uk-company-status-records)

*Source: UK Department for Transport, road traffic statistics — Annual Average Daily Flow (roadtraffic.dft.gov.uk). Contains public sector information licensed under the Open Government Licence v3.0 — free to reuse, including commercially, with attribution to the Department for Transport. Count-point / road / year grain; the coordinates are the count point's own location; no person data of any kind. Official statistics, some estimated, carried verbatim; not a real-time measurement.*

# Actor input Schema

## `year` (type: `integer`):

Optional year to filter (e.g. 2023).

## `regionId` (type: `string`):

Optional DfT region id to filter.

## `roadNameContains` (type: `string`):

Optional. Keep only rows whose road name contains this text (e.g. A1, M25).

## `maxRecords` (type: `integer`):

Maximum records delivered and billed.

## Actor input object example

```json
{
  "maxRecords": 500
}
```

# Actor output Schema

## `results` (type: `string`):

Delivered records.

# 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 = {
    "maxRecords": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgensignal/uk-road-traffic-flow-records").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 = { "maxRecords": 500 }

# Run the Actor and wait for it to finish
run = client.actor("nexgensignal/uk-road-traffic-flow-records").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 '{
  "maxRecords": 500
}' |
apify call nexgensignal/uk-road-traffic-flow-records --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgensignal/uk-road-traffic-flow-records"
        }
    }
}

```

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/Bz1WqKOLz0vsneIXT/builds/G8H1XhT4juQlUhKBk/openapi.json