---
title: "Connect StreetLight Data to Claude: Manage SATC Metrics & Analyses"
slug: connect-streetlight-data-to-claude-manage-satc-metrics-analyses
date: 2026-07-16
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect StreetLight Data to Claude using Truto's MCP server. Automate SATC metrics, spatial queries, and complex mobility analysis pipelines."
tldr: "Connect StreetLight Data to Claude via Truto's MCP server to automate mobility analytics. This guide covers server creation, Claude configuration, hero tools, and real-world GIS workflows."
canonical: https://truto.one/blog/connect-streetlight-data-to-claude-manage-satc-metrics-analyses/
---

# Connect StreetLight Data to Claude: Manage SATC Metrics & Analyses


If you need to connect StreetLight Data to Claude to automate mobility analytics, traffic impact studies, or geospatial data extraction, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and StreetLight Data's complex REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on [connecting StreetLight Data to ChatGPT](https://truto.one/connect-streetlight-data-to-chatgpt-analyze-mobility-zone-sets/) or explore our broader architectural overview on [connecting StreetLight Data to AI Agents](https://truto.one/connect-streetlight-data-to-ai-agents-automate-gis-traffic-data/).

Giving a Large Language Model (LLM) read and write access to a sprawling geospatial ecosystem like StreetLight InSight is an engineering challenge. You have to map massive JSON schemas to MCP tool definitions, handle asynchronous analysis execution pipelines, and deal with strict segment quotas. Every time StreetLight updates an endpoint or changes a required parameter, you have to update your server code, redeploy, and test the integration. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for StreetLight Data, connect it natively to Claude, and execute complex GIS workflows using natural language.

## The Engineering Reality of the StreetLight Data API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against StreetLight's API is painful. You are not just integrating a standard CRUD database - you are orchestrating heavy geospatial workflows.

If you decide to build a custom MCP server for StreetLight Data, you own the entire API lifecycle. Here are the specific challenges you will face:

**Asynchronous Analysis Pipelines**
StreetLight Data is not always a real-time lookup API. For many core metrics, you must define an analysis, submit it to the queue, poll for its completion status, and eventually download a ZIP or CSV payload containing the results. If you expose this directly to Claude without normalization, the model will struggle to handle the wait times or will hallucinate polling logic. Your MCP server needs to cleanly expose these distinct lifecycle phases so the LLM knows to wait, check status, and then retrieve the file.

**Massive Geospatial Payloads**
StreetLight relies heavily on exact spatial definitions. You must pass complex arrays of OpenStreetMap (OSM) IDs or GeoJSON LineStrings to define zones and corridors. LLMs are notoriously bad at generating exact coordinates from scratch. Your tools must be structured to allow the LLM to search for geometries first, store them in context, and pass them exactly as retrieved into the analysis creation endpoints.

**Strict Quotas and Hard Rate Limits**
StreetLight enforces strict quotas, particularly around Streetlight Advanced Traffic Counts (SATC) segments. Unoptimized queries drain quotas rapidly. Furthermore, StreetLight enforces API rate limits to maintain platform stability. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream StreetLight Data API returns an HTTP 429 Too Many Requests, Truto passes that exact error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your agent orchestration layer or the LLM client itself is completely responsible for handling the retry and backoff logic based on these headers.

## How to Generate a StreetLight Data MCP Server with Truto

Truto dynamically generates MCP tools based on the actual resources and documentation available in your integrated StreetLight Data account. You can create a secure MCP server URL in two ways: via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI

This is the fastest path for teams prototyping workflows or building internal AI assistants.

1. Log into your Truto dashboard and navigate to the integrated account page for your StreetLight Data connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., restrict access to specific tags, allow only `read` operations, or set an expiration date).
5. Copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3...`).

### Method 2: Via the Truto API

For production deployments where you need to provision MCP servers dynamically for your end-users, use the REST API.

Make a `POST` request to `/integrated-account/:id/mcp`. You can pass configuration objects to tightly scope what the LLM is allowed to do.

```bash
curl -X POST "https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp" \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "StreetLight SATC Metrics Server",
    "config": {
      "methods": ["read", "create"],
      "tags": ["satc", "analyses"]
    }
  }'
```

The API validates the configuration, ensures the integration has documented tools available, and returns the ready-to-use URL:

```json
{
  "id": "mcp_abc123",
  "name": "StreetLight SATC Metrics Server",
  "config": { "methods": ["read", "create"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Connecting the MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero additional code. You can connect it directly via application UI settings or via a local configuration file.

### Method A: Via the Application UI

If you are using Claude's web or desktop application (or similar interfaces like ChatGPT Developer Mode), you can paste the URL directly into the settings.

**For Claude:**
1. Open Claude Settings.
2. Navigate to **Integrations** -> **Add MCP Server** (or Custom Connectors depending on your plan).
3. Paste the Truto MCP URL and click **Add**.

**For ChatGPT (Developer Mode):**
1. Go to **Settings** -> **Apps** -> **Advanced settings**.
2. Enable **Developer mode**.
3. Under **MCP servers / Custom connectors**, click add, provide a name (e.g., "StreetLight Data"), paste the URL, and save.

### Method B: Via Manual Configuration File

If you are building custom agents, using an IDE like Cursor, or configuring Claude Desktop directly at the filesystem level, you can use the standard MCP Server-Sent Events (SSE) transport configuration.

Add the following JSON to your `claude_desktop_config.json` file:

```json
{
  "mcpServers": {
    "streetlight-data": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_GENERATED_TOKEN"
      ]
    }
  }
}
```

Save the file and restart Claude Desktop. The model will instantly parse the StreetLight Data tool schemas and they will be ready for use.

## StreetLight Data Hero Tools

Truto automatically generates descriptive, heavily-typed tools for Claude based on the StreetLight Data API endpoints. Here are the core "hero" tools you will use to automate mobility analytics.

### create_a_street_light_data_analysis

This tool allows Claude to instantiate and queue a new mobility analysis in StreetLight InSight. It requires specific parameters like the `insight_login_email`, `analysis_type`, `travel_mode_type`, and the zone sets to analyze. It returns the analysis UUID which is critical for downstream tracking.

> "I need to run a new Origin-Destination analysis for commercial trucks entering the Port zone set. Set it up under my email and give me the analysis UUID so we can track it."

### list_all_street_light_data_analyses

Claude uses this tool to check the status of one or more queued analyses or search historical analyses. Because StreetLight processes data asynchronously, Claude will often call this tool in a polling loop to see if an analysis status has changed from 'Processing' to 'Complete'.

> "Check the status of analysis UUID 12345-abcde. Let me know if the metrics are ready to download yet, or if it is still in the queue."

### list_all_street_light_data_analysis_metrics_by_uuid

Once an analysis is complete, Claude uses this tool to extract the actual data. It downloads the metrics file for a specific UUID. Depending on the metric requested, the tool handles retrieving the CSV or ZIP payload and mapping the metric-specific columns back to the LLM context.

> "The corridor study analysis is complete. Download the volume metrics by UUID and summarize the peak hour traffic volumes for the primary segment."

### list_all_street_light_data_satc_metrics

This tool retrieves Streetlight Advanced Traffic Counts (SATC) for segments within a specific geometry. It is a direct lookup (bypassing the asynchronous analysis queue) but it consumes your segment quotas. Claude must pass valid geometry, country, mode, day part, and direction variables.

> "Pull the SATC metrics for yesterday. I need the average daily traffic counts for personal vehicles traveling northbound along the Main Street geometry we defined."

### street_light_data_osm_ids_search

To build zone sets or query SATC metrics, you need precise OpenStreetMap (OSM) segments. This tool allows Claude to search for OSM segments based on a geometry boundary, returning road classifications and segment counts.

> "Search for all highway-classified OSM IDs within this specific GeoJSON bounding box so we can group them into a new zone set."

### create_a_street_light_data_zone_set

Claude uses this tool to logically group geographic areas (zones) or OSM segments into a named Zone Set within StreetLight InSight. This is a prerequisite step before launching complex regional analyses.

> "Take the 15 OSM IDs we just found for the downtown grid and create a new StreetLight Zone Set named 'Downtown Commercial Grid'."

To see the complete inventory of available tools, required schemas, and configuration options, visit the [StreetLight Data integration page](https://truto.one/integrations/detail/streetlightdata).

## Workflows in Action

Connecting Claude to StreetLight Data allows you to move from rigid dashboard clicks to dynamic, conversational GIS workflows. Here is how Claude orchestrates multiple tools to complete complex tasks.

### Workflow 1: End-to-End Corridor Impact Study

When a transportation planner needs to understand the impact of a new development, they typically have to manually define zones, configure an analysis, wait hours, and parse massive CSV exports. Claude can handle the orchestration entirely.

> "I need an origin-destination study for the new stadium site. Search for the OSM IDs matching the site's GeoJSON boundary, create a zone set called 'Stadium Core', and launch a new Origin-Destination analysis for all vehicle types. Check the status and summarize the results when it's done."

1. Claude calls `street_light_data_osm_ids_search` using the provided GeoJSON to retrieve the exact segment IDs.
2. Claude calls `create_a_street_light_data_zone_set` passing the OSM IDs to define "Stadium Core".
3. Claude calls `create_a_street_light_data_analysis` using the new zone set ID, selecting the "Origin-Destination" `analysis_type`.
4. Claude calls `list_all_street_light_data_analyses` repeatedly to check the status.
5. Once complete, Claude calls `list_all_street_light_data_analysis_metrics_by_uuid` to retrieve the CSV data and outputs a natural language summary to the user.

```mermaid
sequenceDiagram
    participant User
    participant Claude as "Claude Desktop"
    participant Truto as "Truto MCP Server"
    participant StreetLight as "StreetLight API"
    User->>Claude: Run study for Stadium site
    Claude->>Truto: street_light_data_osm_ids_search
    Truto->>StreetLight: POST /osm_segments
    StreetLight-->>Truto: OSM IDs
    Truto-->>Claude: OSM IDs
    Claude->>Truto: create_a_street_light_data_zone_set
    Truto->>StreetLight: POST /zone_sets
    StreetLight-->>Truto: Zone Set ID
    Truto-->>Claude: Zone Set ID
    Claude->>Truto: create_a_street_light_data_analysis
    Truto->>StreetLight: POST /analyses
    StreetLight-->>Truto: Analysis UUID (Queued)
    Truto-->>Claude: Analysis UUID
    loop Polling
        Claude->>Truto: list_all_street_light_data_analyses
        Truto->>StreetLight: GET /analyses
        StreetLight-->>Truto: status: Complete
        Truto-->>Claude: status: Complete
    end
    Claude->>Truto: list_all_street_light_data_analysis_metrics_by_uuid
    Truto->>StreetLight: GET /metrics
    StreetLight-->>Truto: CSV Payload
    Truto-->>Claude: Parsed content
    Claude-->>User: Traffic summary report
```

### Workflow 2: Daily SATC Quota-Aware Monitoring

If you are tracking daily traffic volumes on a specific corridor, you can bypass the analysis queue and hit the SATC endpoints directly - but you must be careful with segment quotas.

> "Check the SATC metrics for our 5 primary highway segments for yesterday. Pull the average daily traffic for commercial vehicles. Before you pull the metrics, run a segment count to ensure we don't blow past our daily quota."

1. Claude calls `list_all_street_light_data_satc_segment_counts` to verify how many segments the query will consume against the contract quota.
2. After validating the count is safe, Claude calls `list_all_street_light_data_satc_metrics` with the specific geometry, `country`, `mode` (commercial), and `date`.
3. Claude parses the returned array of metric rows and generates a brief executive summary of traffic changes.

## Security and Access Control

Giving an AI agent access to enterprise mobility data requires strict governance. Truto's MCP servers are designed with security primitives that keep you in control of what the model can execute.

*   **Method Filtering:** You can restrict a generated MCP server to only allow specific operations. Setting `methods: ["read"]` ensures the LLM can search for OSM IDs and list metrics, but cannot accidentally create or delete expensive analyses.
*   **Tag Filtering:** You can scope the MCP server to only expose specific API domains. Setting `tags: ["satc"]` ensures the LLM only sees tools related to Streetlight Advanced Traffic Counts, hiding the broader InSight analysis tools entirely.
*   **Require API Token Auth:** By default, anyone with the MCP URL can interact with the server. Setting `require_api_token_auth: true` forces the client to pass a valid Truto API token in the `Authorization` header, ensuring only authenticated internal tools can utilize the agent.
*   **Expiration (`expires_at`):** You can assign a time-to-live to the MCP server. If you are granting temporary access for a specific urban planning sprint, the server will automatically self-destruct at the designated ISO datetime, cleaning up all downstream KV storage and database entries automatically.

Building a custom integration layer that translates an LLM's natural language intent into complex StreetLight Data geospatial payloads and asynchronous polling loops requires significant engineering overhead. By utilizing Truto, you bypass the boilerplate of OAuth tokens, rate limit normalizations, and schema generation, giving your AI agents immediate, secure access to the industry's most powerful mobility data platform.

> Want to give your AI agents secure, managed access to StreetLight Data without building custom integrations? Let's talk about how Truto can power your autonomous workflows.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)