You have a spreadsheet of barcodes from a wholesale manifest or a supplier feed, and a marketplace listing that needs a name, brand, category, specs, and images before it can go live. Doing that by hand — Googling each SKU, hunting for a usable photo, retyping specs — is the slowest part of building a catalog. This guide shows you how to turn that manual grind into a repeatable Python pipeline: barcodes in, catalog out.

What You'll Learn

• How to structure a product enrichment pipeline that takes GTINs and returns listing-ready data
• Which SKU Monster API endpoints to call for lookup, image generation, and bulk processing
• How to handle the parts marketplaces are strict about (white backgrounds, resolution, per-platform rules)
• How to batch thousands of barcodes without hand-rolling your own rate limiting
• Where the honest limits are, so you build something that actually works

The Problem: A Barcode Is Not a Listing

A barcode is an identity, not content. To publish a product you need a title, a brand, a category, structured attributes, and — the hardest piece — clean images that pass each marketplace's rules.

Those rules are unforgiving. Amazon and Walmart both require primary images on a pure white background (RGB 255,255,255), a minimum around 2000 x 2000 pixels so zoom works, and the product filling most of the frame — at least 85%. Walmart in particular penalizes listings with non-white backgrounds, visible shadows, low resolution, or watermarks, and will reject the listing outright. And the rules conflict across platforms: an image that looks great on Etsy can violate Amazon's clinical standard, while apparel platforms may demand on-model photography that other categories forbid as a primary image.

Traditional product photography solves this at $250–$1,500 per SKU. That math falls apart the moment you're onboarding a few hundred items. A pipeline is how you make it scale.

What the Pipeline Does

SKU Monster turns a barcode (EAN / UPC / GTIN) into five studio-quality product images plus full product specs and pricing. It's an automated pipeline that finds and generates clean, white-background images and structured data — not a shelf of pre-shot photos you're browsing. At $2 per SKU with no subscription, it slots directly into a script.

Your pipeline has three stages:

1. Lookup — resolve each barcode to a product record (name, brand, category, specs).
2. Images — generate the studio image set for each identifier.
3. Output — normalize everything into whatever your storefront or PIM expects.

Before writing code, grab a key from the dashboard and skim the API docs. There's also a free lookup on the home page if you want to eyeball the data quality for a few of your own barcodes first — no account needed.

Stage 1: Lookup

The core endpoint is GET /api/v1/barcode?code=<ean>. It returns the product name, brand, category, specs, and images for a single GTIN. Every request carries your key in the x-api-key header.

import requests

BASE = "https://sku.monster/api/v1"
HEADERS = {"x-api-key": "YOUR_KEY"}

def lookup(code):
    r = requests.get(
        f"{BASE}/barcode",
        params={"code": code},
        headers=HEADERS,
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

record = lookup("0000000000000")

The response is a structured product object. The exact shape is documented, but illustratively it groups fields into product data (name, brand, category, specs) and a set of image references. Treat the field names in the docs as the source of truth rather than anything you assume here — build your parsing against the real schema.

A practical tip: keep the raw response. Storing the full JSON per SKU means you can re-map fields later when you add a new sales channel without re-querying.

Stage 2: Images

If you want to generate or refresh the studio image set for an identifier, use POST /api/v1/images (or POST /api/v1/studio for a studio image job). This is where the white-background, studio-quality set comes from — the part that would otherwise cost you a photographer and a light tent.

def generate_images(identifier):
    r = requests.post(
        f"{BASE}/images",
        json={"identifier": identifier},
        headers=HEADERS,
        timeout=120,
    )
    r.raise_for_status()
    return r.json()

Because you get a set of five images, you have room to assign roles in your own mapping layer — a main shot plus alternates — rather than shooting each asset type separately. Remember the marketplace rules differ: most platforms want a 1:1 primary image, fashion often wants 3:4, and file-size ceilings vary (Amazon around 10MB, Walmart around 5MB, Etsy around 1MB per current guidelines — always confirm the destination's live spec before you publish).

That's why a smart pipeline keeps the largest available asset as a master and derives per-platform crops and compressions from it, instead of locking itself into a single output size. Check each marketplace's current image policy rather than hard-coding numbers that change.

Stage 3: Go Bulk

One barcode at a time is fine for a demo. A real manifest has hundreds or thousands of lines. Use POST /api/v1/batch to bulk-process many barcodes in one job instead of hand-rolling a loop with your own concurrency and backoff.

def submit_batch(codes):
    r = requests.post(
        f"{BASE}/batch",
        json={"codes": codes},
        headers=HEADERS,
        timeout=300,
    )
    r.raise_for_status()
    return r.json()

codes = ["0000000000000", "0000000000001"]  # your GTIN list
job = submit_batch(codes)

When you do call per-SKU endpoints in a loop, read the rate-limits and errors docs and code defensively: retry on transient failures with exponential backoff, and log every barcode that doesn't resolve so a human can review it. Not every GTIN in a liquidation manifest is clean.

You can also check consumption programmatically. GET /api/v1/usage tells you what you've spent so you can budget a run — useful when each SKU is a known $2 and you're processing a large batch.

Wiring It Together

A minimal end-to-end shape for a small run looks like this:

def enrich(code):
    product = lookup(code)
    identifier = product.get("identifier", code)
    images = generate_images(identifier)
    return {
        "gtin": code,
        "product": product,
        "images": images,
    }

results = []
errors = []
for code in codes:
    try:
        results.append(enrich(code))
    except requests.HTTPError as e:
        errors.append({"gtin": code, "status": e.response.status_code})

From here, the last mile is your normalization layer: map SKU Monster's fields onto your Shopify, WooCommerce, Amazon, eBay, or Walmart schema, apply per-platform image crops and compression, and push. That mapping is where you encode each channel's quirks once and reuse them forever.

If you need pricing across regions or translated attributes for a marketplace, check the supported markets and languages via GET /api/v1/markets and GET /api/v1/languages and fold those into your output stage.

Summary

A product enrichment pipeline turns raw barcodes into publishable listings without manual research or a photo studio. In Python, that's three stages: resolve each GTIN with the barcode endpoint, generate a studio image set with the images or studio endpoint, and scale with batch. Keep the raw responses, derive per-platform image crops from a master asset, and log failed lookups for review. Compared with traditional photography at $250–$1,500 per SKU or manual data entry, a $2-per-SKU automated pipeline is what makes onboarding a full catalog realistic.

Ready to Try It?

Start building — create a key and run your first barcode. Feed it one GTIN, inspect the images and specs, then point your batch loop at the whole manifest.