Crime data API

Crime incidents for 41 US and Canadian cities in a single, uniform payload — pick a city code, pick a date range, page through the results — plus a crime score for any address or coordinate and 311 service requests for the 27 cities that publish them. Every city returns the same field names with the same meanings, so you integrate once. AI assistants can query the same data through the MCP server.

Overview

Authentication

Send your key in a header. Both forms are accepted:

# preferred
Authorization: Bearer sck_xxxxxxxxxxxx_yyyyyyyy…

# equivalent
X-API-Key: sck_xxxxxxxxxxxx_yyyyyyyy…

• A key looks like sck_<key_id>_<secret>. The key_id is public and identifies the key in your dashboard and in our audit log; the secret half is shown once, at creation, and we store only a hash of it. We cannot recover it for you — if it is lost, revoke and create a new one.
• Keys belong to your organization, not to an individual, so they survive staff changes and stay revocable by any org owner or admin.
• Do not use this API from browser JavaScript. We deliberately send no CORS headers: any key embedded in a web page is a public key. Call it from your backend.
• Revocation is immediate — it is checked on every request, not cached.

Quick start

curl -s "https://www.seecrime.com/api/v1/incidents?city=CHI&start=2026-07-01&end=2026-07-31&limit=5" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

Response:

{
  "api_version": "v1",
  "meta": {
    "city_key": "CHI",
    "city_name": "Chicago",
    "city_country": "US",
    "start": "2026-07-01",
    "end": "2026-07-31",
    "date_basis": "occurred",
    "timezone": "America/Chicago",
    "limit": 5,
    "returned": 5,
    "has_more": true,
    "next_cursor": "eyJkIjoiMjAyNi0wNy0zMVQxOTowMDowMCIsImkiOiIxMzMzNzExNiJ9",
    "multiple_records_per_incident": false,
    "data_earliest": "2021-01-01",
    "data_latest": "2026-07-30"
  },
  "incidents": [
    {
      "city_key": "CHI",
      "city_name": "Chicago",
      "city_state": "IL",
      "city_timezone": "America/Chicago",
      "record_id": "CHI-13337116",
      "incident_code": "JH123456",
      "incident_date": "2026-07-12T21:00:00",
      "incident_date_basis": "occurred",
      "incident_time_known": true,
      "incident_offense": "Motor Vehicle Theft",
      "incident_offense_code": "240",
      "incident_offense_description": "Motor Vehicle Theft",
      "incident_offense_detail_description": "Motor Vehicle Theft at 050XX N LAKE SHORE DR SB",
      "incident_offense_crime_against": "Property",
      "incident_offense_action": null,
      "incident_offense_severity": 5,
      "incident_offense_is_violent": false,
      "incident_source_name": "Chicago_Police_Department",
      "incident_source_original_type": "MOTOR VEHICLE THEFT",
      "incident_source_original_code": "0910",
      "incident_latitude": 41.975178,
      "incident_longitude": -87.649961,
      "incident_address": "050XX N LAKE SHORE DR SB",
      "incident_arrest": false,
      "incident_domestic": false,
      "incident_source_fields": {
        "description": "AUTOMOBILE",
        "location_description": "STREET",
        "beat": "2033",
        "district": "020",
        "ward": "48",
        "community_area": "3"
      }
    }
  ]
}

GET /incidents

One page of incidents for one city. city is the only required parameter.

Filters combine with AND, and offense, crime_against and violent intersect with each other. A combination with no possible matches returns an empty incidents array — not an error.

Three meta fields describe what came back. meta.one_per_incident echoes the parameter. meta.unit is incident when no two records on the page can belong to one incident (the flag was applied, or the city publishes one record per incident) and record when several can. meta.data_scope_note says what this city's data leaves out — see what a city's data leaves out; null means no limit is documented.

GET /incident-counts

How many incidents, in one city, with up to 3 breakdowns. It takes the same filters as /incidents (everything except limit, cursor and one_per_incident — a count is always of incidents), so a count answers for exactly the records you could page through, and the same values are refused with the same errors. Use it rather than paging to count.

• total counts incidents, not records. In the cities that publish one record per offense (multiple_records_per_incident), each incident is counted once, under one of its records that matches the filters — the one the map shows. So an offense filter counts every incident with any matching record, and can exceed that offense's row in an unfiltered category breakdown. meta.counting_rule says this on each response.
• The window is clipped to the data held, and meta.start / meta.end are the days actually counted; what you asked for is in meta.requested_start / meta.requested_end, and meta.window_clipped / meta.clip_reason say what moved. Divide by meta.days_counted for a daily rate; meta.days_with_records is how many of those days hold at least one counted incident.
• total is null, never 0, when nothing could be counted, and meta.null_reason says why: the window lies outside the data held; the agency published no records at all for those dates (a gap in its feed); the bbox or radius lies outside the city's data (a bbox is minLon,minLat,maxLon,maxLat); or the city publishes none of the requested categories (meta.filter_categories_not_published names the requested ones it does not). Each is a 200: the request was fine, and null is not zero crime. A 0 is a real zero — records were there and none matched, as for filters that contradict each other (offense=Robbery&violent=false).
• Non-crime records are left out by default (warrant service, lost property, assists; meta.exclude_non_crime says which applied), and exclude_non_crime=false counts them; meta.non_crime_count is how many the count holds. Telling them apart needs the city's offense vocabulary, so when that cannot be read a count that leaves them out answers 503 filter_unavailable rather than including them silently.
• At most 731 days of data per request (400 date_range_too_long; split the window and add the totals), and group_by=day covers at most 366 days (400 too_many_buckets; use week or month).
• category lists every offense category the city publishes, with 0 where none fell in the window; a category it never publishes is in not_published, never a 0. If the city's vocabulary could not be read, vocabulary_known is false and only counted categories are listed. violent splits into violent, non_violent_crime and non_crime. native_type is the agency's own offense names, the top 100, with the rest summed in other_count.
• week buckets are ISO weeks. A week or month cut by the window carries partial: true with days_counted of days_in_bucket; don't compare it with a full one. weekday gives days_counted per weekday, since a window rarely holds the same number of each.
• meta.data_scope_note says what this city's data leaves out, so what a total cannot include — see what a city's data leaves out. null means no limit is documented.
• hour is available: false with reason: "no_clock_time" where the city publishes a date only or an artifact time (the cities whose incident_time_known is false), "no_clock_time_detected" where nearly every incident falls in one hour, and "too_few_to_tell" where too few incidents carry a time to tell a real clock time from a placeholder. Incidents whose hour can't be read are in hour_unknown.

curl -s "https://www.seecrime.com/api/v1/incident-counts?city=CHI&start=2026-04-01&end=2026-09-30&exclude_non_crime=true&group_by=category,month" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "api_version": "v1",
  "contract_version": "1.9.0",
  "meta": {
    "city_key": "CHI", "unit": "incident", "multiple_records_per_incident": false,
    "requested_start": "2026-04-01", "requested_end": "2026-09-30",
    "start": "2026-04-01", "end": "2026-09-28", "days_counted": 181,
    "window_clipped": true,
    "clip_reason": "The counted window ends at the city's latest data (2026-09-28).",
    "null_reason": null, "days_with_records": 181,
    "exclude_non_crime": true, "non_crime_count": 0,
    "filter_categories_not_published": null,
    "group_by": ["category", "month"]
  },
  "total": 114203,
  "breakdowns": {
    "category": {"available": true, "vocabulary_known": true,
      "groups": [{"key": "Larceny/Theft", "count": 30117, "crime_against": "Property", "is_violent": false}, ...],
      "not_published": ["Gambling"]},
    "month": {"available": true,
      "groups": [{"key": "2026-09", "start": "2026-09-01", "end": "2026-09-28", "days_counted": 28, "days_in_bucket": 30, "partial": true, "count": 17520}, ...]}
  }
}

Numbers above are illustrative. Responses carry Cache-Control: private, max-age=60.

GET /risk-score

A crime score for a single point — pass coordinates, or a US street address and we geocode it. Same scorer that powers the risk card in the app, so the two never disagree. The score ranks the point among its own city's places by how much reported crime the model estimates there; how the score is calculated is below, and model in the response carries the estimate behind it.

Address lookup is US-only. The geocoder behind address= covers US street addresses; for a covered city outside the US, pass lat and lon directly — the scorer itself works anywhere we hold data. An address we cannot locate returns 422 address_not_found, which is deliberately distinct from 503 geocoder_unavailable.

Supply either coordinates or an address. The search radius is a fixed ¼ mile (0.4 km) and is not configurable — two addresses are only comparable when the circle is the same size.

curl -s "https://www.seecrime.com/api/v1/risk-score?lat=32.816&lon=-96.741" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "api_version": "v1",
  "contract_version": "1.9.0",
  "query": {
    "address": null, "matched_address": null, "geocoder": null,
    "radius_km": 0.4, "lat": 32.816, "lon": -96.741
  },
  "city_key": "DAL", "city_name": "Dallas", "city_state": "TX",
  "scored": true,
  "score": 43, "grade": "C", "label": "Moderate Risk",
  "incidents": {
    "radius_km": 0.4, "total": 3, "violent": 0, "property": 3,
    "last_30_days": 1, "last_90_days": 3,
    "top_offenses": [
      {"offense": "THEFT OF PROP > OR EQUAL $750 <$2,500 (NOT SHOPLIFT) PC31.03(e3)", "count": 1},
      {"offense": "BURGLARY OF BUILDING - FORCED ENTRY", "count": 1},
      {"offense": "BMV", "count": 1}
    ]
  },
  "measures": {
    "vs_city_average_pct": -57, "trend": "stable",
    "night_share_pct": null, "night_share_coverage": 0.0, "has_night_data": false,
    "arrest_rate_pct": 0, "has_arrest_data": true,
    "has_foot_traffic_data": false
  },
  "model": {
    "version": "eb2y-2026-10-20", "window_days": 730, "history_days": 730,
    "half_life_days": 365, "reference_places": 1632,
    "percentile": 43.4, "percentile_interval": [33, 52],
    "index": 43, "index_interval": [32, 55], "index_tier": "below",
    "confidence": "medium", "no_reports_in_window": false,
    "expected_incidents_per_year": {"estimate": 18.1, "interval": [13.2, 23.8]},
    "groups": [
      {"key": "persons", "label": "Crimes against persons", "published": true,
       "distinguishable": true, "index": 13, "index_interval": [2, 33], "percentile": 22},
      {"key": "property", "label": "Crimes against property", "published": true,
       "distinguishable": true, "index": 50, "index_interval": [36, 67], "percentile": 50},
      {"key": "society", "label": "Crimes against society", "published": true,
       "distinguishable": true, "index": 13, "index_interval": [2, 34], "percentile": 28},
      {"key": "other", "label": "Other offences", "published": true,
       "distinguishable": true, "index": 15, "index_interval": [1, 44], "percentile": 18}
    ],
    "offenses": [
      {"key": "Homicide", "label": "Homicide", "published": true,
       "distinguishable": false, "index": null, "index_interval": null, "percentile": null},
      {"key": "Burglary", "label": "Burglary", "published": true,
       "distinguishable": true, "index": 114, "index_interval": [53, 195], "percentile": 73},
      {"key": "Larceny/Theft", "label": "Larceny / theft", "published": true,
       "distinguishable": true, "index": 40, "index_interval": [22, 62], "percentile": 49}
    ],
    "surrounding_area": {"radius_km": 1.6, "index": 62, "index_interval": [58, 65],
                         "pattern": "quieter"},
    "trend": {"direction": "stable", "relative_change_pct": -26, "p_value": 0.8768,
              "recent_days": 90, "recent_incidents": 3,
              "baseline_days": 365, "baseline_incidents": 17},
    "year_over_year": {"last_12_months": 15, "prior_12_months": 23,
                       "change_pct": -35, "city_change_pct": -2}
  },
  "permitted_use": "This score describes reported incidents in an area over a time window. It is not about any person or property, and it must not be used to make housing, tenancy, employment, credit or insurance decisions about an identifiable person.",
  "window": {
    "start": "2026-05-22", "end": "2026-08-19",
    "ends_today": false, "data_lag_days": 60
  },
  "coverage": {
    "limitation": null, "area_coverage_pct": 1.0,
    "nearby_incidents": 2562, "nearby_radius_km": 5.0,
    "city_has_recent_data": true, "outside_data_footprint": false,
    "data_coverage_pct": 1.0, "footprint": "city_boundary", "data_scope_note": null
  }
}

