DEV Community: DSP

DigitProof: one API for every check digit, and it fixes the wrong ones

DSP — Mon, 26 Oct 2026 05:57:40 +0000

Every codebase I have ever worked in has a graveyard of half-remembered validation rules. The IBAN check is mod-97, but only after you rearrange the string. The ISBN-10 check digit can be the letter X. A VIN has a check digit at position 9, unless it was built for a market that does not use one. Each identifier has its own standard, its own math, and its own way of quietly going wrong.

DigitProof is my attempt to put all of that in one place. It is a single API that validates nine families of structured identifiers, parses them, and, this is the part I actually wanted, tells you the correct check digit when the one you have is wrong.

What it validates

IBAN: length and structure for 86 countries, mod-97 check digits, BBAN parsing (bank code, branch code, account number) for 22 countries, SEPA flag, grouped formatting
LEI: the ISO 17442 format and its mod-97 check digits, with the LOU prefix broken out
ISIN: country and NSIN structure with the Luhn check digit
ISBN-10 and ISBN-13, including conversion between them
GTIN-8, UPC-A, EAN-13, and GTIN-14, detected from length
VIN: 17 characters, the North American position-9 check digit, make hints and model year decoding
Payment cards: Luhn, brand detection, and the networks' published test numbers flagged as test_only
UUID: version and variant parsing
EU and GB VAT numbers: per-country formats, with check digits verified where a country defines them

It is format and checksum validation only. There are no bank directories or registry lookups behind it, and the listing says so plainly. A valid result means the identifier is well-formed and its math checks out.

A taste

Send a known-good IBAN:

curl -X POST "https://digitproof.p.rapidapi.com/v1/validate" \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"value": "GB29 NWBK 6016 1331 9268 19"}'

You get back the parsed structure, not just a yes:

{
  "type": "iban",
  "valid": true,
  "details": {
    "country_code": "GB",
    "sepa": true,
    "bank_code": "NWBK",
    "branch_code": "601613",
    "account_number": "31926819",
    "formatted": "GB29 NWBK 6016 1331 9268 19"
  }
}

Now the interesting part. Change the last digit of that account number and the checksum fails, and instead of a bare false you get the expected check digits and the corrected identifier:

{
  "valid": false,
  "errors": [
    { "code": "bad_checksum", "expected_check_digits": "56", "actual_check_digits": "29" }
  ],
  "correction": "GB56NWBK60161331926818"
}

There is also a dedicated check-digit endpoint that computes the digit even when the check position holds a placeholder, auto-detection if you do not know what kind of identifier you are holding (a 13-digit 978 number comes back as both ISBN-13 and GTIN-13), and batch validation for up to 100 identifiers per call.

How it is built

FastAPI on the free tier of Render, with the validation logic kept pure and separate from the web layer. Every validator runs on published standards and official test vectors, and the test suite caught me three real math bugs before launch, including one in the French VAT key formula. The API is stateless and stores nothing: values are processed in transit and forgotten.

Pricing

Every endpoint is available on every plan, including the free tier. The validate, batch, check-digit, and types endpoints are all there from the start, with no Pro-only identifier types and no correction feature held back to force an upgrade. Upgrading simply gets you more requests per month: start free with 150 requests a month (and remember, one request can carry a batch of 100), move up to Pro at $9/month for 5,000, Ultra at $19/month for 20,000, or Mega at $49/month for 100,000. You pay for volume, not for access.

The listing is here: https://rapidapi.com/darksundarker/api/digitproof

Feedback very welcome, especially the "I wish it also validated X" kind. That is how the next identifier on the list gets chosen.

SynthForge: fake test data with deterministic seeds, custom schemas, and SQL output

DSP — Mon, 26 Oct 2026 04:11:47 +0000

Seeding a database with user1, user2, test@test.com works right up until your UI has to render a real-looking name, your demo needs 500 believable products, or your test suite needs the same dataset on every run, not a fresh snowflake each time.

SynthForge is a synthetic data API we built at DSP to fix that. It's live on RapidAPI with a free tier.

Predefined generators

Seven generators, up to 1,000 records per call: person, company, address, product, user, payment-card, and internet, covering names, safe emails, phones, job titles, SKUs, prices, usernames, IPs, UUIDs, and the rest of the usual test-data furniture.

Payment cards deserve a specific mention: numbers come only from the standard public test ranges (Visa 4242…, Mastercard 5555…, Amex, Discover), are Luhn-valid so your validators accept them, and every record is flagged "test_only": true. They will never work for a real purchase, by design.

