DEV Community: Your Evenings Data

Build a GTIN fix list for your Shopify store before Merchant Center flags it (Python)

Your Evenings Data — Fri, 23 Oct 2026 09:11:17 +0000

If you sell on Google from Shopify, you've probably seen a GTIN issue in Merchant Center, or a "Missing GTIN or MPN" error in Shopify's Google & YouTube channel. Merchant Center tells you which products are affected after the feed is processed. This post builds the check you can run before: one CSV row per variant whose barcode won't pass as a GTIN, with the reason.

It needs nothing but Python, requests and your store's public storefront JSON. No app, no admin API token.

What Google actually checks

From Google's GTIN help page and product data specification:

Length: 8, 12, 13 or 14 digits (GTIN-8, UPC-A, EAN-13/JAN/ISBN-13, GTIN-14). Spaces and dashes are ignored.
Check digit: the last digit must match the GS1 check-digit calculation.
Not in a restricted range: Google rejects prefixes 02, 04 and 2. GS1 reserves these for restricted circulation, such as codes a store prints itself.
Not a coupon: Google's GTIN page lists the coupon prefixes as 05, 98 and 99.
Don't invent one. Store-brand, custom or handmade products often have no GTIN, and that's allowed. Google and Shopify both say to leave it empty and give brand and MPN instead. A made-up GTIN is worse than none.

In Shopify, the GTIN is the variant's Barcode field (Products → product → Inventory). For products without a barcode, Shopify's Google & YouTube channel lets you add brand and MPN.

The catch: barcodes aren't in /products.json

Most Shopify storefronts serve /products.json, but it leaves out variant barcodes. Each product's own /products/{handle}.json has them. So the script does two passes: page through /products.json (250 per page) to collect handles, then fetch every product's JSON. That's one request per product, so a 1,000-product store takes a while at a polite one request per second. Run it overnight or on a schedule, not in a request handler.

The script

import csv, time, requests

STORE = "https://your-store.com"      # your storefront domain
UA = {"User-Agent": "gtin-fix-list/1.0"}

def gtin_problem(raw):
    """None if the barcode looks like a usable GTIN, else a short reason."""
    if not (raw or "").strip():
        return "empty"
    d = "".join(ch for ch in raw if ch.isdigit())
    if d != raw.replace(" ", "").replace("-", ""):
        return "not numeric"
    if len(d) not in (8, 12, 13, 14):
        return f"{len(d)} digits"
    body, check = [int(x) for x in d[:-1]], int(d[-1])
    total = sum(n * (3 if i % 2 == 0 else 1) for i, n in enumerate(reversed(body)))
    if (10 - total % 10) % 10 != check:
        return "bad check digit"
    if len(d) >= 12:
        g13 = d.zfill(13)[-13:] if len(d) < 14 else d[1:]
        if g13.startswith(("02", "04", "2")):
            return "restricted range (02/04/2)"
        if g13.startswith(("05", "98", "99")):
            return "coupon range (05/98/99)"
    return None

handles, page = [], 1
while True:
    r = requests.get(f"{STORE}/products.json", params={"limit": 250, "page": page}, headers=UA, timeout=20)
    r.raise_for_status()
    batch = r.json()["products"]
    if not batch:
        break
    handles += [p["handle"] for p in batch]
    page += 1
    time.sleep(1)

rows = []
for h in handles:                     # one request per product: barcodes aren't in /products.json
    p = requests.get(f"{STORE}/products/{h}.json", headers=UA, timeout=20).json()["product"]
    for v in p["variants"]:
        problem = gtin_problem(v.get("barcode"))
        if problem:
            rows.append({"handle": h, "product": p["title"], "variant": v["title"],
                         "sku": v.get("sku") or "", "barcode": v.get("barcode") or "",
                         "problem": problem, "vendor": p["vendor"]})
    time.sleep(1)

with open("gtin-fix-list.csv", "w", newline="") as f:
    w = csv.DictWriter(f, fieldnames=list(rows[0]) if rows else ["handle"])
    w.writeheader()
    w.writerows(rows)
print(f"{len(handles)} products checked, {len(rows)} variants to review -> gtin-fix-list.csv")

How the GTIN check works:

The check digit is the standard GS1 one. Working right to left (excluding the check digit), multiply digits alternately by 3 and 1, add them up, and the check digit is whatever brings the total to the next multiple of 10.
For range checks, 12-digit UPCs are left-padded to 13 digits (a UPC starting with 2 becomes 02…), and 14-digit codes drop the leading indicator digit. GTIN-8 prefixes follow different rules, so the script skips range checks for them.

Reading the fix list

Sort gtin-fix-list.csv by problem, and treat each kind differently:

