Connect Verkada to Claude: Orchestrate Site Access & Entry Control

If you need to connect Verkada to Claude to automate facility access, review license plate recognition (LPR) data, or investigate security footage, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Verkada's 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 Verkada to ChatGPT or explore our broader architectural overview on connecting Verkada to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling physical security ecosystem like Verkada is a severe engineering challenge. You have to handle API token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Verkada's specific media retrieval constraints. Every time Verkada updates an endpoint, 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 Verkada, connect it natively to Claude Desktop, and execute complex security workflows using natural language.

The Engineering Reality of the Verkada 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 Verkada's APIs is painful. You are not just integrating a standard CRUD application - you are interacting with physical hardware, streaming video protocols, and massive event streams.

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

Asynchronous Helix Batch Processing Verkada's Helix API allows you to inject third-party data (like POS transactions or external alerts) into the Command platform. However, bulk operations (verkada_helix_events_bulk_create) are processed asynchronously. The API returns a 202 Accepted status, not a completion confirmation. If you expose this raw endpoint to an LLM, the model will assume the data is immediately available and hallucinate follow-up queries. Your MCP server must either wrap this in a polling mechanism or explicitly provide the LLM with a separate get_single_verkada_batch_job_by_id tool and prompt instructions on how to wait for processing.

Ephemeral Media URLs and Binary Blobs Handling camera feeds and thumbnails is completely different from parsing text JSON. The verkada_footage_get_link endpoint returns an HLS stream or expiring URL that dies after 30 days. Live streaming requires fetching specific JWT tokens. Meanwhile, thumbnail endpoints return raw JPEG binary data. LLMs operating over JSON-RPC cannot natively ingest raw binary streams via standard text tool calls. Your MCP layer must intercept these binary responses and either upload them to an intermediary storage bucket or convert them into base64 encoded strings formatted for Claude's vision capabilities.

Strict API Quotas and Rate Limit Passthrough Verkada imposes strict API quotas that can easily be exceeded when an AI agent runs loops, recursive searches, or wide-net LPR queries. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the Verkada API returns an HTTP 429 Too Many Requests error, Truto immediately passes that error back to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) following the IETF specification. The caller - whether that is your application middleware or Claude's internal tool execution loop - is strictly responsible for implementing its own retry and backoff logic.

How to Create a Managed MCP Server for Verkada

Instead of building a custom Node.js or Python server to handle these quirks, you can use Truto to dynamically generate a managed MCP server. This server translates Claude's JSON-RPC 2.0 requests into Verkada API calls, handles pagination, and enforces security filters.

You can generate this server in two ways.

Method 1: Via the Truto UI

For administrators setting up internal tools, the UI provides a fast path to a running server:

1. Log into your Truto dashboard and connect your Verkada account via the Integrations page.
2. Navigate to the Integrated Accounts section and select your Verkada connection.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Configure the server. You can optionally restrict it to specific methods (e.g., read only) or specific tags (e.g., doors, lpr).
6. Copy the generated MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For engineering teams building multi-tenant AI products, you can generate MCP servers programmatically. Make a POST request to the /integrated-account/:id/mcp endpoint with your desired configuration.

curl -X POST https://api.truto.one/admin/integrated-accounts/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Verkada Security Agent",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API evaluates the Verkada integration's documentation, confirms tools are available, and returns a secure, hashed token URL.

