Cloud Tuning API

Integrate our ECU processing engine directly into your platform. Your customer uploads an ECU file on your site; you send the file plus the solutions you want; we return the corrected file — checksum and RSA fixed automatically — with no manual handling of any web UI.

Base URL: https://www.davincideluxe.fr/api/v1/cloud

Uses your existing DaVinci Deluxe · Cloud Edition account. Subscribe with the normal Stripe checkout — your API key is generated automatically and appears in your profile.

Authentication

Every request is authenticated with a secret API key sent as a Bearer token. Generate your key in your dashboard at /profile#api after activating an API plan. The raw key is shown once — store it securely; we only keep a hash.

Authorization: Bearer dvc_live_xxxxxxxxxxxxxxxxxxxxxxxx

Quick start

Submit a file with the solutions you want and a callback URL. You get a job_id back immediately, then a signed webhook when the corrected file is ready.

# 1. Submit a job (multipart)
curl -X POST https://www.davincideluxe.fr/api/v1/cloud/jobs \
  -H "Authorization: Bearer dvc_live_xxxxx" \
  -F "file=@/path/to/original.bin" \
  -F "ecu_brand=Bosch" \
  -F "ecu_model=EDC17C64" \
  -F "fuel_type=diesel" \
  -F 'services=["DPF","EGR","ADBLUE","DTC"]' \
  -F 'tuning_options=["Stage 1"]' \
  -F "webhook_url=https://yourapp.com/hooks/davinci"

# → { "job_id": 1234, "status": "queued", "webhook_will_fire": true }

Endpoints

Submit a job

Content-Type: multipart/form-data. Send the binary in the file field.

// 202 Accepted
{
  "job_id": 1234,
  "status": "queued",
  "status_url": "/api/v1/cloud/jobs/1234",
  "webhook_will_fire": true
}

Job status

Poll for progress if you are not using webhooks. Status moves through queued → processing → done (or error).

{
  "job_id": 1234,
  "status": "done",
  "result_url": "https://www.davincideluxe.fr/api/v1/cloud/jobs/1234/result"
}

Download result

Streams the corrected binary (checksum + RSA already applied). Available once status = done.

List jobs

Returns your recent jobs with status and timestamps.

Check coverage (before you submit)

Returns the engine’s live, real coverage — exactly which ECUs and services are processed automatically right now. Query it before uploading so you only submit files the engine can handle; anything outside this list is rejected (and never charged). Two modes:

// GET /api/v1/cloud/coverage?ecu=EDC17C50
{
  "ok": true,
  "ecu": "EDC17C50",
  "supported": true,
  "services": ["dpf", "egr", "adblue", "stage1", "stage2"]
}

Health

Authenticated liveness check. Also returns your subscription status headers.

Solutions covered

Two families are available. Deletes / corrections go in the services array; performance tuning presets go in the tuning_options array. You can combine both in a single job.

Anti-pollution & corrections — services

• DPF / FAP
• EGR
• AdBlue / SCR
• DTC removal
• Lambda / O2
• Flaps / Swirl
• NOx
• Start & Stop
• Hot Start fix
• Readiness / OBD

Performance tuning — tuning_options

• Stage 1
• Stage 1+
• Stage 2
• Stage 3
• Eco Tune
• Pops & Bangs
• Pops & Bangs (switchable)
• Launch Control
• Hardcut / RPM limiter
• E85 conversion

Supported ECUs & vehicles

Live engine coverage — every brand, ECU and solution

ECU hardware

• Bosch EDC15 / EDC16 / EDC17
• Bosch MED9 / MED17 / ME17 / MEDC17
• Bosch MG1 / MD1
• Continental · Siemens SID (201–807 EVO)
• Continental SIMOS 8 / 12 / 18
• Continental PCR 2.1 / PPD 1.x
• BMW MSD80–90 / MSV / MEVD17
• Delphi DCM3.x / 6.x / 7.x
• Delphi CRD2 / CRD3 / DDCR
• Denso
• Magneti Marelli MJD / IAW / 8GMK
• Valeo VD46.x / VD56.x / J34 / V34
• Visteon DCU102
• ZF (transmission)

Vehicle brands

• Alfa Romeo
• Audi · VW · Seat · Skoda
• BMW · Mini
• Chery
• Chrysler · Dodge · Jeep
• Citroën · Peugeot · DS
• Dacia
• Deutz
• Ferrari
• Fiat · Lancia
• Ford
• Geely
• Great Wall
• Honda
• Hyundai · Kia
• Isuzu
• Iveco · CNH
• JAC
• Jaguar · Land Rover
• Kubota
• Mahindra
• MAN
• Maserati
• Maxus · LDV
• Mazda
• Mercedes-Benz · Smart
• Mitsubishi
• Nissan
• Opel · Chevrolet · Vauxhall
• Renault
• SsangYong
• Subaru
• Suzuki
• Toyota · Lexus
• Volvo

New ECUs are added continuously — see the full searchable list. If you do not see a specific ECU, submit it anyway — if we cannot process it, the job is rejected with a clear reason and no charge.

Compatibility & integration

It is a plain HTTPS REST API, so it works with any platform, language or hosting that can make a web request and receive a webhook. No SDK, no special software, no server-side dependency on our side.

Hosting & servers

• Any Linux VPS / dedicated server
• cPanel / Plesk / shared hosting
• Node.js hosting
• Windows Server / IIS
• Cloud (AWS, GCP, Azure, OVH, Hetzner…)
• Serverless (Cloudflare Workers, Vercel, Lambda)

Platforms & CMS

