
.osano-cm-window__widget {
  display:none;
}
.hsfc-Form .hsfc-RichText p:is(.dark *), .hsfc-Form .hsfc-FieldLabel span:is(.dark *), .hsfc-PostSubmit .hsfc-RichText p:is(.dark *){
  color:#a0a1a2;
}
.dark\:text-primary-light:is(.dark *) {
  color: #378ff0;
}
.hsfc-FormWrapper .hsfc-Step .hsfc-Step__Content {
  padding:0 10px 20px 10px;
  background-color: rgb(113 113 122 / 10%);
  border-radius: 10px;

}
.hsfc-FormWrapper .hsfc-Step .hsfc-Step__Content .hsfc-Row {
  margin-bottom:4px;
}
.hsfc-FormWrapper .hsfc-Step .hsfc-Step__Content .hsfc-NavigationRow{
  margin-top:4px;
}

#!/usr/bin/env node

const fs = require('fs');
const path = require('path');

// Load and parse JSON file
function loadJson(filePath) {
  const raw = fs.readFileSync(filePath, 'utf8');
  return JSON.parse(raw);
}

// Filter out deprecated/default and by record type
function filterRecords(records, type) {
  return records.filter(r =>
    r.type === type &&
    !r.isDeprecated &&
    !r.isDefault
  );
}

// Group records by signalGroupId.where.name
function groupBySignalGroup(records) {
  const groups = {};
  records.forEach(r => {
    const groupName = r._links.signalGroupId.where.name;
    groups[groupName] = groups[groupName] || [];
    groups[groupName].push(r);
  });
  return groups;
}

// Write one MDX file for the given groups
function writeMdx(groups, outputFile) {
  const lines = [];
  Object.keys(groups).sort().forEach(group => {
    lines.push(`<Accordion title="${group}">`);
    lines.push(`| Signal | Type | Description | Example |`);
    lines.push(`| ------ | ---- | ----------- | ------- |`);
    groups[group]
      .sort((a, b) => {
        const nameA = (a.displayName || a.name).toLowerCase();
        const nameB = (b.displayName || b.name).toLowerCase();
        return nameA.localeCompare(nameB);
      })
      .forEach(r => {
        const displayName = r.displayName || r.name;
        const dataType    = r.dataType || '';
        const desc        = (r.description || '').replace(/\r?\n/g, ' ');
        const rawExample = r.example != null ? r.example : '';
        let exampleCell = '';
        const trimmed = rawExample.trim();
        if (!(trimmed.startsWith('{') || trimmed.startsWith('['))) {
          exampleCell = rawExample.replace(/\r?\n/g, ' ');
        }
        lines.push(`| ${displayName} | ${dataType} | ${desc} | ${exampleCell} |`);
      });
    lines.push(`</Accordion>`);
    lines.push('');  // blank line between accordions
  });

  const dir = path.dirname(outputFile);
  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
  fs.writeFileSync(outputFile, lines.join('\n'), 'utf8');
}

// Main entrypoint
function main() {
  const inputFile = path.resolve(__dirname, 'Signal.json');
  const data = loadJson(inputFile);
  const records = data.records || [];

  const signals = filterRecords(records, 'signal');
  const attrs   = filterRecords(records, 'attribute');

  const signalGroups = groupBySignalGroup(signals);
  const attrGroups   = groupBySignalGroup(attrs);

  writeMdx(signalGroups, path.resolve(__dirname, 'snippets/signals.mdx'));
  writeMdx(attrGroups,   path.resolve(__dirname, 'snippets/attributes.mdx'));

  console.log('✅ MDX files generated in /snippets/');
}

main();

Our SDKs make integrating Smartcar fast and easy in different languages and frameworks.

SDKs

SDKs for Connect

smartcar

Learn about how to build applications that connect to millions of vehicles around the world.

Introduction

Introduction to Smartcar's API

Plan Your Integration

Test Your Integration

In this guide we'll go over how to use Vehicle Simulator to test out Smartcar using Postman.

Testing with Postman

In this tutorial, we will use the iOS SDK to integrate Connect into your application.

iOS Tutorial

In this tutorial, we will use the Android SDK to integrate Connect into your application.

Android

Android Tutorial

In this tutorial, we will use the JavaScript SDK to integrate Connect into your application.

React

React Tutorial

In this tutorial, we will go over how  to integrate Connect into your application and make requests to a vehicle using our backend SDKs.

Backend SDKs

Backend SDK Tutorials

A comprehensive breakout of all Smartcar errors.

Overview

By launching Connect in [simulated mode](/docs/connect/advanced-config/modes), you're able to test your application against certain errors.

Testing Errors

All you need to know about the Smartcar Dashboard

Dashboard Overview

Configuration

Dashboard Configurations

Dashboard MFA

