ECU observation API

ECU identification and file analysis API

The Remapdb ECU observation API analyzes raw ECU binaries and returns structured reports. Identify the ECU, inspect file condition, explore candidate maps and raw grids, or compare two files through background jobs.

Included with active API and Max plans.

Input
Raw binary files
File size
Up to 8 MiB each
Processing
Background jobs

Explore it yourself

ECU observation API playground

Try an example or enter your own details. See the API’s results, explore the full JSON, and use the request in your integration.

Explore an ECU file

Live API

Upload a binary to inspect ECU identity, axis checks, blank regions, checksum coverage and flash layout. Browse all map candidates or add a second file to compare changes.

Raw binary, up to 8 MiB. Sent to Remapdb when you run the analysis.

API possibilities

Put file observations where your team works

Build ECU identification, inspection and comparison into your own product. Your application controls the upload flow, review process and presentation of each report.

File-service intake

Identify an uploaded ECU file and attach available hardware or software numbers to the request before your team reviews it.

Internal review tools

Bring file-condition findings, supported checksum checks and identification confidence together in your team's review screen.

Binary comparison views

Show how two supplied files differ, with exact byte counts and candidate-map changes in one comparison view.

Map exploration tools

List candidate tables, then request raw values for a selected map to display as a grid, heatmap or surface in your interface.

Endpoint guide

The requests behind your integration

See what each endpoint does and where it fits in your product. Authenticate on your server with Authorization: Bearer <API_KEY>. Replace placeholder IDs with the values returned by your requests.

Check available operations

Read the supported operations and current file-size, entry and grid limits, plus retention periods. Use this endpoint to check service access before submitting files.

Example: Check service availability before enabling uploads in your application.

Endpoint
GET https://api.remapdb.com/v2/ecu/capabilities

Upload an ECU binary

Send one raw binary in the multipart file field. The response returns an account-owned file ID, checksum, size and expiry for later operations.

Example: Upload ecu.bin and save its returned file_id for an inspection.

Endpoint
POST https://api.remapdb.com/v2/ecu/files
Content-Type: multipart/form-data; boundary=remapdb-example

--remapdb-example
Content-Disposition: form-data; name="file"; filename="ecu.bin"
Content-Type: application/octet-stream

<raw binary bytes>
--remapdb-example--

Identify the ECU

Queue an identity-only report with available ECU and hardware or software identifiers. This endpoint accepts file_id alone and returns a job to follow.

Example: Find the ECU family and supported identifiers without requesting a full inspection.

Endpoint
POST https://api.remapdb.com/v2/ecu/identifications
Content-Type: application/json
Idempotency-Key: <unique-request-identifier>

{
  "file_id": "{file_id}"
}

Inspect a binary file

Queue identification, file-condition checks and candidate-map observations together. Set limit for the initial descriptor page; the stored download includes all candidates.

Example: Inspect one upload, show 20 candidates initially, and download the full map list.

Endpoint
POST https://api.remapdb.com/v2/ecu/analyses
Content-Type: application/json
Idempotency-Key: <unique-request-identifier>

{
  "file_id": "{file_id}",
  "operation": "inspect",
  "limit": 20
}

Compare two uploads

Queue a comparison of reference and comparison files. Results separate exact byte changes from candidate-map matches and changes in their cell values.

Example: Compare two versions of a supplied binary without assuming either is original or tuned.

Endpoint
POST https://api.remapdb.com/v2/ecu/comparisons
Content-Type: application/json
Idempotency-Key: <unique-request-identifier>

{
  "reference_file_id": "{reference_file_id}",
  "comparison_file_id": "{comparison_file_id}",
  "limit": 20
}

Find candidate maps

Queue a scan for candidate tables. Download all saved map IDs, positions and dimensions once, or read individual pages from the completed job's details.

Example: Browse every map candidate locally before opening one as a raw grid.

Endpoint
POST https://api.remapdb.com/v2/ecu/map-scans
Content-Type: application/json
Idempotency-Key: <unique-request-identifier>

{
  "file_id": "{file_id}",
  "limit": 20
}

Download all map candidates

Authorize a short-lived storage download of the complete candidate descriptor list. Fetch the returned Location without your API key, then browse the JSON locally.

Example: Download all 701 candidates in one file without repeatedly loading the full result through the API.

Endpoint
GET https://api.remapdb.com/v2/ecu/jobs/{job_id}/artifacts/maps

Read a map's values

Queue raw-grid extraction using the original file and a map ID from its completed scan or inspection. Read grid.values and available axes from the new job's details.

Example: Turn a selected map candidate into rows of numbers for your table or heatmap.

Endpoint
POST https://api.remapdb.com/v2/ecu/map-grids
Content-Type: application/json
Idempotency-Key: <unique-request-identifier>