The headline: bring your own schema

Describe the shape you want using any of 38 field generators, and get back exactly that shape:

curl -X POST https://synthforge.p.rapidapi.com/v1/generate/schema \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"schema": {"id": "uuid", "name": "product_name",
                  "price": "price", "city": "city", "zip": "zip_code"},
       "count": 2, "seed": 7}'

[{"id": "6513270e-269e-4d37-b2a7-4de452e6b438", "name": "Premium Lamp",
  "price": "395.03", "city": "North Loriville", "zip": "48432"},
 {"id": "81e74ef5-e8e2-4d94-8ed9-04759531985d", "name": "Modular Blender",
  "price": "59.99", "city": "North Christopher", "zip": "55311"}]

Output formats: JSON, CSV, or SQL INSERT statements, so generated data can go straight into a seed file.

Seeds make it deterministic

Every endpoint accepts a seed. Same seed, same data, byte for byte, seed 42 on the person generator gives you Margaret Johnson today, tomorrow, and in CI. That's the difference between a flaky fixture and a reliable one.

Locales are supported where they make sense (en_US, en_GB, de_DE, fr_FR, es_ES, ja_JP), and emails use safe, non-deliverable addresses.

Pricing

Every endpoint is available on every plan, including the free tier. All seven predefined generators and the custom schema endpoint are included from the start, with no Pro-only generators and no output format held back to force an upgrade. Upgrading simply gets you more requests per month: start free with 150 requests a month, move up to Pro at $4/month for 5,000, Ultra at $9/month for 20,000, or Mega at $24/month for 500,000. And since a single request can generate up to 1,000 records, even the free tier goes a long way. You pay for volume, not for access.

Try it: https://rapidapi.com/darksundarker/api/synthforge

What generator is missing for your use case? That's the v1.1 backlog, and it's being written by whoever asks.

Messy data in, clean records out: RecordScrub, a data-cleaning API

DSP — Mon, 26 Oct 2026 04:03:46 +0000

Every project eventually inherits the same spreadsheet: emails in three different cases, phone numbers formatted six ways, names like "DOE, john michael", and the same customer entered twice. Cleaning it by hand, or with a pile of regexes you don't quite trust, is nobody's favorite afternoon.

RecordScrub is a small API we built at DSP to do that job in one call. It's live on RapidAPI now, with a free tier.

What it does

Email validation & normalization, single or batch, with valid/invalid stats and a plain-language reason for every rejection
Phone normalization to E.164, powered by Google's libphonenumber, so (312) 555-0142 becomes +13125550142
Name normalization, "DOE, john michael" → John Michael Doe, with first/last split out
US address normalization, state codes, ZIP+4, standardized street suffixes
Batch record cleaning, send CSV-style records, get snake_case keys, per-field cleaning, and exact dedupe on the fields you choose, with a duplicate report showing what was dropped and why

Every dropped or altered value comes back with a _warnings explanation. No silent data loss.

A taste

curl -X POST https://record-scrub.p.rapidapi.com/v1/normalize/phone \
  -H "X-RapidAPI-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"phone": "(312) 555-0142"}'

{"original": "(312) 555-0142", "normalized": "+13125550142",
 "valid": true, "country_code": 1, "national_format": "(312) 555-0142"}

And the batch cleaner, deduplicating on email + phone:

{"records": [{"name": "John Doe", "email": "john@example.com",
              "phone": "+13125550142"}],
 "stats": {"received": 2, "returned": 1, "duplicates_removed": 1},
 "duplicates": [{"index": 1, "duplicate_of": 0, "record": { "...": "..." }}]}

How it's built

FastAPI, completely stateless. Requests are processed in transit and nothing is stored, so there's no database to leak from. It runs on a free-tier host, so the first call after a quiet spell can take a few extra seconds while it wakes up; after that it's fast.

Pricing

Every endpoint is available on every plan, including the free tier. No feature gates, no Pro-only cleaners, no endpoint held back to force an upgrade. Upgrading simply gets you more requests per month: start free with 100 requests a month, move up to Pro at $10/month for 5,000, and scale from there if your batch volume grows. You pay for volume, not for access.

Try it: https://rapidapi.com/darksundarker/api/record-scrub

Feedback very welcome, especially the "I wish it also cleaned X" kind. That's how the v2 list gets written.