DOCSEARCHbyAlgolia
Submit Docs

DIMO Developer Documentation

website·Indexed 33 days ago

https://www.dimo.org/docs

Developer resources for building applications on DIMO's vehicle data infrastructure. Includes guides for the Telemetry, Identity, Attestation, and Fetch APIs, as well as documentation for the Client SDK (DIMO Connect), Server SDK, and DIMO MCP Server.

Tokens
30.9K
Snippets
120
Records
209
Agent score
70%

What's inside DIMO

  1. Overview of the DIMO Developer Ecosystem

    The DIMO platform provides secure access to vehicle and mobility data. Key components include:

    • Developer Console: The main entry point for managing API keys, DIMO Connect configurations, webhooks, and AI agents.
    • Developer License: Required to build on the platform. It provides a unique clientId (starting with 0x) which is publicly viewable via the Identity API.
    • SACD (Service Access Contract Definition): A privacy layer and permissions contract that allows developers to request specific vehicle data and users to grant or deny that access.
    • DIMO Connect: A frontend component (available as a Client SDK or redirect URL) that implements the SACD flow for user authentication and data consent.

  2. Overview of the DIMO Build Developer Platform

    DIMO Build is the developer platform for the DIMO Network. It allows developers to integrate vehicle permission management, query telematic vehicle data for individual cars and fleets, and build stateful, agentic tooling to automate business workflows.

  3. Overview of the Vehicle Triggers API

    The Vehicle Triggers API (commonly known as webhooks) allows DIMO to automatically send real-time data to external systems when specific events occur, eliminating the need for constant API polling. Webhooks are tied to a specific Developer License; if multiple licenses exist under one account, the Developer JWT associated with the specific license must be used for authentication. Webhooks can be configured via the DIMO Developer Console or programmatically via the API.

  4. Overview of the DIMO Telemetry API

    The Telemetry API is the primary entry point for retrieving real-time and historical data from DIMO-connected vehicles. It is implemented using GraphQL with a single endpoint for all queries. To access vehicle data, developers must perform a token exchange transaction to obtain a Vehicle JWT with the necessary permissions.
    POST /query

  5. Evaluate DIMO vs SmartCar for vehicle data needs

    Choose DIMO over SmartCar when you require a free tier for testing, AI-powered features, broader brand support (50+ vs 30+), or a privacy-first architecture where users own their data. DIMO is particularly suited for LATAM markets and advanced data needs like historical trip data and predictive maintenance. Choose SmartCar for simple, US-only use cases (e.g., basic mileage tracking) with fewer than 100 vehicles where a simpler API is preferred over advanced features.

  6. Understand DIMO JWT Authentication flow

    Authentication in DIMO follows a two-step process using JSON Web Tokens (JWT) to separate general API access from sensitive vehicle data access:

    1. Developer JWT: Obtained first to prove identity. It allows general access to DIMO APIs for a longer period but cannot access specific vehicle data.
    2. Vehicle JWT: Obtained via a Token Exchange using the Developer JWT. It grants short-term access to a specific vehicle's data to protect sensitive information.

  7. Query Manufacturer details

    Retrieve information about a registered manufacturer on the DIMO network using the manufacturer query. You can filter by name or tokenId to get the manufacturer's ID, owner, minting date, and a list of associated aftermarket devices.
    {
    manufacturer(by: { name: "Tesla", tokenId: 123 }) {
        id
        tokenId
        name
        owner
        mintedAt
        aftermarketDevices {
            totalCount
            edges {
                node {
                    id
                    tokenId
                }
            }
        }
    }
}

  8. Query Developer License information

    Retrieve details about a developer license using its token ID, including the owner, client ID, and associated redirect URIs.
    query GetDevLicenseByTokenId {
  developerLicense (by: { tokenId: "<dev_license_token_id>" } ) {
    owner
    tokenId
    alias
    clientId
    mintedAt
    redirectURIs (first: 10) {
      nodes {
        uri
        enabledAt
      }
    }
  }
}

  9. Use the DIMO Platform Skill for AI coding agents

    The DIMO Platform Skill is a knowledge pack designed for AI coding agents (such as Claude Code or Cursor). It provides the agent with verified ground truth regarding DIMO's system architecture, API surfaces, SACD permission models, contract addresses, and SDK method signatures to prevent the LLM from hallucinating endpoints or schemas.

    For maximum effectiveness, pair the skill (which provides design-time knowledge) with the DIMO MCP Server (which provides runtime tools for querying data, decoding VINs, or minting vehicles).

    # 1. Install the skill from github.com/DIMO-Network/dimo-platform-skill
# 2. Connect the DIMO MCP Server for live tool access

  10. Understand CloudEventTypeSummary fields

    The CloudEventTypeSummary object provides aggregated statistics about events of a specific type stored for a subject. It contains the following fields:

    • type (String!): The cloud event type string (e.g., "dimo.status", "dimo.document.vehicle.insurance").
    • count (Int!): The total number of events of this type stored for the subject.
    • firstSeen (Time!): Timestamp of the earliest event of this type.
    • lastSeen (Time!): Timestamp of the most recent event of this type.

  11. Retrieve raw cloud data using the Fetch API

    The Fetch API allows developers to retrieve raw data objects and index keys from cloud storage, formatted as CloudEvents. It uses a GraphQL interface with a single endpoint /query. Data is retrieved using a did (Decentralized Identifier), such as a vehicle DID (e.g., did:erc721:1:0xContractAddress:tokenId). To use this API, you must obtain a JWT via token exchange with 'raw data' permissions for the target entity.
    POST /query