Dashboard Multi-Factor Authentication (MFA)

Playground

Connect Playground

Simulator

Vehicle Simulator

Connect Insights allows you to visualize your Connect conversion rate and identify where individual users are running into issues during onboarding.

Connect Insights

Your Smartcar Team is the central hub for managing your applications, vehicles, members, security settings, and billing information.

Team Settings

Smartcar offers SSO through your identity provider (IdP) for Enterprise customers.

Single Sign-on (SSO)

This guide explains how to use the Smartcar API to enhance charging station discoverability by leveraging vehicle data such as state of charge,  battery level, range, and location. These capabilities allow developers to help EV drivers find nearby charging stations based on real-time vehicle data.

Charging station utilization

This guide outlines how charge point operators can utilize the Smartcar API to implement plug-and-charge capabilities, enabling automatic billing and session management through vehicle identification and charging data.

Enabling simplified payments

This guide explains how to use the Smartcar API to proactively automate preventive maintenance scheduling. By leveraging data such as odometer readings, engine oil life, Diagnostic Trouble Codes (DTCs), and system status, you can reduce vehicle downtime, improve reliability, and enhance customer satisfaction.

Preventive maintenance scheduling

This guide explains how to use the Smartcar API to provide real-time vehicle diagnostics by leveraging data such as Diagnostic Trouble Codes (DTCs), overall system health, and odometer readings. These capabilities allow developers and service providers to proactively identify issues, schedule service visits, and reduce vehicle downtime.

Drive revenue with real-time diagnostics

What is Connect?

Dashboard Configuration

Build the Connect URL

Upon successfully accepting the permissions, Smartcar will redirect the user back to your application using the specified `REDIRECT_URI`, along with an authorization code as a query parameter. In the case of on error, we'll provide an error and description as parameters instead.

Handle the Response

Auth Code Exchange

After fetching your first token pair, you'll need to manage them in order to maintain access to the vehicle.

Your access token will expire **2 hours** after it is issued. When this happens, your application  can retrieve a new one by using the corresponding `REFRESH_TOKEN`.

Refreshing Access Tokens

Refresh tokens expire after **60 days ordinarily** or **after 1 minute when used to fetch a new token pair**.

Refreshing Refresh Tokens

Redirect to Connect

If the re-auth is successful, the redirect to your application will contain a vehicle ID. In the case of an error, we'll provide an error and description as parameters instead.

To support vehicle commands such as lock/unlock or start/stop charge, Rivian requires a mobile device to be paired via Bluetooth with the vehicle.

Rivian Bluetooth Pairing

To support vehicle commands such as lock/unlock or start/stop charge, and benefit from faster data frequencies, Tesla requires a Virtual Key to be added to the vehicle.

Tesla Virtual Keys

Connect can be launched with three different workflows. Depending on your use case and what information you have about the vehicle ahead of a launching Connect, you may be able to leverage one of these flows for a more streamlined Connect experience.

Connect Flows

Modes

By default Connect will launch based on the devices location impacting the brands that are available to the user e.g. Renault is only available in Europe.

Country Selection

Smartcar API Reference

Headers

Makes

In order to use an endpoint or webhook, you'll need to request the associated permissions from your user in [Connect](/docs/connect/what-is-connect).

Permissions

Errors

API Errors

Compatibility will vary by model, year, and trim. This API is for reference purposes only and it showcases vehicle makes and models that may be compatible with Smartcar and it does not guarantee that a specific vehicle will be compatible.

By VIN

By Region and Make

Returns a paged list of all vehicles that are connected to the application associated with the management API token used, sorted in descending order by connection date.

Vehicle Connections

Deletes all vehicle connections associated with a Smartcar user ID or a specific vehicle.

Returns a paged list of all vehicles connected to the application for the current authorized `user`.

All Vehicles

Returns a list of responses from multiple Smartcar `GET` endpoints, all combined into a single request.

Batch

Returns a list of nominal rated battery capacities for a vehicle.

Battery Capacity

Returns the state of charge and the remaining range of an electric vehicle's high voltage battery.

Battery Level

Returns the charge limit configuration for the vehicle.

Charge Limit

Set the  charge limit of an electric vehicle.

Returns the charge status for the vehicle.

Charge Status

Provides a list of active Diagnostic Trouble Codes (DTCs) reported by the vehicle. Currently supporting GM brands including Chevrolet and GMC.

Diagnostic Trouble Codes

Returns the status of the fuel remaining in the vehicle’s fuel tank.

Fuel Tank

Returns the vehicle's last known location.

Location

Returns the lock status for a vehicle and the open status of its doors, windows, storage units, sunroof and charging port where available.

Lock Status

Lock & Unlock

Returns the vehicle’s last known odometer reading.

Odometer