problem	What it usually means	What to do
`empty`	No barcode entered. Often fine for own-brand or custom products	If the product has a manufacturer GTIN, add it. If it doesn't, add brand + MPN in the Google channel instead
`bad check digit`	A typo or a truncated code	Copy the barcode from the packaging or the supplier's data again
`N digits` / `not numeric`	An SKU or internal code pasted into Barcode	Move it to SKU, and put the real GTIN (or nothing) in Barcode
`restricted range`	An in-store code, not a trade GTIN	Remove it, or replace it with the real GTIN
`coupon range`	Wrong code copied from somewhere	Find the product's real GTIN

Two limits to keep in mind: a valid-looking GTIN can still belong to a different product (only GS1 data or the packaging can confirm it), and Merchant Center can disapprove products for reasons that have nothing to do with GTINs (price or availability mismatches, images, policy). Fix what Merchant Center's Needs attention tab reports first. Use this list to stop the GTIN issues coming back.

Make it a habit

Run it weekly and diff the CSV against last week's. New rows usually mean a new supplier import or a bulk edit went wrong, which is much easier to fix the day it happens than after Google re-reviews the feed.

The one-call version (disclosure: we built this)

We packaged a broader version of this as a pay-per-use Apify Actor: Shopify Products Scraper & AI Shopping Readiness Audit.

Catalogue export plus audit. You get one row per product, and one audit row per store that scores GTIN check digits, descriptions, product type, vendor, image alt text, SKUs, missing images and duplicate titles. Each check gets a weight and a 0–100 score, with example handles to fix first.
The same GTIN checks on every variant. Turn on readAllProductDetails, and every variant's barcode is marked valid, missing, invalid (wrong length or check digit) or duplicate (the same code on another variant; a 12-digit UPC and the same code as a 13-digit EAN count as one). The run writes a BARCODE-ISSUES CSV with only the problem variants: in effect, the fix list above. Unlike the script, it doesn't check the restricted and coupon prefix ranges. It reads about one product per second, so give big catalogues a longer run timeout. Example input: Find Shopify variants with missing or invalid barcodes.
GTINs on a sample by default. Without that option, it checks an evenly spread sample (20 products by default, up to 250), which keeps the readiness score fast on big stores.
Whole catalogues. It reads past Shopify's 25,000-product feed limit using the store's sitemap, collection feeds and product pages, and it says whether the catalogue was read completely. Very large catalogues (above about 20,000 products) need a run timeout longer than the default 300 seconds.
No silent zeros. A store that isn't Shopify, is password-protected or disallows robots gets a free status row with a note.

It reads public storefront data only. It can't see your Merchant Center account, and a good score doesn't guarantee approval.

More on Merchant Center disapprovals and a quick sampled audit: Shopify product feed audit.

Prices are on the Actor's Pricing tab.

What's the most common barcode mistake you've seen in a Shopify catalogue? Tell us in the comments.

Get only the jobs you want from Greenhouse, Lever and Ashby boards (and prove you didn't miss any)

Your Evenings Data — Thu, 22 Oct 2026 09:00:47 +0000

Two complaints come up again and again with job scrapers:

"My filter didn't work": remote-only returned office jobs, a title search returned one result, a date filter did nothing.
"I got fewer jobs than I expected": was that everything, or did something break?

Both problems have the same cause: you can't see what happened between "the company's board" and "my spreadsheet". This post shows how to filter public ATS job boards so you can check the result, first by hand in Python and then with a one-call version.

Part 1: the DIY way

Greenhouse, Lever and Ashby all publish keyless JSON job boards, but none of them filters on the server. You download the whole board and filter it yourself:

import re, requests
from datetime import datetime, timedelta, timezone

def greenhouse(token):
    r = requests.get(f"https://boards-api.greenhouse.io/v1/boards/{token}/jobs", timeout=20)
    r.raise_for_status()
    return [{"id": j["id"], "title": j["title"], "location": j["location"]["name"],
             "posted": j.get("first_published")} for j in r.json()["jobs"]]

def word_match(text, words):
    return any(re.search(rf"\b{re.escape(w)}\b", text or "", re.I) for w in words)

jobs = greenhouse("stripe")
cutoff = datetime.now(timezone.utc) - timedelta(days=7)
keep = [j for j in jobs
        if word_match(j["title"], ["engineer", "engineering"])
        and word_match(j["location"], ["London"])
        and (j["posted"] is None or datetime.fromisoformat(j["posted"]) > cutoff)]
print(f"{len(jobs)} on the board, {len(keep)} kept, {len(jobs) - len(keep)} filtered out")

Three details matter more than the code:

Match whole words, and list both forms. engineer shouldn't match "Engineering Manager" unless you want it to, so add engineering explicitly. Most "title search returns one result" complaints are an exact-phrase search on a title nobody uses.
Use the right date field. On Greenhouse, updated_at changes whenever the board re-syncs, often for hundreds of jobs at once. Use first_published for "posted in the last N days". On Lever it's createdAt (epoch milliseconds); on Ashby it's publishedAt.
Always print the board total next to your result. "7 jobs" means nothing on its own. "7 of 729, 722 filtered out" tells you the filter ran and the board was read in full.

Then add the same for Lever (api.lever.co/v0/postings/{slug}?mode=json, a bare array, remote via workplaceType) and Ashby (api.ashbyhq.com/posting-api/job-board/{slug}, isRemote). Map each to the same fields, and you have the whole thing. It's very doable for a handful of companies. If you don't know a company's board token yet, here's how to find it from its careers page.

Part 2: the one-call version

Disclosure: we built this. Greenhouse, Lever & Ashby Jobs API on Apify does the above for a list of company domains across seven ATSs (Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee and, since 22 Oct 2026, Workday). It doesn't cover Personio or iCIMS yet. Filters run before anything is returned or charged.

{
  "companies": ["stripe.com"],
  "titleKeywords": ["engineer"],
  "locations": ["London"]
}

When I ran exactly that on 22 Oct 2026, Stripe's board had 729 open jobs and 7 matched. The cost was one company-resolved event plus 7 job events (about $0.016, against about $1.46 for all 729). Your numbers will differ, because boards change daily.

Other runs from the same morning:

Input	Board total	Returned
`stripe.com`, `titleKeywords: ["engineer"]`, `excludeTitleKeywords: ["senior","staff","intern"]`	729	104
`https://jobs.lever.co/spotify`, `remoteOnly: true`	80	27
`figma.com` + Spotify's Lever board, `postedWithinDays: 14`	139 + 80	17 + 16
`stripe.com`, `titleKeywords: ["xyzzy-no-such-title"]`	729	0, with a `no_matching_jobs` row saying so (only the company-resolved event charged)

Proving you got everything

Every job row carries companyTotalJobs, the board's open-job count before your filters. Every run also writes a COMPANY-STATUS CSV to the run's key-value store, linked from the Output tab, with one line per company you entered:

input,company,ats,boardToken,status,totalJobs,returned,filteredOut,note
stripe.com,Stripe,greenhouse,stripe,ok,729,7,722,"729 open jobs on the board; 7 matched your filters, 722 filtered out (not charged); 7 returned."

In normal mode, returned + filteredOut should equal totalJobs. When it doesn't, the note says why. For example, with maxJobsPerCompany: 3:

"729 open jobs on the board; 145 matched your filters, 584 filtered out (not charged); 3 returned. 142 matching jobs not returned: capped by maxJobsPerCompany (3)."

Companies it can't find get a not_found line, free of charge, instead of silently disappearing from your results.

How the filters match (so they don't surprise you)

titleKeywords / excludeTitleKeywords: case-insensitive whole words or phrases.
locations: whole words in the board's location text. A few country spellings are grouped (for example United Kingdom/UK/England), but cities aren't inferred, so United Kingdom won't match a job listed only as "London". List both if you want both. Remote also matches jobs the board flags as remote.
remoteOnly: the board's remote flag, or "remote" in the location or title. Hybrid jobs aren't included.
postedWithinDays: counts back from each run, so a saved or scheduled run never goes stale. Jobs whose board gives no date are kept and flagged postedAtUnknown: true. Turn off keepJobsWithoutPostedDate to drop them.
All filters combine with AND; the values inside one filter combine with OR.

Make it a daily feed

Turn on monitorMode with the same filters and schedule the run daily. You'll get only jobs that were opened or closed since the last run and match your filters. A company with no changes returns one cheap no_change row. Failed or partial reads are flagged (fetch_failed or partial), never shown as removals.

Prices at the time of writing: $0.002 per job returned, $0.002 per company resolved, $0.00005 per run start, with Silver and Gold plan discounts. The Actor's Pricing tab is authoritative.

Greenhouse jobs API: get jobs posted in the last 24 hours (and why your scraper returns 0 jobs)

Your Evenings Data — Thu, 22 Oct 2026 08:25:16 +0000

If you've searched "greenhouse jobs scraper date filter not working" or "greenhouse API jobs posted last 24 hours", here's the short version: Greenhouse's public job-board API has no date parameter, and neither do Lever's or Ashby's public endpoints. Any date filter you've used was applied after the jobs were downloaded. When it misbehaves, it's that layer, not the job board.

The endpoints are free and public, and getting "new jobs since yesterday" right takes three small habits.

The free endpoints

You need the company's board token, which is usually the slug in its careers URL.

ATS	Endpoint
Greenhouse	`https://boards-api.greenhouse.io/v1/boards/{token}/jobs?content=true`
Lever	`https://api.lever.co/v0/postings/{token}?mode=json` (EU companies: `api.eu.lever.co`)
Ashby	`https://api.ashbyhq.com/posting-api/job-board/{token}?includeCompensation=true`

import requests
jobs = requests.get("https://boards-api.greenhouse.io/v1/boards/airbnb/jobs").json()["jobs"]
print(len(jobs), jobs[0]["title"], jobs[0]["first_published"])

Habit 1: filter on the publish date, not the update date

Each Greenhouse job carries both first_published and updated_at. updated_at changes every time the employer edits the post, so "updated in the last 24 hours" is not "new in the last 24 hours". Filter on first_published:

from datetime import datetime, timedelta, timezone
cutoff = datetime.now(timezone.utc) - timedelta(days=1)
new_today = [j for j in jobs if j.get("first_published")
             and datetime.fromisoformat(j["first_published"]) > cutoff]

The equivalents are Lever's createdAt (milliseconds) and Ashby's publishedAt.

Habit 2: for alerts, diff job IDs

Dates can be missing, and a reposted job gets a fresh date. For a daily alert, the most reliable test is "which job IDs weren't there yesterday?":

new_ids = {j["id"] for j in jobs} - set(yesterdays_ids)
closed_ids = set(yesterdays_ids) - {j["id"] for j in jobs}

Habit 3: never accept a silent zero

When a company comes back with 0 jobs, it's usually one of these:

Wrong token. stripe.com isn't a token. Most ATSs 404 on a bad token, but some return HTTP 200 with an empty list, which looks exactly like "not hiring".
Wrong ATS. The company switched systems. Look for boards.greenhouse.io, jobs.lever.co or jobs.ashbyhq.com links on its careers page.
Unsupported system. Workday, iCIMS and in-house careers pages don't use these endpoints.
Over-tight filters. An exact title like "Head Marketing" misses "Head of Marketing". Match keywords with word boundaries instead.

Log a reason for every company that returned nothing, and record the board's total next to what you kept. That way "0 matched my filters" and "0 because the board wasn't found" never look the same.

Duplicates

The same role posted in three cities is often three job IDs. Decide whether you want one row per posting or per role. If per role, key on (company, normalised title, location). Across days, dedupe on job ID.

The one-call version (disclosure: we built this)

We packaged all of the above as a pay-per-use Apify Actor: Greenhouse, Lever & Ashby Jobs API.

Domains in, jobs out. Give it ramp.com, a careers URL or ats:token. It finds the board across Greenhouse, Lever, Ashby, Workable, SmartRecruiters, Recruitee and Workday, and returns one schema: title, department, location, isRemote, postedAt, posted salary (only when the employer publishes it), job URL and apply URL. It reads each board live on every run.
Filters applied before you're charged: titleKeywords, excludeTitleKeywords, locations, remoteOnly, departments and postedWithinDays. Jobs that don't match are never returned or charged.
Proof you got the whole board. Every job row carries companyTotalJobs, the board's open-job count before filters and limits. Each run also writes a COMPANY-STATUS CSV with one line per input: status, total, returned, filtered out, and a note.
No silent zeros. Companies it can't find get a not_found row with a reason, and they're free. A board where nothing matched gets no_matching_jobs and its total.
New since yesterday. Turn on monitorMode and schedule it daily for changeType: "new" and "removed" rows, diffed by job ID.

from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("yourevenings/careers-jobs-api").call(run_input={
    "companies": ["stripe.com", "ramp.com", "https://jobs.lever.co/spotify"],
    "titleKeywords": ["engineer"],
    "locations": ["London"],
    "postedWithinDays": 1,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["recordType"], row["company"], row.get("title"), row.get("companyTotalJobs"), row.get("note"))

In a test run this morning with an engineer, London, last-30-days filter, one board returned 1 matching job out of 726 open roles, with the other 725 filtered out and not charged. A second board reported no_matching_jobs with its total of 170, and a made-up domain came back not_found at no charge.

It costs $0.002 per job returned and $0.002 per company resolved. Companies it can't find are free. Ready-made inputs: Which ATS does a company use? · Greenhouse board export · Posted salary ranges.

All four public endpoints (Greenhouse, Lever, Ashby and Workday), with their date fields and gotchas, are on one reference page: Greenhouse, Lever, Ashby and Workday jobs API.

Notes

Not covered yet: iCIMS, SuccessFactors and in-house careers sites. Those return not_found, and you're not charged. (Workday was added on 22 Oct 2026. Its posted dates are approximate, because Workday's listing only says "Posted 3 Days Ago".)
Jobs without a published date are kept by default when you set postedWithinDays, flagged postedAtUnknown: true. Set keepJobsWithoutPostedDate: false to drop them.
The tool drops recruiter contact details and strips emails and phone numbers from descriptions. Using job data is your responsibility under the terms and laws that apply to you.

Which ATS do your target companies use? Tell us in the comments.