{
  "id": "mcp-123",
  "name": "Verkada Security Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the Verkada MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude. The process depends on whether you are using Claude for Enterprise/Web or Claude Desktop.

Method A: Via the Claude UI (Web/Enterprise)

If you are using Claude's web interface or organizational settings:

1. In Claude, go to Settings → Integrations → Add MCP Server.
2. Enter a descriptive name like "Verkada Command".
3. Paste the Truto MCP URL you generated.
4. Click Add.

Claude will immediately call the /initialize endpoint, discover the Verkada tools, and make them available in your conversational workspace.

Method B: Via Claude Desktop Configuration File

For developers using the Claude Desktop app, you can connect the server manually by editing the claude_desktop_config.json file. Truto provides an SSE (Server-Sent Events) transport package specifically for this.

Edit your configuration file (located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "verkada": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The "plug" icon will appear, indicating the Verkada tools are loaded and ready for use.

Security and Access Control

Giving an AI agent access to physical door controls and live camera feeds requires strict governance. Truto's MCP architecture provides four layers of security to limit the blast radius of LLM actions:

• Method Filtering: You can restrict a server to only allow read operations (like list and get), explicitly preventing the AI from unlocking doors or updating users. Define this in the config.methods array during creation.
• Tag Filtering: Limit the server to specific functional domains. By passing config.tags: ["lpr", "cameras"], the resulting server will not expose any access control or door tools, physically walling off those APIs from the agent.
• API Token Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, the MCP client must also pass a valid Truto API token in the Authorization header, adding a required secondary authentication factor.
• Automatic Expiration (expires_at): You can generate time-boxed servers for temporary investigations or contractor access. The token is automatically purged from distributed storage exactly at the expiration time via edge-scheduled alarms.

Hero Tools for Verkada

When Claude connects to the Verkada MCP server, it parses the integration's schemas and exposes them as callable functions. Here are the highest-leverage tools available for security operations.

Admin Unlock Doors

Bypasses normal access schedules to immediately unlock a specified door. This is critical for emergency orchestration where an agent needs to clear a path during an evacuation or incident.

"There is a medical emergency in the lobby. Immediately unlock the main lobby doors (door_id: d-12345)."

List All Access Events

Retrieves access control events across your organization. It supports filtering by event type, site, device, or user, making it the primary tool for auditing who entered a facility and when.

"Pull the access events for the West Wing server room for the last 2 hours. Who swiped their badge?"

Get Footage Link

Generates an expiring URL to view Verkada camera footage. If a timestamp is provided, it returns historical footage; otherwise, it provides a live link. This bridges the gap between text-based event logs and visual verification.

"Get a historical footage link for the loading dock camera (camera_id: c-987) at exactly 14:00 yesterday."

List All LPR Images

Queries a specific License Plate Recognition camera to retrieve detected plates, timestamps, and confidence scores. This tool is essential for investigating unauthorized vehicles on site.

"Check the South Gate LPR camera (camera_id: c-lpr-1). Give me a list of all license plates detected in the last hour."

Set Entry Code

Sets or updates a keypad PIN for a specific access user. This is highly useful for automating temporary access provisioning without requiring a physical badge.

"Set a new 6-digit entry code for John Doe (user_id: u-456). Use 847291."

Bulk Create Helix Events

Injects third-party telemetry into Verkada Command. This tool allows the AI agent to take data from external systems (like a point-of-sale refund or a cybersecurity alert) and overlay it onto Verkada camera footage asynchronously.

"Take these 5 high-value POS refunds and create Helix events for them against the register camera (camera_id: c-register-1)."

To view the complete inventory of Verkada tools, endpoints, and schema definitions, visit the Verkada integration page.

Workflows in Action

Once connected, Claude can orchestrate complex, multi-step operations that span physical access logs, camera feeds, and LPR data. The agent autonomously determines which tools to call and in what order based on your prompt.

Scenario 1: Tailgating Investigation

When an unauthorized entry is suspected, security teams usually have to pivot between access logs and video feeds manually. Claude handles this correlation autonomously.

"We suspect someone tailgated into the IT server room around 9:15 AM today. Check the access events to see who badged in, and then get me a footage link for the server room camera exactly 30 seconds after that badge swipe so I can verify who actually walked through."

1. list_all_verkada_access_events: Claude queries the access logs for the server room door filtering around the 9:15 AM timestamp. It identifies that "Alice Smith" successfully badged in at 9:14:45 AM.
2. verkada_footage_get_link: Claude calculates the target time (9:15:15 AM), converts it to a Unix timestamp, and calls this tool targeting the server room camera.
3. Synthesis: Claude returns the name of the employee whose badge was used, alongside a direct URL to the video footage spanning the entry event, allowing human security staff to visually confirm if a second person caught the door.

sequenceDiagram
    participant User as Security Admin
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Verkada as Verkada API

    User->>Claude: "Investigate tailgating at 9:15 AM..."
    Claude->>MCP: Call list_all_verkada_access_events (time range: 9:10 - 9:20)
    MCP->>Verkada: GET /access/events
    Verkada-->>MCP: Returns Alice Smith badge event at 9:14:45
    MCP-->>Claude: JSON event data
    Claude->>MCP: Call verkada_footage_get_link (timestamp: 9:15:15)
    MCP->>Verkada: POST /cameras/footage/link
    Verkada-->>MCP: Returns expiring video URL
    MCP-->>Claude: JSON containing URL
    Claude-->>User: "Alice badged in at 9:14:45. Here is the video link to check for tailgaters: https://..."

Scenario 2: Suspicious Vehicle Correlation

If a facility manager reports a suspicious vehicle, an agent can check LPR cameras and proactively lock down adjacent doors.

"There's a report of a suspicious black truck near the warehouse. Check the warehouse LPR camera for any plates captured in the last 20 minutes. If you find any, automatically create a Helix event flagging that plate on the main lot camera, and then ensure the warehouse loading dock doors are securely locked."

1. list_all_verkada_lpr_images: Claude queries the warehouse LPR camera for recent detections, extracting a list of plates and their confidence scores.
2. verkada_helix_events_bulk_create: Claude takes the identified plate string and constructs a Helix event, pushing it to the main lot camera to create a searchable video overlay for that vehicle in Verkada Command.
3. list_all_verkada_doors: Claude searches the directory for the "warehouse loading dock" door ID.
4. verkada_doors_admin_unlock: (If prompt logic dictated a lock state check, Claude would interact with door APIs to confirm or override states based on the available tools and permissions).
5. Synthesis: The user receives a summary of the license plate found, confirmation that the Helix event was queued for processing, and the final status of the warehouse doors.

flowchart TD
    A["User Prompt:<br>Investigate truck & lock doors"] --> B["list_all_verkada_lpr_images<br>(Warehouse LPR)"]
    B --> C{"Plate Found?"}
    C -->|Yes| D["verkada_helix_events_bulk_create<br>(Tag Main Lot Camera)"]
    C -->|No| E["Report no plates found"]
    D --> F["list_all_verkada_doors<br>(Find Loading Dock)"]
    F --> G["Interact with Door APIs<br>(Ensure secure state)"]
    G --> H["Return summary to user"]

Wrap-Up

Connecting Verkada to Claude using a managed MCP server transforms a static physical security dashboard into an autonomous orchestration engine. Instead of manually correlating badge swipes with video timestamps or writing custom scripts to handle LPR polling, your security and IT teams can investigate incidents and provision access using natural language.

By leveraging Truto's dynamic MCP server generation, you avoid the pain of building OAuth flows, writing JSON-RPC translation layers, and parsing binary image blobs from scratch. You retain total control over what the LLM can touch via strict method and tag filtering, ensuring your physical infrastructure remains secure.