# Public Passenger Vehicle Licenses — Chicago (`alauddinburki/chi-public-passenger-vehicle-licenses`) Actor

A public passenger vehicle is a vehicle used for the transportation of passengers for hire by a public chauffeur. Returns 17 declared fields as flat JSON. Public Chicago Open Data data, no key.

- **URL**: https://apify.com/alauddinburki/chi-public-passenger-vehicle-licenses.md
- **Developed by:** [Alauddin burki](https://apify.com/alauddinburki) (community)
- **Categories:** Travel, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Public Passenger Vehicle Licenses — Chicago

A public passenger vehicle is a vehicle used for the transportation of passengers for hire by a public chauffeur. The list of public passenger vehicles includes licensed taxicabs (medallions), liveries, ambulances, medicars, charter-sightseeing buses, horse-drawn carriages, and pedicabs.
This Actor returns it as one flat JSON row per record, with 17 declared fields — typed, named and
documented in the dataset schema, so a spreadsheet or an agent can use it without guessing.

### What you get

| Field | Type | Meaning |
|---|---|---|
| `state` | string | State |
| `status` | string | Status |
| `taxi_affiliation` | string | Taxi Affiliation |
| `address` | string | Address |
| `vehicle_model_year` | number | Vehicle Model Year |
| `record_id` | string | Record ID |
| `city` | string | City |
| `wheelchair_accessible` | string | Wheelchair Accessible |
| `vehicle_type` | string | Vehicle Type |
| `vehicle_color` | string | Vehicle Color |
| `public_vehicle_number` | number | Public Vehicle Number |
| `vehicle_fuel_source` | string | Vehicle Fuel Source |
| `company_name` | string | Company Name |
| `vehicle_make` | string | Vehicle Make |
| `vehicle_model` | string | Vehicle Model |
| `zip_code` | number | ZIP Code |
| `taxi_medallion_license_management` | string | Taxi Medallion License Management  |

Every row also carries `sourceRowId`, `sourceUpdatedAt` and `scrapedAt`, so a pipeline can tell one record
from another and know exactly when it was read.

```json
{
  "state": "IL",
  "status": "INACTIVE",
  "taxi_affiliation": "Flash Cab Co",
  "address": "2350 W. OGDEN AVE.",
  "vehicle_model_year": 2020,
  "record_id": "6848Taxi",
  "city": "CHICAGO",
  "wheelchair_accessible": "N"
}
```

### Inputs

| Field | What it does |
|---|---|
| **Filter (SoQL)** | Applied at the source, so a narrow question fetches a narrow page instead of downloading everything. |
| **Order** | Empty keeps the publisher's own order; set a column to sort, for example `amount DESC`. |
| **Maximum rows** | Hard cap. The source is paged 1,000 rows at a time. |
| **Time budget** | Stops cleanly and reports how far it got. |
| **Pause between pages** | Keeps the run inside the publisher's rate limits. |

### Limitations

- **This is one dataset, from one publisher.** It is the Public Passenger Vehicle Licenses dataset as City of Chicago publishes it — not a
  national or cross-city equivalent, and not a merge with other sources.
- **The publisher can change it.** Columns are added, renamed and retired upstream; the field list here is the
  schema the Actor was generated from. A renamed column arrives as a new field only after the Actor is updated.
- **Fields are typed from live records.** A column that was empty in the sample is declared as text; a value that
  does not fit the declared type comes back `null` rather than being coerced into a wrong number.
- **Records are what the publisher publishes.** No geocoding, no de-duplication across datasets, no enrichment.
- **Freshness is the publisher's.** The data was last changed upstream on 2026-10-23. Where the publisher
  supplies a row timestamp it appears as `sourceUpdatedAt`; `scrapedAt` records when this Actor read the row.

### Why this is different

- Public Passenger Vehicle Licenses — Chicago declares all 17 of its output fields in the dataset schema, each with a type, a description and an example.
- The Actor reads the Public Passenger Vehicle Licenses dataset directly from Chicago Open Data; no key, login or account is needed.
- Filters run at the source with SoQL, so a narrow request returns a narrow page rather than a full download.
- Every row is flat JSON: nested location objects become `latitude` and `longitude`, and no field holds a nested object.
- The row id is stable, so the same request de-duplicates instead of returning the same record twice.

### FAQ

**Do I need an API key?** No. Chicago Open Data publishes this dataset openly.

**How fresh is it?** The Actor reads the dataset live. `scrapedAt` records when each row was read, and
`sourceUpdatedAt` carries the publisher's own row timestamp where it supplies one.

**Can I filter by date or status?** Yes — use the Filter field with SoQL, for example `status = 'Active'`.

**What happens if my filter is wrong?** The run stops with the portal's own message and the hint to check SoQL, rather than returning an empty dataset that looks like "no data".

**Is this the whole dataset?** Up to your row cap, paged 1,000 at a time. Raise the cap to read more.

**What is `sourceRowId`?** The publisher's own row id when it supplies one, otherwise a stable hash of the row. Either way it is what makes de-duplication and joins possible.

### Pricing

Pay per result: **$0.0005 per row**. A run that matches nothing is not charged for rows.

### Data source

Chicago Open Data — [Public Passenger Vehicle Licenses](https://data.cityofchicago.org/d/tfm3-3j95), published by City of Chicago.
Public data under the portal's open-data terms.

# Actor input Schema

## `where` (type: `string`):

Optional Socrata SoQL expression applied at the source, for example status = 'Active' or year > 2020. Leave empty for every row. An invalid expression returns a clear error, not an empty result.

## `order` (type: `string`):

Optional $order expression. Empty keeps the publisher's own order; set a column name to sort, for example amount DESC.

## `maxItems` (type: `integer`):

Hard row cap for the run. The source is paged 1,000 rows at a time and the Actor stops at this number.

## `budgetSecs` (type: `integer`):

Stops cleanly when this much time has passed and reports how far it got.

## `paceMs` (type: `integer`):

Delay between page requests, to stay inside the publisher's rate limits.

## Actor input object example

```json
{
  "where": "",
  "order": "",
  "maxItems": 5,
  "budgetSecs": 240,
  "paceMs": 120
}
```

# Actor output Schema

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

One row per record, with the 20 fields listed under Views.

# 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 = {
    "where": "",
    "order": "",
    "maxItems": 5,
    "budgetSecs": 240,
    "paceMs": 120
};

// Run the Actor and wait for it to finish
const run = await client.actor("alauddinburki/chi-public-passenger-vehicle-licenses").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 = {
    "where": "",
    "order": "",
    "maxItems": 5,
    "budgetSecs": 240,
    "paceMs": 120,
}

# Run the Actor and wait for it to finish
run = client.actor("alauddinburki/chi-public-passenger-vehicle-licenses").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 '{
  "where": "",
  "order": "",
  "maxItems": 5,
  "budgetSecs": 240,
  "paceMs": 120
}' |
apify call alauddinburki/chi-public-passenger-vehicle-licenses --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alauddinburki/chi-public-passenger-vehicle-licenses"
        }
    }
}
```

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/2Hz2YOr97bhCAggbK/builds/jr0bj9PiEHbKssrpL/openapi.json