← SKU Monster · Blog
August 14, 2026 · SKU Monster

You loaded 2,000 SKUs into your Amazon or eBay bulk template, hit submit, and watched a wall of errors come back: invalid product ID, GTIN does not match, UPC already in use. Now you're re-checking rows by hand while your listings sit dead. Most of that pain is avoidable — bad GTINs are cheaper to catch before upload than to untangle after a rejected feed.

This guide walks through how to validate barcodes properly, why marketplace rules make it non-negotiable, and how to enrich clean records so your bulk upload lands on the first try.

What You'll Learn

Why Bad GTINs Break Bulk Uploads

Marketplaces treat the GTIN as the primary key for catalog matching. Amazon requires a GTIN for listings in most categories, and books need an ISBN, EAN, or JAN; listing without a valid identifier can trigger an error. eBay's UPC field must be numeric, up to 12 digits, and valid and registered — an 8-digit GTIN-8 or UPC-E may only be accepted if it's genuine and registered.

The rules also close off your escape hatches when the data is wrong. Amazon says GTIN exemptions are not available when a GS1-approved barcode already exists on the product or packaging, so a bad or duplicate GTIN can actually block the exemption path you were counting on. And misstated product IDs are not allowed — sellers are instructed to use the correct GTIN for the exact item being listed, not a close-enough substitute.

Because many Amazon categories carry their own UPC/GTIN rules, one bad barcode often means category-specific rework rather than a single global fix. Multiply that across a bulk feed and a small data-quality problem becomes hours of manual triage.

The Validation Checks Every Barcode Should Pass

Before any barcode goes into an upload template, it should clear a short, mechanical set of checks. None of these require guessing — they're deterministic rules you can automate.

1. Format and length. A GTIN-13 (EAN) is 13 digits, a GTIN-12 (UPC-A) is 12, and GTIN-8 is 8. Strip whitespace, leading apostrophes from spreadsheet exports, and any non-numeric characters. eBay in particular expects the UPC field to be numeric and up to 12 digits, so a stray letter or a scientific-notation number from Excel (4.0069E+12) will fail.

2. Check digit. Every GTIN's final digit is a mod-10 checksum computed from the preceding digits. A checksum failure means the number is simply invalid — it was never a real GTIN, or it got corrupted somewhere in your pipeline. This is the single highest-value check because it catches typos and truncation instantly.

Here's the checksum logic in plain Python so you can run it on a column before you ever call an API:

def gtin_check_digit_valid(code: str) -> bool:
    code = code.strip()
    if not code.isdigit() or len(code) not in (8, 12, 13, 14):
        return False
    digits = [int(c) for c in code]
    check = digits.pop()
    digits.reverse()
    total = sum(d * (3 if i % 2 == 0 else 1)
                for i, d in enumerate(digits))
    return (10 - (total % 10)) % 10 == check

3. Real-world existence. A number can pass the checksum and still not correspond to a real, registered product. This is where a lookup step earns its keep: confirming the GTIN actually resolves to a known item, brand, and category before you commit it to a listing.

4. Match to the exact item. Amazon requires the GTIN for the exact item being listed. If you're reselling and pulled a barcode off a similar-looking product, the identifier may resolve — but to the wrong variant, size, or pack count. Confirm the resolved product name and specs match what you're actually shipping.

Catching Duplicate and Mismatched UPCs Across Variations

Variation data is where bulk uploads quietly go wrong. eBay expects a unique UPC per variation, or the UPC field left blank — you cannot reuse one parent barcode across every child. If your export has the same UPC repeated across five sizes, the feed will either reject or collapse them incorrectly.

Run two extra passes on any variation set:

Doing this cleanup before upload is far cheaper than relisting after a rejection, because GTINs are tied to product packaging and catalog matching — the marketplace validates them at ingest, not after.

Using a Lookup API to Confirm GTINs Resolve

Once your barcodes pass format and checksum checks, the next step is confirming each one maps to a real product with the right details. SKU Monster's product lookup does exactly this: give it a barcode and it returns structured product data — name, brand, category, and specs — that you can compare against your intended listing.

There's a free lookup on the home page at sku.monster that needs no account, which is handy for spot-checking a handful of suspect rows. For a full feed, use the API. A single lookup uses the barcode endpoint:

GET /api/v1/barcode?code=0000000000000
x-api-key: <your-key>

An illustrative shape of what a lookup returns (generic identifier, fields only):

{
  "identifier": "0000000000000",
  "name": "...",
  "brand": "...",
  "category": "...",
  "specs": { }
}

When a lookup comes back empty or the returned product doesn't match your item, that's your signal to fix the row before upload — not after. For large catalogs, the /api/v1/batch endpoint lets you process many barcodes in one pass, so you can validate an entire feed instead of checking rows one at a time. Full request and response details live in the API docs.

A useful side effect: because SKU Monster also generates clean, white-background studio images and structured specs from the barcode, the same validation pass that confirms a GTIN is real can also hand you the listing content — images and data — for the SKUs that check out. Compared with traditional product photography that can run $250–$1,500 per SKU, generating that content during validation is a meaningful shortcut.

A Pre-Upload Validation Workflow

Put it together as a repeatable pipeline you run on every feed:

  1. Normalize the barcode column — strip formatting, fix Excel scientific notation, pad or reject wrong lengths.
  2. Checksum every GTIN with the mod-10 rule; drop or flag failures.
  3. Deduplicate across variation rows; enforce unique-or-blank UPCs.
  4. Resolve each surviving GTIN via /api/v1/barcode (or /api/v1/batch for volume) and confirm the product matches your item.
  5. Split your feed into clean rows to upload and flagged rows to fix.
  6. Enrich the clean rows with the returned specs and generated images so the listing is upload-ready.

Run steps 1–3 locally in seconds, then use the API for the resolution and enrichment steps that need real product data.

Summary

To validate barcodes before bulk upload, run every GTIN through format, checksum, and duplicate checks, then confirm each one resolves to the exact product you're listing. Marketplace rules — Amazon requiring a valid GTIN in most categories, eBay requiring a numeric, registered, unique UPC per variation — mean a single bad barcode can block a listing or an exemption. Catching and fixing bad GTINs before you submit is dramatically faster than reworking rejected feeds. A barcode lookup step turns validation from guesswork into a deterministic, batchable pass over your whole catalog.

Ready to Try It?

Start validating and enriching your catalog with clean, verified product data. Create an account and try SKU Monster — pay $2 per SKU with no subscription, or run a free lookup first on the home page.

← More posts