A real response for a residential block in Dallas, computed on a copy of the data whose newest day was 2026-08-19 (hence data_lag_days), with model.offenses shortened to three of its entries. Homicide is distinguishable: false here: Dallas records too few for this place's own count to tell it apart from the city level, so no index is published for it rather than the city average. Three incidents in the last 90 days, but the model reads the place's whole model.window_days: more reported crime than about 43% of Dallas's places, 43% of the city average, with the intervals saying how far either could be off.

Read scored before you read score

How the score is calculated

The score is a model estimate, not a count. For the 0.4 km circle we take every incident in the 730 days ending at window.end, by offense category, and weight each by its age: one 365 days old counts half as much as one from the last day. Each category's rate is then estimated with an empirical Bayes (Poisson–Gamma) model fitted to the city's own places, so a place with few incidents is pulled toward the city's level and a place with many keeps its own, and every estimate carries a 90% interval for that rate. The rate is always over the whole circle, however much of it lies inside the city's data. The categories' rates are added up, each weighted by its severity, and that sum is ranked among the city's reference places — squares of 0.71 km a side (the circle's own area) holding at least 2 incidents over the same period. The rank is model.percentile, which score rounds; the same sum against the city's average is model.index.

• Relative to the city. A score of 70 means more reported crime than about 70% of the city's places, so a C in Dallas and a C in Chicago say different things. model.expected_incidents_per_year is the one absolute figure, and two cities' feeds publish different things (coverage.data_scope_note).
• An estimate, with its uncertainty. Read model.percentile_interval and model.confidence with the score: a quiet block's interval is wide. The intervals are for the place's underlying rate, not a range a future count will fall in: crime clusters in time more than chance alone would, so a later quarter's count falls outside a range built from them more often than one time in ten.
• Reported crime only. It counts what the agency published. Foot traffic, the arrest rate and the night share are reported in measures and do not affect it.
• Not ranked where the city is too thin. A city with fewer than 20 reference places, or fewer than 200 incidents over the period, has no distribution to rank a place in, and answers too_few_incidents_citywide.

Response fields

model

Present when scored is true. Indices are against the city's own average, so 100 is the average, 200 twice it and 50 half. Every interval is a 90% interval for the place's underlying rate, not a forecast range for a future count.

coverage.limitation

One field to branch on. null means score it as read. When more than one applies you get the first, in this order.

Zero incidents does not by itself mean no coverage. A genuinely quiet residential block also returns zero, so we additionally count what exists within nearby_radius_km, and check how much of the circle lies inside the city's data footprint: a circle inside the footprint with nothing in it is quiet, and it still gets a grade. Nothing nearby, or a circle mostly outside the footprint, means the data does not reach the address, and that is the case we refuse to grade.

Errors specific to this endpoint

Address lookups add roughly 0.2–2 s on a first request and are cached afterwards. If you are scoring the same locations repeatedly, geocode once on your side and pass lat/lon.

GET /service-requests

311 service requests — potholes, graffiti, illegal dumping, missed collections — for the 27 of 41 cities that publish them. Same city codes, same pagination, same date semantics as /incidents.

curl -s "https://www.seecrime.com/api/v1/service-requests?city=CHI&type=Pothole+in+Street&limit=2" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "meta": {
    "city_key": "CHI", "start": "2026-07-11", "end": "2026-08-10",
    "limit": 2, "returned": 2, "has_more": true, "next_cursor": "eyJk…",
    "request_type_vocabulary": "city_specific",
    "publishes_closed_date": true,
    "publishes_status": true
  },
  "service_requests": [
    {
      "city_key": "CHI", "city_name": "Chicago", "city_state": "IL",
      "city_timezone": "America/Chicago",
      "record_id": "CHI-SR26-01234567",
      "request_code": "SR26-01234567",
      "request_type": "Pothole in Street",
      "request_subtype": "PHF",
      "request_status": "Completed",
      "request_is_open": false,
      "request_opened_date": "2026-07-28T08:14:00",
      "request_opened_time_known": true,
      "request_closed_date": "2026-08-04T15:02:00",
      "request_channel": "Phone Call",
      "request_latitude": 41.902117, "request_longitude": -87.663443,
      "request_address": "1600 N WESTERN AVE",
      "request_source_fields": {
        "zip_code": "60647", "ward": "1", "community_area": "24",
        "community_area_name": "WEST TOWN", "police_district": "014"
      }
    }
  ]
}

request_is_open is tri-state