• WordPress / WooCommerce (PHP)
• Joomla / Drupal / PrestaShop (PHP)
• Laravel / Symfony
• Node.js (Express, Next.js)
• Python (Django, Flask, FastAPI)
• Any custom site with a backend

PHP example (WordPress / cPanel)

<?php
// Submit a job from PHP (works in WordPress, Joomla, plain cPanel)
$ch = curl_init('https://www.davincideluxe.fr/api/v1/cloud/jobs');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer dvc_live_xxxxx'],
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => [
    'file'        => new CURLFile('/path/to/original.bin'),
    'ecu_brand'   => 'Bosch',
    'ecu_model'   => 'EDC17C64',
    'services'    => '["DPF","EGR","DTC"]',
    'webhook_url' => 'https://your-site.com/wp-json/davinci/v1/hook',
  ],
]);
$res = json_decode(curl_exec($ch), true);
// $res['job_id']

PHP webhook verification

<?php
$payload = file_get_contents('php://input');
$sig = $_SERVER['HTTP_X_DVC_SIGNATURE'] ?? '';
$expected = 'sha256=' . hash_hmac('sha256', $payload, 'whsec_xxxxx');
if (!hash_equals($expected, $sig)) { http_response_code(400); exit; }
$evt = json_decode($payload, true);
// $evt['event'] === 'job.completed' -> download $evt['result_url'] with your API key

Python example

import requests
r = requests.post(
  "https://www.davincideluxe.fr/api/v1/cloud/jobs",
  headers={"Authorization": "Bearer dvc_live_xxxxx"},
  files={"file": open("original.bin", "rb")},
  data={"ecu_brand": "Bosch", "ecu_model": "EDC17C64",
        "services": '["DPF","EGR","DTC"]',
        "webhook_url": "https://your-site.com/hooks/davinci"})
print(r.json()["job_id"])

Webhooks (async callbacks)

If you set webhook_url, we POST a JSON event the moment the job reaches a terminal state — job.completed or job.failed. Delivery is retried automatically (60s, 5min, 30min, up to 4 attempts) on any non-2xx response.

POST https://yourapp.com/hooks/davinci
X-DvC-Event: job.completed
X-DvC-Signature: sha256=<hmac_hex>
X-DvC-Delivery-Attempt: 1

{
  "event": "job.completed",
  "job_id": 1234,
  "status": "done",
  "ecu_brand": "Bosch",
  "ecu_model": "EDC17C64",
  "services_applied": ["DPF","EGR","Stage 1"],
  "result_url": "https://www.davincideluxe.fr/api/v1/cloud/jobs/1234/result",
  "completed_at": "2026-06-20T10:30:00.000Z",
  "metadata": "your-reference"
}

Verifying the signature

Every webhook is signed with your per-key webhook secret (whsec_..., shown once when you create the key). Compute an HMAC-SHA256 of the raw request body with that secret and compare it to the X-DvC-Signature header.

// Node.js (Express) -- verify a DaVinci webhook
const crypto = require('crypto');

app.post('/hooks/davinci',
  express.raw({ type: 'application/json' }), (req, res) => {
    const sig = req.headers['x-dvc-signature'] || '';
    const expected = 'sha256=' + crypto
      .createHmac('sha256', process.env.DAVINCI_WEBHOOK_SECRET)
      .update(req.body)              // raw Buffer, not parsed JSON
      .digest('hex');
    if (sig !== expected) return res.sendStatus(400);

    const evt = JSON.parse(req.body.toString());
    // evt.event === 'job.completed' -> download evt.result_url with your API key
    res.sendStatus(200);
  });

Rate limits & file size

Your subscription state is returned on every authenticated call so your integration always knows access is live:

X-DvC-Subscription-Status: active
X-DvC-Subscription-Period-End: 2026-07-20T00:00:00.000Z

Errors

Support

Integration help, sandbox keys, or volume pricing: message us on WhatsApp. We typically reply same-day.

All processing is performed on files you are authorized to modify.

Frequently asked questions

How do I authenticate with the Cloud Tuning API?

Every request uses a Bearer API key: send the header Authorization: Bearer dvc_live_. You create and revoke keys yourself in your DaVinci Deluxe · Cloud Edition profile under API settings.

Which programming languages and platforms can I use?

Any language or stack that can make HTTPS requests works. We provide ready PHP (WordPress / cPanel) and Python examples, and the REST API integrates with any CMS, framework or hosting provider.

Is the Cloud Tuning API synchronous or asynchronous?

It is asynchronous. You submit a job, then either poll the job-status endpoint or set a webhook URL and we POST a signed callback the moment the processed file is ready to download.

Which ECU solutions and brands are supported?

Anti-pollution and performance solutions including DPF/FAP, EGR, AdBlue/SCR, DTC removal, Lambda, MAF, Stage 1/2/3, Pops & Bangs and Hardcut across Bosch, Continental, Siemens, Delphi, Marelli and more. Checksum and RSA are corrected automatically; unsupported files are rejected with a clear reason and never charged.

What are the API rate limits and maximum file size?

The API allows up to 60 requests per minute and a maximum file size of 50 MB per job. Exceeding the burst limit returns HTTP 429 rate_limit_exceeded; retry after a short delay. Each plan also has a daily file cap (Starter 100/day, Business 500/day, Enterprise unlimited); exceeding it returns HTTP 429 daily_limit_reached.

How do I verify webhook callbacks are genuine?

Each webhook is signed with HMAC-SHA256 using your whsec_ secret and delivered in the X-DvC-Signature header. Recompute the signature over the raw request body and compare it to confirm the callback really came from DaVinci Deluxe · Cloud Edition.