{
  "file_id": "{file_id}",
  "scan_job_id": "{scan_job_id}",
  "map_id": "{map_id}"
}

Follow analysis progress

Read the saved job status without restarting analysis. Inspect status and error together: a failed job can still be retrieved successfully with HTTP 200.

Example: Poll every two seconds or slower while showing progress in your own interface.

Endpoint
GET https://api.remapdb.com/v2/ecu/jobs/{job_id}

Retrieve the summary

Fetch the compact report after completion. It contains the operation's findings, counts and notices without the larger map entries or cell arrays.

Example: Show the identification outcome or changed-byte count in a request overview.

Endpoint
GET https://api.remapdb.com/v2/ecu/jobs/{job_id}/result

Open the detailed report

Retrieve expanded observations for the completed operation, including map descriptors, candidate comparisons or raw grid values and axes.

Example: Load the grid cell array only when a user opens that map.

Endpoint
GET https://api.remapdb.com/v2/ecu/jobs/{job_id}/details

Delete an upload

Prevent further use of an uploaded file and schedule its removal. Retained reports follow their own expiry, while physical cleanup can wait for active processing to finish.

Example: Remove the uploaded binary when your review workflow is finished.

Endpoint
DELETE https://api.remapdb.com/v2/ecu/files/{file_id}

Data coverage

From ECU identity to the numbers inside a map

Choose the observations your interface needs. Available fields depend on the uploaded file and supported checks; results keep missing evidence and unknown values explicit.

ECU identity

Manufacturer, family and model or variant, plus supported hardware, software, calibration and part numbers when established.

Identification confidence

An identified, review-required or unknown outcome, with a named confidence level and a short explanation.

File condition

Condition findings, check coverage and supported checksum results, with notices for observations that need review.

Candidate map descriptors

Map IDs, positions and dimensions, alongside available, returned and omitted counts for the requested scan.

Raw grids and axes

Rows of raw unsigned cell values, available axis values, dimensions and minimum or maximum values. Physical scaling remains unknown.

File and map differences

Exact changed-byte counts, differences in file length and candidate-map comparisons, including changed cells and realigned matches.

Developer setup

From API access to your first integration

Set up access, try your first request, and bring the results into your own application.

1

Check your API access

Use an API or Max key with vdb_read. Request capabilities to confirm service availability, operations, file limits and retention periods.

2

Upload the raw binary

Send the file through your backend as multipart form data. Save the returned file ID, checksum and expiry time.

3

Submit the operation

Choose identification, inspection, comparison or a map scan. Send the file IDs and a unique Idempotency-Key; reuse that key for unchanged retries.

4

Follow the job

Save the returned job ID and poll its status every two seconds or slower. Stop when it completes or reaches another terminal state.

5

Show the relevant details

Read the compact result first. Request details for map entries or comparisons, and submit a separate grid job for a selected map's values.

6

Manage files and reports

Use the returned expiry times, retain any reports your workflow needs and delete uploads when finished. Re-upload expired files before starting new analysis.

ECU observation + your application

Your workflow, with file evidence built in

Connect analysis to your existing upload and review process. Remapdb returns structured reports while your application manages the customer request and the next action.

Attach analysis to a request

Upload the binary through your backend and associate its file and job IDs with your own request record. Keep API credentials on the server.

Keep the review moving

Follow background-job progress and display the completed summary. Load map, grid or comparison details when someone needs a closer look.

Work with your AI tools

Use Remapdb MCP to identify, inspect or compare uploaded files through a connected assistant. Upload files through REST first; MCP works with their returned IDs.

One upload can support several operations until it expires. Keep the returned IDs with your request so your team can move from identification to inspection, maps or comparison.

API essentials

Know what to expect

FAQ

Questions about ECU observation API

What can the ECU observation API identify?

When supported by the file evidence, it returns the ECU manufacturer, family, variant and available software, hardware, calibration or part numbers. Each report includes an identification status and confidence level. Unknown fields are omitted.

Which files can I upload?

Upload raw binary files from one byte up to 8 MiB each. Convert archives, Intel HEX or S-record files to raw binary before uploading. The API does not automatically decode those formats.

Does ECU observation edit or repair my file?

No. It observes the uploaded bytes and returns a report. It does not edit maps, repair checksums, create a tuned file or confirm that a file is safe to flash.

Can I retrieve map values?

Yes. Run a map scan, then submit its file ID, scan job ID and map ID to the map-grid endpoint. A completed job’s details contain the raw cell values and available axes, with a maximum of 65,536 cells. Physical units and scaling remain unknown.

Which plan and key permissions do I need?

ECU observation requires an active API or Max subscription. A key with vdb_read can use the service. Restricted integrations can use ecu_observe for submissions and ecu_read for results. The vehicle catalog trial does not include ECU observation.

Your application. Remapdb data.

Build your next integration

Start with an account, choose the access your project needs, and connect your own workflow.