5 of the 27 cities publish no close date at all. For those, request_is_open is null — not true, because "no close date recorded" and "still open" are different claims and we only know the first. meta.publishes_closed_date tells you which case you are in, and open_only returns 400 unsupported_filter rather than silently returning everything.

Field notes

Asking for a city we cover for crime but that publishes no 311 returns 404 no_311_coverage — deliberately different from unknown_city, which means the code itself was wrong.

GET /service-request-types

Every distinct request_type for one city, with counts, most common first. This is how the type filter becomes usable — call it once per city and cache it. Counts cover every request we hold for the city and are refreshed after each daily data fetch, so they usually trail the newest requests by up to a day.

curl -s "https://www.seecrime.com/api/v1/service-request-types?city=CHI" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "api_version": "v1",
  "city_key": "CHI", "city_name": "Chicago",
  "count": 96,
  "truncated_at": null,
  "request_types": [
    { "request_type": "Pothole in Street", "count": 184203 },
    { "request_type": "Graffiti Removal",  "count": 151874 }
  ]
}

Capped at 500 types; truncated_at is null unless a city exceeded it, in which case it holds the cap. Asking for a city we cover for crime but that publishes no 311 returns 404 no_311_coverage, the same as /service-requests — a code that is not recognised at all is 400 unknown_city.

GET /cities

Every covered city with its code, timezone, publishing agency, available date range, and per-city capabilities. Call this at startup and cache it — it is how a newly added city reaches your integration without a code change on your side. No parameters.

curl -s "https://www.seecrime.com/api/v1/cities" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "api_version": "v1",
  "count": 41,
  "cities": [
    {
      "city_key": "CHI",
      "city_name": "Chicago",
      "city_state": "IL",
      "city_country": "US",
      "city_timezone": "America/Chicago",
      "source_name": "Chicago_Police_Department",
      "date_basis": "occurred",
      "data_earliest": "2021-01-01",
      "data_latest": "2026-07-30",
      "multiple_records_per_incident": false,
      "supports": {
        "date_filter": true,
        "offense_filter": true,
        "spatial_filter": true,
        "arrest_field": true,
        "domestic_field": true
      },
      "has_311_data": true,
      "data_scope_note": null
    }
  ]
}

GET /offenses

The complete offense vocabulary — every value incident_offense can take, with its NIBRS code, group, severity weight and violent flag. Static apart from taxonomy releases, and the same 25 values rendered in the catalog below. No parameters.

curl -s "https://www.seecrime.com/api/v1/offenses" \
  -H "Authorization: Bearer $SEECRIME_API_KEY"

{
  "api_version": "v1",
  "count": 25,
  "offenses": [
    {
      "offense": "Robbery",
      "offense_code": "120",
      "crime_against": "Property",
      "severity": 8,
      "is_violent": true,
      "is_crime": true
    },
    {
      "offense": "Non-Crime",
      "offense_code": null,
      "crime_against": "Other",
      "severity": 0,
      "is_violent": false,
      "is_crime": false
    }
  ]
}

MCP server (for AI assistants)

The same data, as tools an AI assistant can call. https://www.seecrime.com/mcp is a Model Context Protocol server: connect Claude, OpenAI's Responses API, Gemini CLI, Cursor, VS Code or any other MCP client, and the model can look up cities, search incidents and 311 requests, and score an address itself. Each tool runs one of the endpoints above and returns exactly the JSON that endpoint returns for the same arguments: the same fields, the same nulls, the same cursors and error codes. An AI app connects in one of two ways: you sign in with your seecrime account and approve the app (most apps: paste the URL and sign in, see Sign in an AI app), or it presents an API key, the same key and the same rate limits as /api/v1 (servers, scripts and the local bridge). Signing in needs a paid plan (Pro, Team or Enterprise) on an account in an organization; a key comes from your organization's owner or admin, as under Authentication. A request through either counts against your organization's limits.

Tools

7 tools, in the order the server lists them. The last column is the description the model receives, word for word: it carries the data caveats that matter for that tool. Arguments use the REST parameter names and meanings (follow the endpoint link), with three differences: offense and crime_against are JSON arrays, bbox is an array of four numbers, and an argument sent as null counts as omitted.

Security

• The key is a secret. Keep it server-side: in your backend's secret store, an environment variable, or your client's own secret prompt, and out of any file you commit. Never put it in a URL; a key in the query string is ignored and answered 401, and it would be copied into logs and history on the way. Never put it in browser code: the endpoint sends no CORS headers, and a request carrying another site's Origin is refused with 403. If a key leaks, revoke it on this page and mint another.
• Signing in. seecrime.com asks every time an app connects, and shows who is asking (the app's web address for a published app, "unverified" for one that registered itself), where it will send you back, and what it may do: read the data through these tools, as you, and nothing else. Access tokens last 60 minutes; the app renews them with a refresh token that lapses after 30 days unused and after 180 days in any case. Disconnect an app any time under Profile, Connected AI apps (an organization owner or admin can disconnect members' apps from the organization page). A password change or reset, leaving the organization or moving to the free plan disconnects every app at once. A sign-in token that appears in a URL, on any page of the site, is revoked at once (URLs are logged); an app sends its token only in the Authorization header.
• Tool results contain third-party data, which the model must treat as data, not as instructions. Addresses, offense descriptions and 311 request text come verbatim from city feeds, and we do not alter them. Every tool description and the server's instructions tell the model so, but your application should still never let text from a tool result trigger an action on its own.
• Permitted use of the risk score. Every get_risk_score result carries this text as permitted_use, and the model is told to show it with the score:

• Read-only. All 7 tools only read published data, and each is marked readOnlyHint: true.
• What we log: one line per request with the method, the tool name and your public key_id (for a signed-in app, the connection's id). Never the arguments (an address is personal data), never a secret or a token.

Known limits

• Sign-in needs a paid plan. Pro, Team or Enterprise, on an account in an organization. A free account that tries to connect an app is shown why it cannot; close that page and return to the app yourself. One account can approve at most 50 app connections in 24 hours.
• A wrong key starts a sign-in. A client that can sign in (Claude Code, the MCP Inspector and others) reads any 401 as a request to sign in, and offers that instead of showing "The API key is not valid.". Signing in works; if you meant to use a key, check it.
• Apps that registered themselves are labelled unverified. seecrime.com cannot confirm who made such an app; its approval screen says so and shows where it will send you back. Approve only an app you started connecting yourself.
• An app that answers 403 instead of offering to sign in is sending an Origin header the server does not recognise. The server checks Origin before it looks for a credential, so such an app never sees the sign-in challenge. Contact us to have its origin allowed.
• A refresh token works once. An app that sends the same refresh token again within 30 seconds (a lost response, a retry) gets a new pair; later than that, or once both of the pairs it got are in use, the connection ends and you sign in again, because a reused token may be a stolen one.
• Small pages. 25 records by default and 100 at most. A model that needs more pages with cursor; for bulk export, call /api/v1 directly.
• Address lookup is US-only, as on /risk-score. In a Canadian city, pass lat and lon.
• Tools only: no resources, prompts or subscriptions, no streamed progress, and a request body of at most 1 MB.
• The data caveats apply unchanged. The tools return the REST JSON, so everything under Incident fields and Data caveats holds for tool output too: local time with no offset, occurred and reported dates, null is not zero, and one record per offense in some cities.
• Two kinds of refusal. When the endpoint refuses a call (an unknown city code, a bad date), the answer is a tool result with isError: true whose text is the {"error", "message"} body listed under Errors. When the request is refused (no key or a bad one, a rate limit, the service unavailable), the answer is the HTTP status (401, 403, 429 or 503, with Retry-After where the REST API sends one) and a JSON-RPC error whose data.error is the REST code: {"jsonrpc": "2.0", "error": {"code": -31000, "message": "…", "data": {"error": "rate_limit_exceeded"}}}.

Connect a client

Most AI apps need only the URL https://www.seecrime.com/mcp: they find seecrime's sign-in themselves, send you to seecrime.com to sign in with your seecrime account (on a paid plan) and approve them, and keep the connection from then on (Sign in an AI app). An API key suits a backend, a script, and the local bridge (Connect with an API key). The same steps for Claude and ChatGPT, written for people who are not developers, are at /ai-assistants. Each step was checked against the client's own documentation on the date in the comment beside it; if a client's screens differ, they may have changed since.

Sign in an AI app

The server answers an app that has no credential with a sign-in challenge naming https://www.seecrime.com/.well-known/oauth-protected-resource/mcp, and the app takes it from there. You see seecrime.com's approval screen: check the app's name and web address and where it will send you back, then Approve. The app may read crime, 311 and risk-score data through the tools above, as you, with scope crime:read, and nothing else. Only an account on a paid plan (Pro, Team or Enterprise), in an organization, can approve an app. Disconnect it any time under Profile, Connected AI apps.

Claude: claude.ai, Claude Desktop and the mobile apps

1. Go to Customize → Connectors and click Add custom connector. On a Claude Team or Enterprise plan, an Owner adds it once for the organization instead, under Organization settings → Connectors → Add → Custom.
2. Enter the URL https://www.seecrime.com/mcp and click Add. If the dialog asks how Claude identifies itself, keep Use Claude's published identity; you need no client ID or secret.
3. Click Connect on the connector, sign in to seecrime.com in the window that opens, and approve the app.

A connector added on claude.ai is there in Claude Desktop and the mobile apps too, signed in as the same account.

Claude Code

claude mcp add --transport http seecrime https://www.seecrime.com/mcp

Then run /mcp in Claude Code: the server shows as needing authentication, and choosing it opens your browser to sign in and approve. From a shell, claude mcp login seecrime does the same (add --no-browser on a machine without one); claude mcp logout seecrime signs out.

ChatGPT

1. Open ChatGPT Plugins, select the plus button, then Add custom MCP server. Your workspace's policies decide whether this is available.
2. Give it a name, enter the URL https://www.seecrime.com/mcp, and choose OAuth for authentication. ChatGPT identifies itself with its own published client details; you need no client ID or secret.
3. Create it, then sign in to seecrime.com when ChatGPT sends you there, and approve the app.

Cursor

{
  "mcpServers": {
    "seecrime": {
      "url": "https://www.seecrime.com/mcp"
    }
  }
}

In ~/.cursor/mcp.json, or .cursor/mcp.json in a project. Cursor registers itself with seecrime's sign-in service and sends you to seecrime.com to sign in and approve it; because it registers itself, the approval screen labels it unverified.

VS Code

{
  "servers": {
    "seecrime": {
      "type": "http",
      "url": "https://www.seecrime.com/mcp"
    }
  }
}

In .vscode/mcp.json, or your user configuration (MCP: Open User Configuration). No oauth block is needed: VS Code finds seecrime's sign-in when it first connects and opens your browser to sign in and approve.

Gemini CLI

{
  "mcpServers": {
    "seecrime": {
      "httpUrl": "https://www.seecrime.com/mcp"
    }
  }
}

In ~/.gemini/settings.json. Gemini CLI finds the sign-in when the server answers 401; run /mcp auth seecrime to sign in and approve, and again if it asks you to later.

Connect with an API key

For a backend, a script, or a client that cannot sign in. Every one needs the same two things: the URL https://www.seecrime.com/mcp and the header Authorization: Bearer <your key>. Where a client can read the key from an environment variable (SEECRIME_API_KEY here) or from its own secret prompt, the example does, so the key does not sit in a file you might commit. Each example was checked against the client's own documentation on 2026-10-06; if a client rejects a field, its format may have changed since.

Claude: the Messages API

Anthropic's MCP connector calls the server for you from inside a Messages API request (beta header mcp-client-2025-11-20). Give the key as the server's authorization_token; the connector presents it as the bearer token. Run this from your backend.

import os
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "List the five most recent robberies reported in Chicago."}],
    mcp_servers=[{
        "type": "url",
        "url": "https://www.seecrime.com/mcp",
        "name": "seecrime",
        "authorization_token": os.environ["SEECRIME_API_KEY"],
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "seecrime"}],
    betas=["mcp-client-2025-11-20"],
)

