RemapdbRemapdb

Remapdb API

Build with vehicle tuning API data

Use the Remapdb vehicle tuning database API to bring vehicle lookup, engine data, tuning gains, and configurator logic into your own website, platform, dashboard, dealer portal, or file-service workflow.

Explore API accessSee pricing

22,000+ vehicle engines. REST-style API access. JSON-ready tuning data. Built for custom integrations.

22,000+ vehicle engines

Access a large vehicle and engine data foundation through one integration layer.

Vehicle lookup

Build custom make, model, engine, and variant selection flows.

Tuning gains

Use structured performance data in your own UI, dashboards, or workflows.

JSON-ready responses

Work with predictable API responses designed for modern web products.

Custom interfaces

Build your own configurator instead of relying only on the Remapdb Widget.

Platform-ready

Use the API for websites, portals, dashboards, file services, dealer systems, and internal tools.

API possibilities

Use Remapdb data inside your own product experience

This vehicle tuning API is for teams that want full control over interface, flow, and customer journey while using Remapdb as the tuning data layer.

Custom vehicle configurator

Build your own vehicle search and selection experience using Remapdb data.

Example: make -> model -> generation -> engine -> tuning result

endpoint
GET https://api.remapdb.com/v1/search?query=audi
GET https://api.remapdb.com/v1/engines/{engine_id}

Tuning gains display

Show stock and tuned performance values inside your own website, dashboard, or portal.

Example: original HP/Nm vs tuned HP/Nm for available stages

endpoint
GET https://api.remapdb.com/v1/engines/{engine_id}

Online file-service workflow

Connect selected vehicle data to quote, file request, or customer inquiry flows.

Example: vehicle selected -> tuning shown -> file request started

endpoint
POST /your-service/file-requests
{
  "engine_id": 1234,
  "stage_number": 1
}

Dealer network tools

Use vehicle and request context inside dealer portals, routing flows, or location-based systems.

Example: selected vehicle + selected dealer + quote request context

endpoint
GET https://api.remapdb.com/v1/search?query=bmw
POST /your-service/dealer-routing

Product and parts pages

Add vehicle-aware performance data to product pages, catalog journeys, or compatibility flows.

Example: product page shows supported vehicle data and gains

endpoint
GET https://api.remapdb.com/v1/engines/{engine_id}

Internal admin tools

Build internal lookup tools for sales, support, quoting, or data review.

Example: support team searches a vehicle and checks available tuning values

endpoint
GET https://api.remapdb.com/v1/search?query=2.0 tdi
Explore API docsReview authentication

API workflow

From vehicle lookup to your own interface

The API lets your system request vehicle and tuning data, then render that information inside your own configurator, dashboard, portal, product page, or internal tool.

1

Request vehicle data

Your app requests makes, models, generations, engines, or specific vehicle records.

2

Receive structured responses

The API returns vehicle and tuning data in a developer-friendly JSON structure.

3

Render your own UI

You decide how the data appears: configurator, dashboard, product page, portal, or internal tool.

4

Connect the next action

Use selected vehicle context in quote flows, file requests, dealer routing, and internal workflows.

5

Expand when needed

Start with one integration and grow into more endpoints and customer-facing experiences over time.

Read integration best practicesCheck usage limits

Developer examples

Predictable data your team can build around

Real examples below are based on Remapdb OpenAPI endpoint contracts and example payloads from the current documentation.

Vehicle lookup

request
curl -X GET "https://api.remapdb.com/v1/search?query=audi" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept-Language: en"
response
{
  "results": [
    {
      "type": { "id": 1, "name": "Cars & LCV" },
      "manufacturer": { "id": 1234, "name": "Audi" },
      "model": { "id": 123, "name": "A4" },
      "generation": { "id": 1234, "name": "B5" },
      "engine": { "id": 1234, "name": "2.2 i-CDTi 140hp 340Nm" }
    }
  ],
  "total": 456
}

Engine and tuning data

request
curl -X GET "https://api.remapdb.com/v1/engines/1234" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Accept-Language: en"
response
{
  "id": 1234,
  "name": "1.8i 125hp 170Nm",
  "engine_code": "XYZ",
  "capacity": 1800,
  "cylinders": 4,
  "fuel": "Petrol",
  "performance": {
    "power": 150,
    "torque": 270
  },
  "tuning": {
    "stages": [
      {
        "stage_number": 1,
        "performance": { "power": 482, "torque": 620 }
      }
    ],
    "options": [
      { "name": "EGR", "description": "Removal of EGR" }
    ]
  }
}

Subscription and API access

request
curl -X GET "https://api.remapdb.com/v1/subscription" \
  -H "Authorization: Bearer YOUR_API_KEY"
response
{
  "api_key": "string",
  "scopes": ["vdb_read"],
  "calls_limit": 3600,
  "created": "2024-12-04T08:05:15+00:00",
  "subscription": {
    "api_access": true,
    "is_active": true,
    "end_date": "2028-12-04T08:05:15+00:00"
  }
}
Open endpoint documentationAPI credentials guide