Returns the remaining life span of a vehicle’s engine oil.

Oil Life

Returns a list of the permissions that have been granted to your application in relation to this vehicle.

Send destination coordinates to the vehicle's navigation system.

Send Destination

Start & Stop Charge

Retrieve service records tracked by the vehicle's dealer or manually added by the vehicle owner. Currently supporting Ford, Lincoln, Toyota, Lexus, Mazda and Volkswagen (US)

Service History

Provides a list of vehicle systems and their current health status. Currently supporting FCA and GM brands including RAM, Jeep, Chrysler, Dodge, Fiat, Alpha Romeo, Buick, Cadillac, Chevrolet and GMC. See [Diagnostic Systems](/docs/help/diagnostic-systems) for a complete list of Smartcar System IDs.

System Status

Returns the air pressure of each of the vehicle’s tires.

Tire Pressure

Returns the ID of the vehicle owner who granted access to your application.

User

Returns a single vehicle object, containing identifying information.

Vehicle Attributes

Returns the vehicle’s manufacturer identifier.

About Make Specific

Make Specific Endpoints

Callback URI Verification

Payload Verification

Subscribe

Unsubscribe

What is Smartcar

What is Smartcar?

What is a connected car

What is a Connected Car?

Frequently Asked Questions

Frequently Asked Questions (FAQs)

Learn about limits you may encounter when using Smartcar.

Smartcar Usage Limits

To support our System Status endpoint, reference the below list of unified systems.

Diagnostic Systems

Understand Smartcar's approach to features in beta.

Beta

Learn about what to expect from Vehicle Simulator and how it compares to Live mode.

The Smartcar Support Center provides helpful resources including a knowledge base, ticket submission form, AI chat assistant, and a ticket center to manage your requests.

Accessing the Smartcar Support Center

Learn how to submit a support ticket through the Smartcar Support Center, including step-by-step instructions and eligibility details based on your plan.

How to Submit a Ticket in the Support Center

As part of our Enterprise Slack support offering, Smartcar includes access on select Enterprise plans to an AI-powered assistant that can help you get answers quickly, submit tickets, and navigate support resources—all without leaving your Slack workspace.

Assist AI features in Slack

Below you can find the connected service name for each brand as well as any specific subscription packages needed to connect to the vehicle via Smartcar.

Subscription Information

Brand Subscription Information

When making requests to vehicles, there is variation in how often data is updated and how many requests it can process in a given period. The tables below indicate the performance for each of Smartcar supported brands in each region.

Reliability and Data Age

OEM Latency

Brand specific quirks to keep in mind while building out your application.

Brand Quirks

Compatible Vehicles

Research Fleet

Join the Research Fleet

Connect your car

With [mySmartcar](https://my.smartcar.com/login), you can see which apps are connected to your vehicle and manage their permissions anytime.

mySmartcar

Submit feature request

Submit a Feature Request

Learn about Smartcar's latest product updates and improvements

Latest

Latest Releases

2024

2024 Releases

2023

2023 Releases

2022

2022 Releases

Scheduled webhooks make it incredibly easy to receive vehicle data on a cadence of your choosing. You can set up a webhook for any Smartcar endpoint that allows you to read data from a vehicle.

Scheduled

Scheduled Webhooks

Dynamic webhooks make it incredibly easy to receive data from a vehicle at the optimal frequency supported by the OEM. Specifically, once a certain condition is met, you will be able to receive data more frequently from the vehicle to stay up-to-date with the state of the vehicle when it matters most to you.

Dynamic (Early Access)

Dynamic Webhooks (Early Access)

Diagnostic webhooks send events whenever a state change occurs within the vehicle's Health Status or a Diagnostic Trouble Code (DTC) is reported

Diagnostic (Early Access)

Diagnostic Webhooks (Early Access)

This error occurs when a user denies your application access to the requested scope of permissions.

Access Denied

This error occurs when a user’s vehicle is compatible but their connected services subscription is inactive because either it has expired or it has never been activated.

Invalid Subscription

This error occurs when the user has encountered an Error page in Connect and has chosen to return to your application.

This error occurs when a vehicle owner has a connected services account, but there are no vehicles associated with the account.

No Vehicles

If there is a server error, the user will return to your application.

Server

This error occurs when a user tries to authorize an incompatible vehicle in Smartcar Connect.

Vehicle Incompatible

This error occurs when a user went to authorize directly with the OEM but exited the flow for some reason.

OEM Login Cancelled

This error occurs when a user leaves the Connect flow after hitting **Back to application** before granting your application access to their vehicle.

Introduction

Launching Connect

Token Management

Reauthentication

Vehicle Owner Actions

Advanced Configuration

SDKs for Connect

android

iOS

Flutter

JavaScript

Java

Node.js

Python

Ruby