The connector needs the mcp_toolset entry and an https URL, and uses only the tools part of MCP, which is all this server offers. If you copy the tool schemas into your own tool definitions instead, do not mark them strict: strict tool use rejects the numeric and length limits they carry and the four-number bbox, with a 400. The connector itself is not affected.

Claude Code

claude mcp add --transport http seecrime https://www.seecrime.com/mcp \
  --header "Authorization: Bearer $SEECRIME_API_KEY"

Your shell fills in $SEECRIME_API_KEY (in PowerShell, write $env:SEECRIME_API_KEY), and Claude Code keeps the server in your own ~/.claude.json, its default local scope. claude mcp list shows whether it connected. To share the server with a team in a project's .mcp.json, commit a reference rather than the key; Claude Code expands it from each person's environment:

{
  "mcpServers": {
    "seecrime": {
      "type": "http",
      "url": "https://www.seecrime.com/mcp",
      "headers": { "Authorization": "Bearer ${SEECRIME_API_KEY}" }
    }
  }
}

Claude Desktop (local bridge)

Claude Desktop's configuration file starts local servers. The seecrime bridge, seecrime_mcp_stdio.py, is a single Python file (Python 3.9 or newer, standard library only, nothing to install) that Claude Desktop starts; it forwards each message to https://www.seecrime.com/mcp with your key. Its SHA-256 is b693d7cc4cd6ac24595c8314c3142135052fe2fa8e6dc2c6ad73569f6ccc0ceb; compare it with the output of shasum -a 256 seecrime_mcp_stdio.py (macOS, Linux) or Get-FileHash seecrime_mcp_stdio.py (Windows) before you run it. Save it somewhere permanent, open the configuration from Settings → Developer → Edit Config (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json; Windows: %APPDATA%\Claude\claude_desktop_config.json) and add:

{
  "mcpServers": {
    "seecrime": {
      "command": "python3",
      "args": ["/Users/you/seecrime/seecrime_mcp_stdio.py"],
      "env": { "SEECRIME_API_KEY": "sck_your_key_here" }
    }
  }
}

Then quit Claude Desktop completely and start it again. On Windows, use "command": "python" and a path with doubled backslashes, such as "C:\\Users\\you\\seecrime\\seecrime_mcp_stdio.py". The key goes in env, never in args, where other programs on the computer can read it. SEECRIME_MCP_URL is optional and defaults to https://www.seecrime.com/mcp. The same entry works in any client that can only start local servers.

Claude: claude.ai custom connectors

A custom connector can send a fixed header only where your claude.ai organization has request headers, which Anthropic offers as a beta to a limited set of organizations. If the Add custom connector dialog shows a Request headers section:

1. Add a custom connector (Customize → Connectors, or Organization settings → Connectors on a Claude Team or Enterprise plan) with the URL https://www.seecrime.com/mcp.
2. Under Authentication, choose No sign-in.
3. Under Request headers, add authorization with the value Bearer sck_<key_id>_<secret>. Include Bearer and the space: Claude sends the value exactly as you enter it.

Everyone who can use that connector uses your organization's key. Without the Request headers section, or to have each person connect as themselves, sign in instead.

OpenAI: the Responses API

OpenAI's remote MCP tool connects from OpenAI's side. Give the key, without Bearer, as the tool's authorization: OpenAI does not store that value or show it in the Response object, so send it on every request.

import os
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-astra",
    input="List the five most recent robberies reported in Chicago.",
    tools=[{
        "type": "mcp",
        "server_label": "seecrime",
        "server_description": "Read-only crime and 311 data for US and Canadian cities.",
        "server_url": "https://www.seecrime.com/mcp",
        "authorization": os.environ["SEECRIME_API_KEY"],
        "require_approval": {"never": {"read_only": True}},
    }],
)
print(resp.output_text)

The approval filter lets the model call tools marked read-only without a confirmation round trip, and every seecrime tool is marked read-only. Leave require_approval out to approve each call, which is OpenAI's default. The tool also accepts the header itself, "headers": {"Authorization": "Bearer <your key>"}, in place of authorization.

Gemini CLI

In ~/.gemini/settings.json, or a project's .gemini/settings.json. Use httpUrl, not url, which Gemini CLI reads as an SSE endpoint. It expands ${SEECRIME_API_KEY} from your environment when it loads the file.

{
  "mcpServers": {
    "seecrime": {
      "httpUrl": "https://www.seecrime.com/mcp",
      "headers": { "Authorization": "Bearer ${SEECRIME_API_KEY}" }
    }
  }
}

Or add it from the command line. Your shell fills in the key and Gemini CLI writes the result to a settings file, so keep -s user: it puts the entry in your own ~/.gemini/settings.json, where the command's default scope would put the key itself in the project's .gemini/settings.json.

gemini mcp add -s user --transport http --header "Authorization: Bearer $SEECRIME_API_KEY" seecrime https://www.seecrime.com/mcp

