How to Add Rego Plate Lookup to Your Auto Parts Store

The fastest way to help an Australian auto parts customer find the right part is to ask for their number plate. One plate lookup returns the vehicle's year range, make, model, body type, and engine -- enough to filter your catalogue to compatible parts instantly. This is called a "rego search to garage" feature, and it is the single biggest conversion improvement most Australian auto parts stores can make.

This guide walks through how to build it with PlateAPI, from the API call to the frontend flow, with working code examples.

What is rego search to garage?

Rego search to garage is a feature where a customer enters their vehicle's registration plate number, the system identifies the vehicle automatically, and the store filters its parts catalogue to show only compatible items. The customer's vehicle is saved to their "garage" so they do not need to enter the plate again on future visits. It replaces manual make/model/year dropdown selectors, which are slow and error-prone -- most customers do not know their exact model year or engine variant.

Why it matters for auto parts stores

Auto parts stores that add plate-based vehicle identification see measurable improvements:

• Faster vehicle identification. A plate lookup takes under 3 seconds. Navigating a make/model/year dropdown takes 15-30 seconds and often leads to wrong selections.
• Fewer fitment errors. The API returns the exact model generation, body type, and engine displacement -- the same granularity parts catalogues use for fitment. Customers picking "2005 Corolla" from a dropdown might get the wrong generation; a plate lookup gets the right one.
• Higher conversion. Every step you remove from "I need a part" to "here are compatible parts" reduces drop-off. Plate lookup is one field instead of three or four dropdowns.
• Works for every state. PlateAPI covers all eight Australian states and territories (ACT, NSW, NT, QLD, SA, TAS, VIC, WA) in a single API call. No per-state logic needed.

How it works: the basic flow

1. Customer enters their plate number and selects their state
2. Your backend calls PlateAPI with the plate and state
3. PlateAPI returns the vehicle: year range, make, model, body, engine
4. Your store filters parts to that vehicle and saves it to the customer's garage
5. On return visits, the customer selects their saved vehicle -- no re-entry needed

Step 1: Get an API key

Create a free PlateAPI account -- no credit card required. Your API key is issued instantly and works for 20 lookups per month on the free tier. For a live store, the Starter plan at $29/month gives you 400 lookups -- enough for most small to mid-size auto parts stores.

Step 2: Call the API from your backend

Always call PlateAPI from your server, never from browser JavaScript. This keeps your API key secret and lets you add your own caching or rate limiting.

Node.js / Express example

app.get("/api/vehicle-lookup", async (req, res) => {
  const { plate, state } = req.query;

  const response = await fetch(
    `https://api.plateapi.com.au/api/v1/lookup?plate=${plate}&state=${state}`,
    { headers: { "X-API-Key": process.env.PLATEAPI_KEY } }
  );
  const data = await response.json();

  if (data.success) {
    res.json({
      year_range: data.vehicle.year_range,
      make: data.vehicle.make,
      model: data.vehicle.model,
      body: data.vehicle.body,
      engine: data.vehicle.engine,
      alternatives: data.alternatives,
    });
  } else {
    res.status(404).json({ error: "Vehicle not found" });
  }
});

Python / Flask example

import os, requests
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/api/vehicle-lookup")
def vehicle_lookup():
    plate = request.args.get("plate")
    state = request.args.get("state")

    resp = requests.get(
        "https://api.plateapi.com.au/api/v1/lookup",
        params={"plate": plate, "state": state},
        headers={"X-API-Key": os.environ["PLATEAPI_KEY"]},
        timeout=30,
    )
    data = resp.json()

    if data["success"]:
        v = data["vehicle"]
        return jsonify(
            year_range=v["year_range"],
            make=v["make"],
            model=v["model"],
            body=v["body"],
            engine=v["engine"],
            alternatives=data["alternatives"],
        )
    return jsonify(error="Vehicle not found"), 404

Step 3: Build the frontend

The frontend needs a plate input field, a state selector, and a results area. Here is a minimal example:

<form id="rego-form">
  <input type="text" id="plate" placeholder="Enter rego plate"
         maxlength="10" required />
  <select id="state">
    <option value="NSW">NSW</option>
    <option value="VIC">VIC</option>
    <option value="QLD">QLD</option>
    <option value="SA">SA</option>
    <option value="WA">WA</option>
    <option value="TAS">TAS</option>
    <option value="NT">NT</option>
    <option value="ACT">ACT</option>
  </select>
  <button type="submit">Look Up Vehicle</button>
</form>
<div id="result"></div>

<script>
document.getElementById("rego-form")
  .addEventListener("submit", async (e) => {
    e.preventDefault();
    const plate = document.getElementById("plate").value;
    const state = document.getElementById("state").value;
    const res = await fetch(
      `/api/vehicle-lookup?plate=${plate}&state=${state}`
    );
    const data = await res.json();
    if (data.make) {
      document.getElementById("result").textContent =
        `${data.year_range} ${data.make} ${data.model} ${data.engine}`;
    } else {
      document.getElementById("result").textContent =
        "Vehicle not found -- check the plate and try again.";
    }
  });
</script>

Step 4: Handle multiple matches

Some plates map to multiple vehicle variants -- for example, the same model sold with different engine options. When PlateAPI returns entries in the alternatives array, show the customer a picker so they confirm which variant is theirs. This is critical for parts fitment: a 1.8L petrol and a 2.0L diesel take different filters, belts, and brake pads.

Step 5: Add a make/model/year fallback

Not every customer has their plate handy. For those cases, offer a traditional make/model/year dropdown as a fallback. PlateAPI's vehicle database endpoint provides cascading make, model, and year data for 32,000+ Australian vehicles across 213 makes -- purpose-built for these dropdowns. It does not consume your lookup quota and responds in milliseconds.

Step 6: Save to the customer's garage

Once a vehicle is identified, save it to the customer's account or browser session. On return visits, they select from their saved vehicles instead of entering a plate again. This "garage" pattern is standard in Australian auto parts ecommerce and dramatically improves repeat purchase experience.

Which plan do you need?

Plan selection depends on your monthly lookup volume:

• Free ($0/month, 20 lookups): enough for development, testing, and integration builds. Use the sandbox plate TEST123 for CI.
• Starter ($29/month, 400 lookups): suits most small auto parts stores. At a typical 2-3% lookup-to-visit ratio, this covers around 15,000 monthly visitors.
• Growth ($89/month, 2,000 lookups): for busy stores or multi-location businesses with higher traffic.
• Enterprise ($549/month, unlimited): for high-volume platforms, marketplace integrations, or stores with heavy repeat lookup traffic.

All plans return the same data, cover all states, and include the sandbox test plate. See the full pricing breakdown.

Testing your integration

Use plate TEST123 with any state for automated tests and CI. It returns a fixed response instantly (2015-2020 Toyota Hilux SR 2.8L Diesel) without consuming quota or hitting upstream sources. For manual testing with real plates, the live demo on the PlateAPI homepage shows exactly what the API returns.