Data coverage

Vehicle and tuning data for custom workflows

Use Remapdb as your tuning database API layer for vehicle identity, engine specs, stage data, and performance gains in your own workflow.

Vehicle identity

Make, model, generation, year range, variant, and vehicle structure where available.

Engine data

Engine name, fuel type, displacement, stock power, stock torque, and related technical context.

Tuning stages

Stage-level tuning information where available, including supported stage numbers.

Performance gains

Power and torque values, including original and tuned performance values.

Vehicle compatibility context

Data that helps users understand whether a selected vehicle is relevant for a service or flow.

Integration metadata

IDs and response fields your system can use to connect Remapdb data to your own interface.

View plan access

Integration patterns

Choose how Remapdb data fits your product

Pick the integration pattern that matches your architecture, from front-end configurators to back-end service workflows and dealer routing.

Front-end configurator

Use API data to build your own vehicle selector and tuning result UI. Best for custom websites and advanced landing pages.

Back-end service integration

Use your server to request Remapdb data and combine it with your business logic. Best for portals and secure workflows.

File-service request flow

Connect vehicle data to file requests, quote flows, and service inquiries. Best for online tuning file providers.

Dealer network routing

Use selected vehicle and dealer context for partner and location-based flows. Best for multi-location tuning companies.

Product-page data layer

Use vehicle and tuning data inside product pages and compatibility journeys. Best for parts and module websites.

Internal lookup tools

Build admin, support, sales, and quote-assistance tools for your team.

Discuss your integration

Developer setup

From API access to first working request

Start with secure credentials, validate requests in staging, then move endpoint by endpoint into your own production flow.

1

Enable API access

Choose a plan or add-on that includes API access.

2

Generate credentials

Copy your API key from the API section and store it in secure server-side secrets.

3

Review API docs

Check endpoint contracts, parameters, limits, and implementation notes.

4

Make first request

Start with vehicle lookup, then move to engine and tuning data endpoints.

5

Build your interface

Render the data in your own configurator, portal, dashboard, file-service flow, or internal tool.

6

Test and launch

Validate edge cases, missing values, and usage limits before production rollout.

Explore API accessRead API docs

API capabilities

What the Remapdb API helps your team do

Use this as your compact API capability checklist for planning rollout, architecture, and customer-flow coverage.

  • Vehicle lookup API
  • Engine-level data
  • Tuning gains API
  • JSON response structure
  • Custom configurator logic
  • White-label product experience
  • Quote and request workflows
  • API credentials and authentication
  • Documentation and examples
  • Support for technical teams
Visit docs and supportAPI help center

Related features

Choose the right integration path

Widget

Use the Widget when you want the fastest embedded customer-facing experience.

Explore widget

WordPress plugin

Use the plugin if your website runs on WordPress and you want a simpler installation path.

View WordPress plugin

Customisations

Planned feature for advanced database editing, custom records, imports, and deeper data control.

Explore customisations

Support

See how Remapdb helps with setup, documentation, installation, and technical guidance.

View support

Pricing

Compare plans for API access, websites, branding, quote features, support, and advanced control.

See pricing

FAQ

Questions about the Remapdb API

What does the Remapdb API do?

The API lets you use Remapdb vehicle and tuning data inside your own website, platform, dashboard, portal, quote flow, file-service flow, or internal tool.

Who is the API for?

It is best for businesses that need deeper integration than the standard Widget, including online tuning file providers, cloud-based platforms, dealer networks, and custom automotive websites.

What can developers build with it?

Developers can build custom vehicle configurators, tuning result pages, internal lookup tools, quote flows, file request flows, dealer routing systems, and product-page data experiences.

What data can we access?

API data supports vehicle lookup, engine information, tuning specs, performance gains, stage data, and selected vehicle context where available.

Does the API return JSON?

Yes. The API returns structured JSON responses suitable for modern web applications. Final response formats should always follow the live API reference documentation.

How large is the database?

Remapdb includes data covering 22,000+ vehicle engines, with ongoing improvements and maintenance.

Can we build our own configurator?

Yes. The API is the right path when you want your own vehicle selector, tuning result UI, quote flow, or platform-level experience.

Does the API replace the Widget?

No. The Widget is the fastest embedded option. The API is for teams that need deeper control and custom interfaces.

Do we need developers?

Yes. API integration requires technical implementation by your developer or technical team.

Is API access included in every plan?

API access depends on your selected plan or add-on. Check Pricing for availability.

Is there documentation?

Yes. API reference documentation includes endpoints, parameters, examples, authentication guidance, and implementation notes.

Can Remapdb build the integration for us?

Remapdb provides API reference documentation, access guidance, and support where available. Full custom development inside your own platform is handled by your technical team.

Ready to build with Remapdb data?

Add vehicle tuning data to your own product

Use the Remapdb API to power vehicle lookup, tuning gains, configurators, quote flows, dashboards, and custom platform experiences.

Explore API accessSee pricing

22,000+ vehicle engines. JSON-ready data. Built for custom vehicle tuning integrations.