Seeded numeric PIN generator
Length 6 with the seed release-demo-2026 always gives 095015, and it is not flagged as weak. Build repeatable PINs for form tests, screenshots and demos, with patterns like 7777, 1234 or 4321 called out. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Length
- 6
- Seed
- release-demo-2026
- Pin
- 095015
The seeded numeric PIN generator turns a requested digit length and a text seed into a stable PIN made only of digits. The response also identifies obvious weak forms: one digit repeated throughout, a strictly ascending sequence, or a strictly descending sequence. It uses no clock, network, random source, or stored state, and it rejects lengths below four.
Generate the same PIN whenever you need it
Enter length as a whole number from 4 through 1,024 and enter seed as text. The generator hashes every character of the seed into a fixed 32-bit starting state, advances that state once per requested position, and maps each generated value to a decimal digit. The PIN is returned as text rather than as a number, so a leading zero is preserved and still counts toward the requested length.
Run the same length and case-sensitive seed again and every output field remains identical. Change the length or even one character of the seed and the deterministic stream changes. An empty string is a valid seed, although a descriptive value is usually easier to recognize in test data.
Because the algorithm has no hidden state, collaborators and automated jobs can reproduce an example without copying the PIN itself. Record both inputs when repeatability matters, and treat the pair as the complete recipe for rebuilding the result.
Understand the weak-pattern report
The weak flag becomes true when the entire PIN uses one repeated digit, when every neighboring digit rises by exactly one, or when every neighboring digit falls by exactly one. Sequences do not wrap between nine and zero, so 7890 is not classified as a strict ascending sequence. A PIN can be reproducible without matching any of these patterns, in which case weak is false and the list is empty.
This check is intentionally narrow and explainable. It does not estimate guessing probability, compare against leaked PIN lists, detect birthdays, or know whether a value has been reused elsewhere. Use the report as an immediate warning for conspicuous forms such as 7777, 1234, or 4321, not as proof that an unflagged PIN is secure.
Longer PINs increase the numeric search space, but deterministic generation remains predictable to anyone who knows the seed and algorithm.
Use deterministic PINs only in the right context
Seeded generation is most useful where reproducibility is more important than secrecy. It can supply stable values to automated form tests, screenshots, documentation examples, device simulators, training exercises, and development environments. Do not use this capability to create a real authentication PIN, recovery code, payment credential, door code, or any value that must resist prediction.
The generator is deliberately deterministic and non-cryptographic: a person who learns the seed can reproduce the PIN, and similar operational mistakes can expose the input recipe. For genuine credentials, rely on a cryptographically secure random source controlled by the authentication system, apply rate limits, prevent common choices, and follow the system's enrollment and recovery policies. Also avoid using personal details as seeds because the seed is returned in the response and may appear in logs.
What you can do with it
Reproduce a simulator scenario
Share a seed and length so another developer can rebuild the exact PIN used in a device or kiosk simulation.
Prepare repeatable documentation
Keep screenshots and worked examples consistent across rebuilds while clearly labeling the values as non-production samples.
FAQ
Does the same seed always produce the same PIN?
Yes. The same case-sensitive seed and length produce the same PIN and pattern report with this algorithm.
What happens when the length is below four?
A length of at least four digits is required.
Which patterns are flagged as weak?
The checker flags a single digit repeated throughout and strict ascending or descending sequences without wraparound.
Can I use the generated PIN for a real account?
No. This deterministic generator is intended for reproducible samples and tests, not authentication secrets or recovery codes.
Why does the PIN keep a leading zero?
The PIN is returned as text, not as a number, so a first digit of zero is kept and counts toward the length. That is why 095015 still has 6 digits instead of turning into a shorter number.
Related tools
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/security/password-pin-seeded \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"length":6,"seed":"release-demo-2026"}'const res = await fetch("https://api.kit.forhosting.com/security/password-pin-seeded", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"length": 6,
"seed": "release-demo-2026"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/password-pin-seeded",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"length": 6,
"seed": "release-demo-2026"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/password-pin-seeded", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"length":6,"seed":"release-demo-2026"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"length":6,"seed":"release-demo-2026"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/password-pin-seeded", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"length": 6,
"seed": "release-demo-2026"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.password_pin_seeded",
"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_items | 1024 |
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. |
Technical notes
Understand the weak-pattern report
The result includes weak and weak_patterns alongside the PIN, length, and original seed. The pattern list names each condition that matched, using repeated_digits, ascending_sequence, or descending_sequence.
Integration use cases
Create stable form-test fixtures
Regenerate the same numeric input for validation and end-to-end tests without storing a separate fixture value.
Technical questions
How much does one API request cost?
One API request costs $0.002. The browser version runs the same pure deterministic algorithm locally.