Gemini API (Interactions API)

The Interactions API describes a remote MCP server as an mcp_server tool. Google's own overview says Gemini 3 models do not support remote MCP yet, so check that the model you call supports it before relying on this entry:

{
  "type": "mcp_server",
  "name": "seecrime",
  "url": "https://www.seecrime.com/mcp",
  "headers": { "Authorization": "Bearer sck_<key_id>_<secret>" }
}

Cursor

In ~/.cursor/mcp.json, or .cursor/mcp.json in a project. Cursor reads ${env:SEECRIME_API_KEY} from your environment.

{
  "mcpServers": {
    "seecrime": {
      "url": "https://www.seecrime.com/mcp",
      "headers": { "Authorization": "Bearer ${env:SEECRIME_API_KEY}" }
    }
  }
}

VS Code

In .vscode/mcp.json, or your user configuration (MCP: Open User Configuration). VS Code uses servers, not mcpServers. The inputs entry makes it ask for the key the first time the server starts and store it securely, so the file holds no secret.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "seecrime-api-key",
      "description": "seecrime API key",
      "password": true
    }
  ],
  "servers": {
    "seecrime": {
      "type": "http",
      "url": "https://www.seecrime.com/mcp",
      "headers": { "Authorization": "Bearer ${input:seecrime-api-key}" }
    }
  }
}

Any other MCP client

Give it the URL and the header; the server needs nothing else.

URL     https://www.seecrime.com/mcp
Header  Authorization: Bearer sck_<key_id>_<secret>

A client that can only start local servers can run the bridge instead, as for Claude Desktop. To check a key by hand, ask for the tool list:

curl -s https://www.seecrime.com/mcp \
  -H "Authorization: Bearer $SEECRIME_API_KEY" \
  -H "Content-Type: application/json" \
  -H "MCP-Protocol-Version: 2025-11-25" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Incident fields

Everything at the top level has the same meaning in every city. Anything whose meaning varies by agency is quarantined inside incident_source_fields.

City codes

41 cities27 also publish 311

“Rows per incident: many” means the agency files one record per offense, so several rows can share an incident_code. Count record_id for offenses; group by incident_code for incidents.

“311: yes” means /service-requests and /service-request-types work for that code. The same fact is on every /cities entry as has_311_data — read it from there rather than copying this column.

Offense catalog

Pagination

Cursor-based, newest first. Follow meta.next_cursor until meta.has_more is false:

cursor = None
while True:
    q = {"city": "CHI", "start": "2026-01-01", "end": "2026-06-30", "limit": 1000}
    if cursor: q["cursor"] = cursor
    r = requests.get(BASE + "/incidents", params=q, headers=H, timeout=30).json()
    yield from r["incidents"]
    if not r["meta"]["has_more"]:
        break
    cursor = r["meta"]["next_cursor"]

• Page 10,000 costs the same as page 1. There is no offset and no page number; the cursor is a keyset position, so we never re-scan what you have already read. That is also why there is no maximum date range for records — walk a decade if you need it. The exception is one_per_incident=true in a city that publishes one record per offense: choosing one record per incident runs over the whole range on every page, so that range is capped at 731 days.
• Treat the cursor as opaque. Its contents are an implementation detail and may change within v1.
• We do not return a total count. Counting exactly would mean a full scan per request; has_more answers the question that actually drives a loop.
• Cursors are stable against a fixed dataset. Ingest runs once a day, so a very long paging run that straddles it may see a row shift; restart the window if you need a perfectly consistent snapshot. See how current the data is.

Caching

• Every response carries an ETag. Send it back as If-None-Match and an unchanged window answers 304 Not Modified with no body — the cheapest way to poll.
• Cache-Control: private, max-age=60 on /incidents and /service-requests; 3600 on /cities; 86400 on /offenses. The remaining endpoints set their own — read the header rather than assuming one of these.
• private on every response, always: it is served against your credential, so it must never land in a shared cache.

How current the data is

Our ingest sweep starts at 09:00 UTC and works through the cities one at a time. That is a start time, not an instant: the sweep is bounded by a wall-clock budget and rotates where it left off, so a large city can land several hours later, or roll over to the following day's run. Polling more often than hourly will not surface anything new.

Rate limits

Three limits apply to every request, on different axes. You need to know about all three, because the one that stops you is not always the one you sized for.

The per-key limit runs in a fixed 60-second window, and every response tells you where you stand against it:

X-RateLimit-Limit: 120
X-RateLimit-Remaining: 118
X-RateLimit-Reset: 1786000260   # unix seconds

Exceeding it returns 429 rate_limit_exceeded with Retry-After. Honour it — retry with exponential backoff rather than a tight loop.

Two consequences of the per-IP limit

• Keys behind one egress address share it. If several of your services call us through the same NAT gateway or egress IP, their requests count together against 600/minute regardless of how many separate keys they hold. Distinct keys give you distinct per-key budgets and separate audit trails; they do not give you distinct IP budgets.
• Raising one key above 600/minute achieves nothing on its own. The per-IP cap is checked first, so a key allowed more than 600/minute will still be refused at 600 from a single address. If you need to go beyond it, tell us what the traffic shape is — the answer is usually spreading the load across sources rather than one very large key.

Errors

Every error is JSON with a stable error code and a human message. Branch on the code, not the message.

{ "error": "unknown_city", "message": "Unknown city code. Valid codes are listed by GET /api/v1/cities (the list_cities MCP tool), e.g. NYC for New York." }

Data caveats

These are properties of the source data, not of the API. They are documented because getting them wrong produces analysis that looks fine and is wrong.

1. Timestamps are local, with no offset. Agencies publish local civil time. We do not stamp a Z on it — that would be wrong by five to eight hours on every row. Localise using city_timezone. 3 cities (Mesa, Phoenix, Tucson) do not observe DST — their IANA zone says so, which is why you should localise from city_timezone rather than from a UTC offset you worked out once.
2. occurred vs reported is not cosmetic. 15 of 41 cities key their feed on when the report was filed. Comparing those to occurred cities day-by-day will mis-date incidents.
3. Coverage windows differ per city. Always read data_earliest / data_latest from /cities instead of assuming a range. Some feeds also lag their source by days or weeks, and at least one is frozen upstream — an empty recent window is usually publication lag, not zero crime. See how current the data is.
4. Some agencies publish administrative records — warrant service, lost property, mental-health transports, found vehicles — in the same dataset as offenses. We classify these as Non-Crime so they are visible rather than silently counted; they exceed 30% of records in a handful of cities. Pass exclude_non_crime=true for crime-only analysis.
5. Some agencies file one row per offense, not one per incident. 21 of the 41 cities do, so several records legitimately share one incident_code — a single arrest with three charges is three records — and counting rows over-counts incidents. Two places tell you which cities: meta.multiple_records_per_incident on every response, and the Rows per incident column in the City codes table. Count record_id for offenses and DISTINCT incident_code for incidents, or let us do it: /incident-counts counts incidents, and one_per_incident=true on /incidents returns one record per incident. Records stay the default, deliberately: both views are legitimate, and collapsing the rows would throw away the individual charges — which for many consumers are the point.
6. null is not zero and not false. A null in incident_arrest means the agency publishes no disposition. Counting nulls as "no arrest" invents a clearance rate — and null is what you will get from all but 1 of the 41 cities. The same applies to incident_domestic and to incident_offense_action.
7. Coordinates are as published. Many agencies deliberately publish block-level or slightly offset points to protect victim privacy. Do not treat a coordinate as a street address, and be careful with very small radii.
8. Some cities' data leaves things out. The source feeds differ in what they cover, and where this is documented the city carries a data_scope_note on /cities, the /incidents and /incident-counts meta, and /risk-score's coverage. A city with no note has no documented limit; that is not a guarantee it is complete. The notes today:
   • AUS Austin: Austin publishes no coordinates for its crime reports, to protect victims' privacy, so each incident is placed near the population center of its Census block group: locations and radius results are approximate. Incidents with no block group, or a block group outside Travis County, are not in this data.
   • BTR Baton Rouge: Baton Rouge Police publish about 16% of their records without a location (measured 2026-08-04); those records are not in this data.
   • LA Los Angeles: Records from LAPD's 2024-2025 NIBRS dataset, which publishes no coordinates, are placed at the center of their LAPD reporting district, so their locations are approximate; records from 2026 on carry the coordinates LAPD publishes.
   • LV Las Vegas: Las Vegas Metropolitan Police cover the City of Las Vegas and most of unincorporated Clark County, including the Strip; Henderson and North Las Vegas have their own police departments and are not in this data.
   • MESA Mesa: Mesa Police publish sensitive offenses without a location, so those incidents are not in this data.
   • MTL Montreal: Montreal police (SPVM) publish six categories only: breaking and entering, mischief, motor vehicle theft, theft from a motor vehicle, robbery, and offenses causing death; every other offense, including assault and sexual offenses, is not in this data. Records published without a location (16.71% of rows, measured 2026-08-25) are not in it either.
   • OTT Ottawa: This feed carries 13 of the Ottawa Police offense categories: property crime, assault, threats and harassment, robbery, arson and homicide. Fraud, sexual violations, other violations involving violence, offensive weapons, other Criminal Code offenses and five smaller families of offenses are not in this data.
   • PHX Phoenix: Phoenix Police's open-data crime dataset has published no incidents after 2025-12-31 (as of 2026-10-08); the gap is in the source, not in seecrime.
   • RAL Raleigh: Raleigh Police published only about 43% of their rows from the two years to 2026-08-04 with a location; the rest, which include all of their non-offense "Miscellaneous" records, are not in this data.
   • SAC Sacramento: Sacramento Police publish confidential and non-criminal report types without a location (about 46% of rows, measured 2026-08-04), so those records are not in this data.
   • SAN San Diego: San Diego Police leave sensitive incident types out of this dataset: domestic violence, child abuse, suicide, sex crimes and stalking.
   • TOR Toronto: This feed carries only Toronto Police major crime categories: assault, auto theft, break and enter, robbery and theft over (theft over $5,000) in every year, plus, from 2026 on, sexual violation, bike theft, shooting, homicide and theft from motor vehicle, which TPS otherwise publishes as separate datasets that are not ingested here. No other offense is in this data.
   • TPA Tampa: Tampa Police publish only crimes against persons and against property; crimes against society, such as drug and weapons offenses, are not in this data.
   • TUS Tucson: As of 2026-10-08, this data holds only a small fraction of the Tucson incidents reported between 2026-01-01 and about 2026-06-14: Tucson Police had not published that period, so those months are far from complete.
9. Offense counts are not crime rates. Recording practices, classification and what each agency chooses to publish all differ. incident_offense and incident_offense_severity exist to make cross-city comparison possible; they do not make it automatic.
10. Canadian cities report under Canadian UCR, not FBI/NIBRS. Montreal, Ottawa, Toronto publish under the Canadian Uniform Crime Reporting survey — a different coding system from the FBI's. incident_offense and incident_offense_code are our canonical classification, derived the same way for every city, so they stay comparable across the border. But a Canadian city's incident_source_original_code (TOR) is a raw Canadian UCR code and is not comparable to a US city's raw code. Group and compare on incident_offense; never on raw incident_source_original_code across countries.