License plate generator from a pattern and seed
This deterministic license plate generator turns a recognized layout template and a seed into a plausible plate-style string.
Run — free
Choose a supported arrangement such as three letters followed by three digits, then provide any stable seed that identifies your test case. The same template and seed always return the same result, which makes the tool useful for fixtures, mockups, demos, and repeatable sample data without copying a real vehicle registration accidentally.
Choose a layout that matches your mock data
Start by selecting one of the recognized templates. Each template defines the number and order of letter and digit groups, while hyphens make the result easy to read. For example, the three-letters-three-digits template produces a value shaped like ABC-123, and the one-letter-three-digits-two-letters template produces a value shaped like A-123-BC. The generator intentionally supports a documented set rather than trying to interpret arbitrary prose. That strict boundary prevents a misspelled template from silently producing a plate with the wrong shape. It also makes validation straightforward in automated tests because every accepted format has a stable contract. The letters come from an ambiguity-reduced uppercase alphabet that omits characters commonly confused on signs and small images. Digits use the standard zero-through-nine set. The result is plausible display data, not a claim that the format is officially issued by a particular authority. Always choose the layout your interface, fixture, or demonstration expects, and treat jurisdiction-specific legal rules as a separate concern.
Use the seed as a repeatable identity
The seed controls which characters fill the selected layout. It can be a fixture name, an internal example label, a vehicle reference used only in a test environment, or any other stable text. The algorithm combines the complete seed with the chosen template and each output position, then maps the resulting unsigned value into the appropriate letter or digit alphabet. No random source, current time, network call, stored counter, or process state participates. Consequently, identical inputs produce identical JSON across repeated runs, while a different seed normally produces a different plate. The template is part of the derivation as well, so changing the layout creates a fresh result instead of merely rearranging characters from the old one. Seeds are treated as exact, case-sensitive strings: Demo, demo, and demo followed by a space are distinct inputs. Keep that behavior in mind when generating fixtures from user data. Normalize a seed in your own application first if capitalization or surrounding whitespace should not distinguish records. The response echoes both inputs alongside the generated plate so logs and snapshots remain understandable.
Apply generated plates responsibly
Generated plate-style strings are most useful where realistic shape matters but a real registration must not be exposed. A design team can populate vehicle cards, a developer can create stable end-to-end fixtures, and a documentation writer can show an API response that remains unchanged between builds. Because the output only follows a visual template, it does not check registration databases, reserved sequences, regional prefixes, checksum rules, diplomatic ranges, or whether an authority could issue the value. A generated string may coincide with a real plate by chance, so do not use it to identify, accuse, impersonate, register, or authorize a vehicle. For public mockups, consider adding an obvious fictional context around the plate as well. Automation clients receive the same deterministic result as the browser tool. A malformed or unsupported pattern returns an invalid-input error instead of guessing, which lets pipelines fail early and makes template migrations deliberate. Browser use is free, while an API request uses the displayed $0.002 base price. Store the seed when you need to reproduce a value later; no server-side history is required for regeneration.
What you can do with it
Stable software fixtures
Create repeatable plate-shaped values for tests and snapshots without embedding a real registration.
Vehicle interface mockups
Fill cards, tables, and prototypes with readable strings that follow a chosen letter-and-digit layout.
Consistent documentation examples
Regenerate the same sample plate whenever tutorials, screenshots, or API examples are rebuilt.
FAQ
Will the same seed always produce the same plate?
Yes. When both the template and exact seed are unchanged, the result is deterministic.
Does the result belong to a real vehicle?
The tool does not query registration records. A coincidental match is possible, so the output must be treated as fictional sample data rather than proof of registration.
Which pattern templates are recognized?
The input selector lists every supported template, including letter-first, digit-first, and grouped layouts. Any value outside that documented list returns an invalid-input error.
Why are some letters never generated?
The alphabet omits several characters that are easily confused with digits or with one another when displayed at small sizes.
What does an API request cost?
Each API request uses the displayed $0.002 base price. The browser version runs locally for free.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/locale/license-plate-style \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pattern":"3-letters-3-digits","seed":"demo-vehicle-42"}'const res = await fetch("https://api.kit.forhosting.com/locale/license-plate-style", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pattern": "3-letters-3-digits",
"seed": "demo-vehicle-42"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/locale/license-plate-style",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pattern": "3-letters-3-digits",
"seed": "demo-vehicle-42"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/locale/license-plate-style", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pattern":"3-letters-3-digits","seed":"demo-vehicle-42"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pattern":"3-letters-3-digits","seed":"demo-vehicle-42"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/locale/license-plate-style", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"pattern": "3-letters-3-digits",
"seed": "demo-vehicle-42"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "locale.license_plate_style",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_tokens | 20000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |