DEV Community: ByteHarvester

73% of the Shopify stores I checked still load scripts that stop on 1 March 2027

ByteHarvester — Sat, 24 Oct 2026 11:29:08 +0000

Disclosure: I build Citebeam, and the free checker linked below is mine.

Shopify will stop injecting ScriptTags into storefronts on 1 March 2027. I wanted to know how many real stores still depend on them, so I measured it: of 45 public Shopify storefronts I checked, 33 (73%) still load at least one ScriptTag. I built a free checker for this at Citebeam, an independent Shopify app (not affiliated with Shopify). You paste a store address and it shows what will stop and what to ask your vendors. This post is the data behind it, and the two-minute manual version if you would rather not use any tool.

What is changing

From the Shopify developer changelog (published 24 August 2026):

Since 1 October 2026, apps can no longer create or update ScriptTags. scriptTagCreate and scriptTagUpdate return an error, and the REST resource rejects POST and PUT. This applies to all API versions, so pinning an old version does not defer it.
Existing ScriptTags keep running until 1 March 2027, when Shopify stops injecting them into storefronts.
The scriptTags query and scriptTagDelete still work, so apps can audit and clean up.
The replacements are app embed blocks in a theme app extension (for general JavaScript) and web pixels (for analytics and conversion tracking only).

This covers ScriptTags scoped to the online store. Scripts on the order status page fall under a separate, earlier deprecation.

How I measured it

45 stores: one theme demo store plus 44 drawn at random from a list of live stores (30 on custom domains, 14 on *.myshopify.com).
For each store I fetched only what any visitor can fetch: robots.txt, the public home page, and /account/login (only where robots.txt allows it). Honest user agent, robots.txt respected, no retries, no proxy.
Shopify injects ScriptTags into the page head as an asyncLoad function with a var urls = [ ... ] list. That list parsed as JSON on all 33 pages that have it. I counted the URLs in it.

Limits, so you can weigh the numbers: I looked at the home page only, so scripts that load on other page types are not counted. The sample is small, and it leans toward smaller stores. The list shows what a store injects, not which app owns it, so I can only name the host a script is served from. I could not compare against any store's admin.

What I found

33 of 45 stores (73%) inject at least one ScriptTag. 12 (27%) have none.
95 ScriptTag URLs in total. Among the stores that have any: median 2, mean 2.9, max 11 in a single store.
29 of 45 stores (64%) also load at least one theme app embed asset, so many stores are mid-way: some apps already moved, some did not. 26 stores have both.
Most common hosts the scripts are served from, by number of stores: nfcube.com 8, chimpstatic.com 6, hextom.com 5, and trustpilot.com, avada.io and printful.com 3 each. Another 25 or so domains appear once: chat, reviews, pop-ups, back-in-stock, email capture, upsell, affiliate and analytics apps.

A script served from a vendor's domain does not mean that vendor has not migrated. Many vendors already offer an app embed, and the old ScriptTag may just be a leftover. For any domain you see, check with the vendor.

What actually breaks

A ScriptTag is how many older apps put something on your storefront without editing the theme: a pop-up, a chat bubble, review stars, a back-in-stock form, an upsell. When injection stops, whatever that script drew or did stops loading, unless the app has moved to an app embed. And even after a vendor ships an app embed, it is off until someone switches it on in the theme editor. A vendor saying "we migrated" and your storefront showing the widget are two separate facts.

Check your own store in two minutes (no tool needed)

Open your home page in a private window, view the page source (Ctrl+U or Cmd+Option+U).
Search for asyncLoad.
Right below it you will see var urls = [ ... ]. Every URL in that list is a ScriptTag. If the block is not there, you have none on the home page.
Look at the domains and match them to apps you installed. Theme app embeds look different (cdn.shopify.com/extensions/...) and do not appear in that list.

Or let the free checker do the reading: paste your store address, no sign-up. It makes two requests to your public storefront, lists the ScriptTags with the vendor host behind each, shows any theme app extensions, and checks the legacy account question below. It is free, and it only reads pages any visitor can open.

What to do about it

Ask each vendor which of its features use a ScriptTag today and what its plan is for 1 March 2027. You want to hear "app embed" or "theme app extension" and a date.
Switch on the app embed in the theme editor once the vendor ships it, and test the page.
Analytics and conversion scripts should move to a web pixel, which needs no action from the merchant.
If a vendor has no plan, you have until 1 March 2027 to replace the app, which is a lot easier in November than on 28 February.

One more deadline: legacy customer accounts

Shopify deprecated legacy customer accounts on 26 February 2026. The final sunset date is to be announced later in 2026. In my sample, 8 of the 43 stores I could read (19%) still showed the classic login form, the signal that a store is still on legacy accounts (the other 35 redirect to the new sign-in; 2 stores' robots.txt does not allow /account/login, so I did not fetch it). The checker reports this too.

If you look after more than one store

Agencies and freelancers can run the same check across a whole client list with the Apify actor Shopify Script Tag Checker. Give it a list of store domains (or a CSV link) and you get one row per store: a risk level, the ScriptTags and the vendor hosts behind them, the number of app embeds, whether the store is still on legacy customer accounts, and plain-English next steps. It checks a store for $0.01, so a 50-store client list is 50 cents, and stores it cannot check are free. It is going public on the Apify Store now.

You can see a public example run here: Will 20 Shopify stores break on 1 March 2027?. And here is a short YouTube walkthrough of the checker.

Your next step

Check one store now: free ScriptTag checker.
Run it on every client store: Apify actor.
Forward this to the person who installed the apps, and put "ask vendors about 1 March 2027" on this week's list.

The deadline is fixed and the vendor answers take time. A short list of questions sent today beats a broken storefront in March.

Written with AI assistance.

Where are the tech jobs in Germany? Jobs by city, remote share and salaries (22 October 2026)

ByteHarvester — Sat, 24 Oct 2026 06:51:56 +0000

Disclosure: I built the Apify Actors used to collect this data. This post was written with AI assistance.

München leads the German tech job market this week with 275 open software developer jobs on XING, ahead of Berlin (239). Across the ten biggest job cities, 421 of 1,452 software developer jobs were posted or refreshed in the last seven days. Of the newly posted or refreshed tech jobs in my sample, 9.9% are fully remote and 53.2% hybrid; only 35.3% show a salary published by the employer, and 54.3% carry only an estimate computed by XING.

If you are hunting for a developer, data or DevOps job in Germany, or benchmarking your own hiring, "which city, how much, how remote" is spread across thousands of ads. This report counts them from two job boards with the same searches every time, so changes between editions are real changes.

Software developer jobs by city

City	Software developer jobs open	Posted or refreshed in last 7 days	Data engineer jobs open	DevOps jobs open	Hybrid or remote share (new jobs)	Salary published by employer	Change in open software jobs
München	275	82	113	151	51.6%	43%	–
Berlin	239	63	150	205	63.8%	21.3%	–
Hamburg	187	40	80	145	65.2%	37.1%	–
Köln	147	38	76	102	59.7%	39.1%	–
Frankfurt am Main	137	39	70	130	77.5%	40.4%	–
Stuttgart	114	33	38	73	73%	43.2%	–
Nürnberg	114	43	16	59	69.3%	37.3%	–
Dresden	109	45	22	60	46.8%	17.2%	–
Düsseldorf	69	19	31	66	59.5%	39.3%	–
Leipzig	61	19	6	46	61.6%	30.8%	–

Each role column counts the jobs XING returns for that keyword in that city, so a job can appear in more than one role. Shares come from a sample of up to 20 new jobs per search; cities with fewer than 10 sampled jobs show n/a. The last column compares with the previous edition (this is the first edition, shown as a dash).

By role

Role (search keyword)	Open jobs in the 10 cities	Posted or refreshed in last 7 days	Fully remote / hybrid (new jobs)	Salary published	Median published salary (per year)
Data & AI ("data engineer")	602	203	2.9% / 53.6%	17.1%	€77,500
DevOps & cloud ("devops")	1,037	382	17% / 58.5%	55.3%	€80,000
IT security ("it-sicherheit")	1,038	343	11.6% / 57.8%	39.5%	€90,000
IT admin & support ("it-administrator")	1,482	438	7.6% / 59.4%	40.6%	€62,500
Software development ("softwareentwickler")	1,452	421	9.7% / 38.9%	23.8%	€70,000

On XING, "published" means the employer stated a salary in the ad; for most ads XING shows its own estimate instead, which I count separately and do not treat as a salary disclosure. The median uses published salaries with a yearly range between €20,000 and €300,000.

The second source: stellenanzeigen.de, the complete list

stellenanzeigen.de is a smaller board with fewer tech ads, which means I can read all of them. This week it listed 580 distinct tech jobs across 27 tech keywords, 177 of them posted in the last seven days. Home office is possible or full in 56.7% of them (1.2% fully remote), and 13.6% state a salary, with a median advertised yearly salary of €67,500 (61 ads with a yearly range).

Role	Jobs	Posted in last 7 days	Home office possible or full	Salary stated	Median salary (per year)
Data & AI	144	34	48.6%	9%	€80,000
DevOps & cloud	50	7	22%	6%	€75,000
IT security	55	23	65.5%	16.4%	€70,000
SAP & ERP	82	11	92.7%	8.5%	€80,000
IT admin & support	117	54	47.9%	18.8%	€56,770
Software development	132	48	60.6%	18.9%	€65,000

Most common workplaces on stellenanzeigen.de (a job with several workplaces counts for each city):

City	Jobs	Share of tech jobs
Hamburg	35	6%
Frankfurt am Main	25	4.3%
Dortmund	24	4.1%
Berlin	22	3.8%
Köln	19	3.3%
München	19	3.3%
Düsseldorf	14	2.4%
Finsterwalde	13	2.2%
Stuttgart	12	2.1%
Karlsruhe	12	2.1%

How this was measured

Sources: the XING Jobs Scraper and the stellenanzeigen.de Scraper on Apify, run on 2026-10-22 with fixed inputs: 5 role keywords ("data engineer", "devops", "it-sicherheit", "it-administrator", "softwareentwickler") in ten cities (Berlin, München, Hamburg, Frankfurt am Main, Köln, Stuttgart, Düsseldorf, Leipzig, Dresden, Nürnberg) on XING; 27 tech keywords across all of Germany on stellenanzeigen.de.
Counts: the open-job and new-job numbers on XING are the totals XING reports for each search at run time. The stellenanzeigen.de figures are counted from the complete list.
Samples: work mode and salary shares for XING come from up to 20 jobs per search posted or refreshed in the last 7 days (XING's own date filter) (801 distinct jobs in total), so read them as estimates of the new-job mix, not of every open ad.
What the keywords catch: a keyword search matches ads that mention the term, so some matches are only loosely related. The same searches run every week, which keeps editions comparable.
Aggregates only: no job titles, ad texts, company names or contact details are used or published here.

How to get this data yourself, every day

Everything above was collected by these Apify Actors from a fixed input, plus some arithmetic. You can run the same collection on your own Apify account in a couple of clicks:

XING Jobs Scraper: $0.80 per 1,000 results on the free plan, you pay only for results delivered.
stellenanzeigen.de Scraper: $1.20 per 1,000 results on the free plan, you pay only for results delivered.

Collecting the data for this edition costs about $1.92 on Apify's free plan (you pay per result delivered, nothing for a search that returns nothing), so a weekly refresh is about $8 a month.

Daily monitor in three steps:

Open the Actor, paste an input like the one below, and switch on Only new (onlyNew). The first run returns everything; every later run returns only what no earlier run of the same watch list delivered, and skipped items are not charged.
Save the input as a task and put it on a schedule (for example the cron expression 0 7 * * *, every day at 07:00 UTC).
Send the result where you work: e-mail, Slack or Google Sheets, from the task's Integrations tab.

{
  "keywords": [
    "softwareentwickler"
  ],
  "locations": [
    "Berlin"
  ],
  "maxListingsPerSearch": 100,
  "onlyNew": true,
  "monitorKey": "softwareentwickler-berlin"
}

This input is for the stellenanzeigen.de Scraper, which has the only-new switch (onlyNew plus a monitorKey that names your watch list). On the XING scraper, use Posted within (postedWithinDays: 1 or 7) with a daily schedule to get the same effect.

Want your own cut: your stack, your city, your salary band? Run the XING Jobs Scraper or the stellenanzeigen.de Scraper on Apify, type your keywords and towns, and get every job with its salary, work mode and posting date as a spreadsheet. The input forms are prefilled and the first run takes a minute.

Next edition: follow me here on dev.to for the next weekly count, and use the daily monitor above if you want new jobs in your inbox every morning.

EU customs identifiers from 1 Nov 2026: audit SKU coverage of many Shopify stores with one API call

ByteHarvester — Sat, 24 Oct 2026 06:50:03 +0000

If you look after more than one Shopify store, the EU customs deadline of 1 November 2026 is a catalog problem multiplied by your client list. The Shopify AI Readiness Audit on Apify answers the first, cheapest question for all of them in one call: how many variants in each store have a usable SKU, which SKUs are duplicated, and does the product page print a valid GTIN. It costs $0.01 per store (500 stores = $5), and stores it cannot read are free. Run it on your own list of stores. If you want to see it work first, open the ready-made EU customs ID check example task for 20 Shopify stores and press Start.

I am not giving legal advice, and I will say plainly what this can and cannot see further down. First, why SKUs are the right place to start.

Why SKUs, and why now

From 1 November 2026, EU customs declarations for online sales of goods to consumers need product identifiers for each item: your own product code, a manufacturer or supplier code, and a standardised code such as a GTIN where the product has one. For a Shopify merchant, your own product code is the variant SKU. A variant with no SKU, a placeholder such as N/A, or a SKU shared by several variants cannot identify anything.

For one store you fix that in a spreadsheet. For an agency with 40 clients, a developer building a catalog-cleanup service, or an analyst comparing a market, opening every store by hand does not scale. The public storefront already shows enough to size the job: every Shopify store that leaves it open serves its product list at /products.json, SKUs included.

What 1,071 stores looked like

In October 2026 we read the public data of 1,071 live Shopify stores (the first 50 products of each feed plus one product page). No store is named here. Two numbers matter for this deadline:

50.3% of products have at least one variant with no SKU. 79.6% of the stores have at least one such product.
8.4% of the stores print a GTIN in the Product JSON-LD of the product page we read. That is a lower bound, not the share of stores with barcodes: the public feed does not show barcodes, and a theme only prints one if it is set up to.

Half the products in that sample have a SKU gap. If your client list looks like the sample, a large part of it needs work before the deadline, and you want to know which part.

One API call for the whole list

The audit is an Apify Actor, so any language with an HTTP client can drive it. In Python, with the apify-client package (pip install apify-client):

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("highbrow_fame/shopify-ai-readiness-audit").call(
    run_input={
        "stores": [
            "theme-dawn-demo.myshopify.com",
            "client-one.example.com",
            "client-two.example.com",
        ],
        "maxProducts": 50,
    }
)

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["status"] != "ok":
        print(row["input"], row["status"])  # unreadable stores are free
        continue
    print(
        row["store"],
        row["euSkuCoveragePct"],
        row["euVariantsWithoutSku"],
        row["euDuplicateSkus"],
        row["euGtinInJsonLd"],
    )

Swap the list for your own, or pass csvUrl with a public link to a file with one store per line. Up to 5,000 stores fit in a run. You can also paste the same list into the Actor's input form on the Store page and download the rows as JSON, CSV or Excel, no code needed.

What one row looks like

This is the audit of Shopify's own demo store, theme-dawn-demo.myshopify.com (a store Shopify publishes for its free Dawn theme, so nobody's real shop), trimmed to the fields that matter here:

{
  "input": "theme-dawn-demo.myshopify.com",
  "status": "ok",
  "readinessScore": 95,
  "euSkuCoveragePct": 40.2,
  "euVariantsWithoutSku": 159,
  "euVariantsSampled": 266,
  "euDuplicateSkus": 0,
  "euGtinInJsonLd": true
}

Read it like this: 159 of the 266 sampled variants have no SKU (so 40.2% coverage), no SKU value is used twice, and the product page prints a GTIN with a valid check digit. The overall readiness score is 95 out of 100, because the other parts (product feed completeness, Product structured data, AI crawler access) are in good shape. The EU fields do not change that score, and that is the point: a store can look healthy and still have a SKU gap, and now the gap has its own columns. When SKUs are missing, one of the row's top-three fixes says so in plain English ("Give every variant its own SKU").

Sort the table by euSkuCoveragePct ascending and you have your work queue for the next days.

What it costs

$0.01 per store audited, charged only for stores with status ok.
20 stores = $0.20. 500 stores = $5. 1,000 stores = $10.
Stores that cannot be audited are free: product feed not public, robots.txt disallows it, blocked, rate limited, not a Shopify store, empty catalog.
Set a Maximum charge on the run and it stops cleanly when the budget is used up.

The honest caveat

This is a readiness proxy, not a customs check. The public product feed carries no barcodes and no manufacturer codes, so the Actor cannot tell you that a catalog is complete. A clean euSkuCoveragePct of 100 means your own product codes are in order; it does not mean the manufacturer codes and barcodes are, and euGtinInJsonLd describes the single product page that is read, not the whole catalog. It is also not legal advice: which of your parcels are in scope and what data your carrier needs is for your carrier or customs broker to confirm.

The Actor is polite by design: it reads robots.txt first and obeys it, makes at most three requests per store, identifies itself, and never retries after a refusal.

Who this is for

Agencies and freelancers who want one comparable table for a client list instead of 40 browser tabs.
Developers and app builders who need a lead list sorted by how much a store has to fix, or who want a SKU-readiness check inside their own tool through the API.
Analysts who want to measure the catalog quality of a market segment, the way the 1,071-store sample above was read.

The Python client is documented in the Apify docs. If you would rather call Apify Actors from an AI assistant than from Python, the apify-data-mcp project on GitHub shows how.

Do it before the 1st

1 November is close. A first run of 20 stores costs $0.20 and takes seconds: open the Actor, paste your stores, press Start. If it saves you an afternoon of tab-hopping, a short review on the Store page tells me what to improve next. And if you remember only one thing from this post: start with the SKUs, and audit the whole list in one go.

Written with AI assistance.

EU customs identifiers from 1 Nov 2026: what 1,071 Shopify stores look like

ByteHarvester — Fri, 23 Oct 2026 12:38:46 +0000

Disclosure: I build Citebeam, the Shopify app mentioned in this post. The numbers use public data only and the method is open, so you can check them yourself.

From 1 November 2026, EU customs declarations for online sales of imported goods to consumers have to carry product identifiers for each item, and customs can hold parcels that lack required data. Citebeam, the Shopify app I build, has a free checker that shows how your catalog looks on the identifier basics in about ten seconds: run it on your store, no sign-up.

I am not giving legal advice. Which of your parcels are in scope, and in what format the data goes, is for your carrier or customs broker to confirm, and carriers have started publishing what they want from merchants. What I can give you is data: what the identifier basics look like across 1,071 live Shopify stores, what Shopify itself says about its fields, and a 20-minute pass that gets a catalog ready.

The three identifiers, in Shopify terms

Your own product code (M-PID). In Shopify that is the variant SKU. Every variant needs its own.
The manufacturer's or supplier's code (NS-PID). A model or part number. Shopify now lets you enter it as a variant barcode of type NS-PID (Admin API 2026-10 and the admin).
A standardised identifier (S-PID). A GTIN, EAN, UPC or ISBN, where the product has one.

What 1,071 stores look like

In October 2026 I read the public data of 1,071 live Shopify stores (42,560 products): the public product feed (first 50 products) and one product page each. No store is named. Two numbers matter here, and both are public-data proxies, not customs data:

50.3% of products have at least one variant with no SKU. 79.6% of the stores have at least one such product, and in 50.2% of the stores most products have one. The SKU is the usual M-PID, and a SKU that is blank or shared by several variants cannot identify one variant.
8.4% of the stores print a GTIN in the Product JSON-LD of the product page I read (10.6% of the pages that carry Product JSON-LD at all). Read that as a lower bound, not as the share of stores that have barcodes: the public feed does not show barcodes, and a theme prints one into its structured data only if it is set up to.

The manufacturer's code cannot be seen from outside at all. That one only exists in your admin.

What Shopify says about its own fields (as of 23 October)

Shopify staff have answered several of the open questions on the developer forum. The short version, with the sources at the end of this section:

A barcode with no declared type ("Custom") that holds a valid GTIN already counts as the S-PID. You should not tick "Has no standardized identifier" for those variants. Staff added that the safer move is still to set the barcode's type to GTIN, EAN, UPC or ISBN rather than rely on Shopify recognising it. The declaration is for variants whose barcodes are SKUs, internal codes or other values that are not valid GTINs. (Staff, 20 October.)
If a variant has no NS-PID, Shopify fills one in from its other barcodes, the SKU or the variant ID. Your supplier's real code is better, and you should keep one NS-PID barcode per variant: which one is used when there are several is not documented. (Staff, 20 October.)
"Has no standardized identifier" cannot be set in bulk from the admin today. There is no CSV column and no bulk-editor column. Through the API it is in the unstable version and in the 2027-01 release candidate, which becomes the stable version on 1 January. A placeholder such as "None" in the barcode field does not record it. (Staff, 19 to 22 October.)
Passing the declaration on to carriers was "not live just yet" on 20 October, so ask your carrier how they take it.

Sources: Shopify's BarcodeType documentation and the developer-forum threads About EU new barcode requirements and barcode types and How to bulk edit the new "Has no standardized identifier" checkbox. This is Shopify's description of its own fields, so check it against the current docs.

A 20-minute pass before 1 November

SKUs first. Export Products as CSV. In the Variant SKU column, filter the blanks, then flag duplicates (in Google Sheets, =COUNTIF(A:A, A2)>1 on that column). Replace placeholders such as N/A or 0. Fix products with many variants first: that is where a parent SKU gets copied to every size and colour.
Barcodes second. For each variant decide: a real GTIN goes in the barcode field, as digits only; if the product has none, declare it on the variant instead of typing a placeholder. A mistyped barcode is worse than none, so check the last digit. This is the check digit test Citebeam uses:

// GTIN-8/12/13/14 check digit (GS1 mod 10)
function validGtin(code) {
  if (!/^\d{8}$|^\d{12,14}$/.test(code)) return false;
  const digits = code.split("").map(Number);
  const check = digits.pop();
  const sum = digits.reverse().reduce((s, d, i) => s + d * (i % 2 === 0 ? 3 : 1), 0);
  return (10 - (sum % 10)) % 10 === check;
}

Manufacturer codes third. If you make the product, the code is yours to assign. If you resell it, ask the supplier for the maker's model or part number, and enter it as an NS-PID barcode. Never invent one.
HS code and country of origin. They sit on the variant (Shipping section) and carriers ask for them too. The origin is where the item was made, not where you ship from.
Hand your carrier a file, one line per variant: handle, variant title, SKU, barcode, vendor, manufacturer code, HS code, country of origin.

Skip the spreadsheet

Doing this across hundreds of variants by hand is the job Citebeam is built for. The free checker reports your SKU coverage, missing and duplicated SKUs, and whether a product page publishes a GTIN, from public data only. The Citebeam app goes further from inside your Shopify admin: it reads every variant (it only reads, it stores nothing from this check and needs no new permission), lists the variants with a missing or duplicated SKU, a barcode that fails the check digit or is not a GTIN, no vendor, no manufacturer code, and gives you that carrier file as a CSV with the manufacturer-code column ready for you to fill from your suppliers.

The data behind the study, the method and its limits are public: the research page, including the EU customs identifiers section.

How I measured (short version)

Stores came from Common Crawl's October 2026 index of myshopify.com addresses; I probed 1,461 and 1,071 qualified (public feed, at least 10 products). Per store: robots.txt, up to 50 products from the public feed and one product page, with at most 3 requests, an honest user agent and robots.txt respected. For the 58.6% of stores with more than 50 products, only the first 50 are represented, and structured data comes from one product page per store without running JavaScript. The sample leans toward smaller and newer merchants.

1 November is close. Start with the SKUs: run the free check and you will know in ten seconds how big that job is for your store.

Written with AI assistance.

Coles vs Woolworths vs Aldi: weekly grocery price index (22 October 2026)

ByteHarvester — Fri, 23 Oct 2026 08:50:10 +0000

Disclosure: I built the Apify Actors used to collect this data. This post was written with AI assistance.

Aldi is the cheapest of the three for this week's basket of 31 staples ($105.40), Coles the dearest ($128.57, 22% more). With Aldi at 100, Coles is at 122 and Woolworths at 117.5. Between the two big chains, Coles is 3.8% dearer than Woolworths on this basket.

Supermarket price comparisons are usually one-off snapshots. This one is rebuilt every week from the shelf prices the three chains show online, for the same 31 items every time, so the trend is visible. Prices are for the cheapest matching product per item (usually a home brand), compared per kilogram or litre, so pack sizes do not distort the result.

This week's basket

	Coles	Woolworths	Aldi
Basket total (31 items)	$128.57	$123.81	$105.40
Index (Aldi = 100)	122	117.5	100
Basket at regular prices (without specials)	$129.86	$135.20	$105.40
Items where the cheapest match is on special	5 of 31	3 of 31	10 of 31
Share of all matching products on special	23.3%	15.3%	29.6%
Items where this chain has the lowest price (ties count for each)	11	7	26

On special: Coles and Woolworths flag a product as on special when it has a discount or multi-buy deal. Aldi shows no "was" price, so its basket is the same with or without specials; Aldi products on its Lower Prices, Super Savers and Limited Time Only shelves are flagged as promotions here.

Week-over-week changes appear from the second edition on: this report stores every edition, and the next one will show which items moved.

The basket, item by item

Price per kilogram or litre of the cheapest matching product (an asterisk means that product is on special today). The basket buys the quantity shown.

Item	Quantity	Coles	Woolworths	Aldi
Full cream milk	2 L	$1.70	$1.65	$1.65*
Eggs, 12 pack	0.7 kg	$8.50	$7.50	$7.10*
Butter	0.25 kg	$18.00	$16.80	$14.00
Tasty / cheddar cheese block	0.5 kg	$9.30	$10.50	$8.99
Natural yoghurt	1 kg	$7.50	$4.20	$3.90
White sandwich bread	0.7 kg	$6.60	$7.40	$3.70
Long grain white rice	1 kg	$1.80	$1.80	$1.80
Spaghetti	0.5 kg	$1.90*	$1.80	$1.80
Plain flour	1 kg	$1.20	$1.20	$1.20
White sugar	1 kg	$1.30	$1.30	$1.30
Rolled oats	1 kg	$2.30	$2.10	$2.00
Corn flakes	0.75 kg	$5.60	$8.40	$5.60
Canned diced tomatoes	0.8 kg	$2.38	$2.38	$2.98
Baked beans	0.84 kg	$3.10	$3.80	$3.10
Canned tuna	0.38 kg	$10.53	$9.19	$9.14
Peanut butter	0.375 kg	$13.10*	$13.30*	$6.00*
Extra virgin olive oil	0.5 L	$14.00	$13.00*	$8.80*
Frozen peas	1 kg	$4.40	$2.50	$2.49
Vanilla ice cream	2 L	$3.00	$3.00	$2.50*
Royal Gala apples	1 kg	$7.90	$7.90	$6.99
Washed potatoes	2 kg	$3.85	$2.50	$2.12
Brown onions	1 kg	$2.65	$2.75	$2.99
Carrots	1 kg	$1.73	$2.50	$2.09
Tomatoes	0.5 kg	$3.90*	$5.90	$4.36
Chicken breast fillets	1 kg	$8.50*	$9.50	$8.99*
Beef mince	0.5 kg	$15.40*	$15.40	$12.98*
Rindless bacon	0.25 kg	$17.60	$17.60*	$13.98*
Orange juice	2 L	$2.75	$2.10	$2.00*
Frozen mixed vegetables	1 kg	$2.80	$2.80	$2.79
Frozen potato chips	1 kg	$3.15	$3.15	$2.99*
Dishwashing liquid	1 L	$1.40	$1.40	$1.40

How this was measured

Source: the Coles, Woolworths and ALDI scrapers on Apify, run on 2026-10-22 with a fixed list of 31 search terms, the first 20 to 30 results per search at each chain.
Like for like: a product counts for an item only if its name matches that item (for example "full cream" milk, not lactose-free, flavoured or A2) and it has a unit price. Only items with a match at all three chains enter the totals.
Cheapest match: for each item the lowest unit price among the matching products is used. That favours home brands, which is what a price-conscious shopper buys.
Online shelf prices: the prices are those each chain's website shows without choosing a store, in Australian dollars. Coles prices vary a little from store to store. Prices include any special that is active that day.
Not an official index: this is a small, fixed basket of staples, not the whole shop, and not a substitute for ABS or ACCC figures. Aldi's range is narrower, which is why some items have fewer matches there.
Aggregate prices only: product names and prices are shown; no personal data is involved.

How to get this data yourself, every day

Everything above was collected by these Apify Actors from a fixed input, plus some arithmetic. You can run the same collection on your own Apify account in a couple of clicks:

Coles Australia Scraper: $1.00 per 1,000 results on the free plan, you pay only for results delivered.
Woolworths Australia Scraper: $0.70 per 1,000 results on the free plan, you pay only for results delivered.
Aldi Australia Scraper: $1.00 per 1,000 results on the free plan, you pay only for results delivered.

Collecting the data for this edition costs about $1.49 on Apify's free plan (you pay per result delivered, nothing for a search that returns nothing), so a weekly refresh is about $6 a month.

Daily monitor in three steps:

Open the Actor, paste an input like the one below, and switch on Only new (onlyNew). The first run returns everything; every later run returns only what no earlier run of the same watch list delivered, and skipped items are not charged.
Save the input as a task and put it on a schedule (for example the cron expression 0 7 * * *, every day at 07:00 UTC).
Send the result where you work: e-mail, Slack or Google Sheets, from the task's Integrations tab.

{
  "searchTerms": [
    "milk",
    "eggs",
    "bread"
  ],
  "maxProductsPerInput": 50,
  "onlyNew": true,
  "monitorKey": "coles-staples"
}

The same fields work in the Woolworths scraper. With onlyNew on, a product whose price changed since the last run comes back again with the old and new price in changes, so the monitor doubles as a price-drop alert. The ALDI scraper has no only-new switch: schedule it and compare the runs.

Want your own basket, with your brands, your store and your postcode? Run the Coles, Woolworths or ALDI scraper on Apify: type the products you buy, press Start, and get prices, unit prices and specials as a spreadsheet. The input forms are prefilled.

Next edition: follow me here on dev.to for the next weekly index, or switch on the daily monitor above and get price changes the moment they happen.

I checked 1,071 Shopify stores for ChatGPT shopping readiness. Here is what is missing before Black Friday

ByteHarvester — Fri, 23 Oct 2026 08:39:22 +0000

Disclosure: I build Citebeam, the Shopify app mentioned in this post. The data is public-feed only and the method is open, so you can check it yourself.

Black Friday is on November 27, 2026. More shoppers now ask an AI assistant what to buy, and an assistant can only recommend what it can read. Citebeam is the Shopify app I build to check a catalog for exactly that, and its checker is free: run it on your store in ten seconds, no sign-up.

I wanted real numbers instead of guesses, so I measured 1,071 live Shopify stores (42,560 products) in October 2026, using only public data. No store is named. Here is what came out.

The good news: the basics are there

85.8% of the stores score 80 or more out of 100 on the product-data checks (median 89.1). Every product has a title and a vendor. If your store is in that group, you are ahead of the 14.2% that are not, and the rest of this post is about the last mile. The last mile is where the details are patchy.

The gaps an AI assistant trips over

1. SKUs and barcodes. About half of all products (50.3%) have at least one variant with no SKU. On the product pages I checked, only 8.4% of stores publish a GTIN or other barcode in their structured data. Identifiers are how a product gets matched across feeds and shops.

2. Thin descriptions and missing labels. 21.7% of products have a description under 150 characters, and 6.9% have no description at all. 64.2% of stores have at least one thin description somewhere in the catalog. 37.9% of products have no product type and 38.2% have no tags. These fields tell an assistant what a product is and who it is for.

3. No Product structured data. 79.7% of sampled product pages carry schema.org Product data in JSON-LD, with price and availability in nearly all of them. That leaves 20.3% of stores without it: 16.3% use older microdata only and 4% have no Product markup in the delivered HTML. Shipping details (1.2%) and return policy (1.1%) are almost never there.

4. Crawlers are not the problem. Of 1,069 robots.txt files, 0 block OpenAI's search crawler (OAI-SearchBot) on product pages, 0 block PerplexityBot and 1 blocks GPTBot. The door is open. What is missing is complete data behind it.

Your 5-step fix list before the sale

Give every variant a SKU, and add the manufacturer barcode (GTIN, UPC, ISBN) where you have one. Never invent one.
Write descriptions of at least 150 characters: what it is, who it is for, materials, size, care. Start with your top sellers.
Fill in product type and tags.
Check that your product page outputs Product structured data with price and availability in the page HTML (Google's Rich Results Test shows what yours prints).
Keep AI crawlers allowed in robots.txt.

Doing this by hand across hundreds of products is the job Citebeam is built for: it scans the whole catalog from inside your Shopify admin, ranks the gaps by importance and applies the fixes it can after you preview them. Start with the free check and fix your best sellers first, while there are still a few weeks left.

The half this study cannot see

My data is about your catalog, the part you control. It does not tell you what ChatGPT or Perplexity actually answer, or which competitors and outside sources they name instead of you. If you want that measured, I run a one-off audit on Apify: 16 buyer questions on ChatGPT, Perplexity and Gemini, 96 answers for $4.80, showing your brand against your competitors and the sources they cite (a paid Apify plan is needed for the full size). Full AI visibility audit. Pair it with the catalog fixes above and you know both what to repair and whether it moved anything.

How I measured (short version)

Stores came from Common Crawl's October 2026 index of myshopify.com addresses; I probed 1,461 and 1,071 qualified (public feed, at least 10 products). Per store: robots.txt, up to 50 products from the public feed and one product page, with at most 3 requests, an honest user agent and robots.txt respected. For the 58.6% of stores with more than 50 products, only the first 50 are represented. Scores use the same rules as Citebeam's free checker, except image alt text, which Shopify's public feed does not expose, so it is not measured here. Two sub-samples (stores on their own domain and stores served on the myshopify.com address) show the same picture (mean score 88.4 and 86.8).

Limits you should know before quoting this: the sample leans toward smaller and newer merchants, structured data comes from one product page per store without running JavaScript, and the study measures data completeness, not what any assistant recommends. Charts, full method and the anonymous aggregates are on the research page: ai-shopping-readiness-2026.

Ready to see your own number? Run the free check.

Written with AI assistance.

Vienna rent prices per sqm by district: October 2026 (live ImmoScout24 data)

ByteHarvester — Thu, 22 Oct 2026 17:28:42 +0000

Disclosure: I built the Apify Actors used to collect this data. This post was written with AI assistance.

Vienna's median asking rent is €22.72 per m² in October 2026, about €1,590 a month for a typical flat. The most expensive district is Innere Stadt (1010) at €26.74 per m², followed by Donaustadt (€26.67); the cheapest is Simmering (1110) at €18.77.

If you are comparing Vienna districts before a move, negotiating a lease or building a market model, the number you want is rent per square metre by district, and the listing pages do not show it. This report computes it from live ImmoScout24.at rental listings, for all 23 districts, and I will publish a new edition regularly so you can see the change.

Rent per m² by district

Orange: the three most expensive districts. Green: the three cheapest. The grey figure is the change against the previous edition (this is the first edition, so there is none yet, shown as a dash).

Postcode	District	Median €/m²	Middle half (25%-75%)	Median rent €/month	Median size m²	Rental flats on the portal	Change in median €/m²
1010	Innere Stadt	26.74	22.89 - 30.67	3,448	147	211	–
1220	Donaustadt	26.67	22.05 - 34.53	1,532	59	628	–
1190	Döbling	25.13	22.74 - 30.89	2,548	95.9	217	–
1040	Wieden	24.58	22.77 - 32.59	3,860	148.3	87	–
1020	Leopoldstadt	23.85	21.46 - 29.15	1,834	75.9	124	–
1030	Landstraße	23.08	20.00 - 24.64	1,699	81.8	476	–
1180	Währing	22.84	21.27 - 25.58	2,850	131.9	117	–
1140	Penzing	22.75	18.35 - 26.11	1,490	70	117	–
1050	Margareten	22.54	19.02 - 25.54	1,600	66.4	74	–
1100	Favoriten	22.34	20.31 - 23.66	1,125	50.8	395	–
1070	Neubau	22.31	20.05 - 24.33	2,129	97.6	72	–
1130	Hietzing	22.31	19.48 - 26.52	1,542	74	116	–
1120	Meidling	21.52	18.63 - 23.37	1,249	58.8	119	–
1080	Josefstadt	21.16	19.92 - 24.11	2,309	102.1	47	–
1200	Brigittenau	21.15	17.75 - 27.64	1,545	68.8	137	–
1170	Hernals	21.09	18.52 - 23.65	1,598	69.1	59	–
1160	Ottakring	20.87	18.49 - 22.98	1,149	54.2	78	–
1060	Mariahilf	20.25	17.84 - 25.23	2,148	94.5	71	–
1090	Alsergrund	20.15	17.91 - 24.47	1,972	81	75	–
1210	Floridsdorf	19.84	18.09 - 22.06	1,049	53.1	340	–
1150	Rudolfsheim-Fünfhaus	19.63	18.09 - 25.51	1,435	65	89	–
1230	Liesing	19.28	17.81 - 21.05	1,199	63.6	119	–
1110	Simmering	18.77	16.99 - 20.40	1,141	63.5	112	–

Rent per m² by flat size: under 40 m² cost the most

under 40 m²: €28.05 per m² (median rent €900 a month, 52 listings)
40-60 m²: €22.72 per m² (median rent €1,099 a month, 281 listings)
60-90 m²: €21.53 per m² (median rent €1,598 a month, 301 listings)
90 m² and up: €22.80 per m² (median rent €3,148 a month, 381 listings)

The under 40 m² band is the most expensive per square metre (€28.05) and the 60-90 m² band the cheapest (€21.53). A small flat is a cheaper flat per month, not per square metre, so compare districts using flats of the same size.

How this was measured

Source: the ImmoScout24 Austria Scraper on Apify, run on 2026-10-22 with a fixed input: all 23 Vienna postcodes, rent, flats, sorted newest first, the newest 50 listings per district (1015 listings in total after removing duplicates, implausible rows and listings beyond the agency cap). The portal itself listed 3,880 rental flats in Vienna that day (column "Rental flats on the portal").
Asking rents, not contracts: these are the rents advertised by landlords and agents, as ImmoScout24 shows them (monthly rent including operating costs). Signed contracts, old tenancies and regulated rents are lower.
City median: each listing is weighted by how many rental flats its district has on the portal, so small districts do not count as much as large ones.
No single advertiser decides a district: one agency or developer counts for at most 5 listings per district, because a developer who posts a whole new-build block on one day would otherwise set the median of its district (listings used per district: 30 to 50).
Aggregates only: no landlord names, streets or listing texts are used or published here.
Caveat 1: peripheral districts with a lot of new-build rental supply can rank higher than their address suggests; the data used here does not separate new-builds from older flats.
Caveat 2: the newest 50 listings are a sample of a district's market, not all of it. Differences of a euro between neighbouring districts are within noise; the gaps of five euros and more are not.

How to get this data yourself, every day

Everything above was collected by an Apify Actor from a fixed input, plus some arithmetic. You can run the same collection on your own Apify account in a couple of clicks:

ImmoScout24 Austria Scraper: $1.50 per 1,000 results on the free plan, you pay only for results delivered.

Collecting the data for this edition costs about $1.73 on Apify's free plan (you pay per result delivered, nothing for a search that returns nothing), so a monthly refresh costs about the same.

Daily monitor in three steps:

Open the Actor, paste an input like the one below, and switch on Only new (onlyNew). The first run returns everything; every later run returns only what no earlier run of the same watch list delivered, and skipped items are not charged.
Save the input as a task and put it on a schedule (for example the cron expression 0 7 * * *, every day at 07:00 UTC).
Send the result where you work: e-mail, Slack or Google Sheets, from the task's Integrations tab.

{
  "locations": [
    "Wien"
  ],
  "transaction": "rent",
  "propertyType": "flat",
  "sortBy": "newest",
  "maxListingsPerSearch": 100,
  "onlyNew": true,
  "monitorKey": "vienna-rent-flats"
}

Want the numbers for your own street, price range or flat size? Open the ImmoScout24 Austria Scraper on Apify, set the district and filters, and run it: the input form is prefilled, one click starts a run, and the dataset comes back as CSV, Excel or JSON.

Next edition: follow me here on dev.to to get the next Vienna rent update, and run the monitor above if you would rather have the new listings in your inbox the same morning they appear.

More copy-paste examples (Python, n8n workflow, LangChain tool): ImmoScout24 Austria integration examples on GitHub

Historical stock prices and crypto quotes API in 10 lines of Python

ByteHarvester — Thu, 22 Oct 2026 04:05:08 +0000

Disclosure: I built the Apify Actor used in this tutorial. This post was written with AI assistance.

You want today's price for a handful of tickers, a year of daily closes for a backtest, and the sector and margins for a screen, without signing up for three different market-data plans. The Yahoo Finance Scraper (highbrow_fame/yahoo-finance-quotes) on Apify returns all three for stocks on any exchange, ETFs, crypto, currencies and indexes, from a single input, for $1.00 per 1,000 symbols on the free Apify plan. Price history and company data cost nothing extra. Here is the ten-line version, then the options, then a small portfolio report you can run after the close every day.

The 10 lines

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("highbrow_fame/yahoo-finance-quotes").call(
    run_input={"symbols": ["AAPL", "VOD.L", "SAP.DE", "SPY", "BTC-USD", "EURUSD=X", "^GSPC"]}
)
for q in client.dataset(run.default_dataset_id).iterate_items():
    if q.get("price") is None:
        continue
    print(f'{q["symbol"]:<9} {q["price"]:>12,.2f} {q.get("changePercent") or 0:+6.2f}%  {q["currency"]} {q["exchange"]}')

Symbols are written exactly as Yahoo Finance writes them: VOD.L for London, SAP.DE for Xetra, 7203.T for Tokyo, BTC-USD for Bitcoin, EURUSD=X for a currency pair, GC=F for gold futures and ^GSPC for the S&P 500. Quotes come 50 symbols to a request, so a 300-symbol watchlist is a handful of requests rather than 300. A symbol Yahoo does not know comes back as a free record with error set and no price, which is why the loop skips those.

Each record carries the full quote: price, change, changePercent, previousClose, open, dayLow, dayHigh, volume, bid, ask, marketTime and marketState, the ranges fiftyTwoWeekLow, fiftyTwoWeekHigh, fiftyDayAverage and twoHundredDayAverage, valuation fields marketCap, trailingPE, forwardPE, epsTrailingTwelveMonths and priceToBook, and dividendRate, dividendYield, dividendDate, earningsDate and analystRating. exchangeDelayMinutes tells you whether the quote is real-time or delayed for that exchange.

Option 1: price history

Set includeHistory: true and pick a range and interval. historyRange takes 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd or max; historyInterval takes 1m, 5m, 15m, 30m, 60m, 1d, 1wk or 1mo, with minute intervals available for recent days only. Exact dates go in historyFrom and historyTo as YYYY-MM-DD and override the range. The history lands in history.points, a list of {date, open, high, low, close, adjClose, volume}, plus history.dividends and history.splits.

run = client.actor("highbrow_fame/yahoo-finance-quotes").call(run_input={
    "symbols": ["AAPL", "BTC-USD"],
    "includeHistory": True,
    "historyRange": "1y",
    "historyInterval": "1d",
})
for q in client.dataset(run.default_dataset_id).iterate_items():
    points = q.get("history", {}).get("points") or []
    if not points:
        continue
    first, last = points[0], points[-1]
    total_return = (last["adjClose"] / first["adjClose"] - 1) * 100
    print(f'{q["symbol"]}: {len(points)} days, {first["date"]} to {last["date"]}, '
          f'{total_return:+.1f}% total return, {len(q["history"].get("dividends") or [])} dividends')

If you work in pandas, pd.DataFrame(points).set_index("date") gives you a frame per symbol. Dividends and splits are already applied in adjClose, so return maths uses that column; close is the raw print.

For a growing local archive, store the last date you have per symbol and pass it as historyFrom on the next run, so each day fetches only the missing points. Intraday work uses the minute intervals with a short range such as 5d; Yahoo keeps minute bars for recent days only, so archive them as you go if you need them later.

Option 2: company data

includeFundamentals: true adds three objects per symbol: profile (sector, industry, website, employees, business summary), financials (revenue, growth, margins, EBITDA, cash, debt, free cash flow, ROE, analyst targets and recommendation) and keyStatistics (enterprise value, beta, PEG, short interest). Crypto, currencies and indexes are not companies, so they say so in fundamentalsUnavailable instead of returning empty objects.

run = client.actor("highbrow_fame/yahoo-finance-quotes").call(run_input={
    "symbols": ["AAPL", "SAP.DE", "BTC-USD"],
    "includeFundamentals": True,
})
for q in client.dataset(run.default_dataset_id).iterate_items():
    if q.get("fundamentalsUnavailable"):
        print(q["symbol"], "-", q["fundamentalsUnavailable"])
        continue
    p, f = q.get("profile") or {}, q.get("financials") or {}
    print(q["symbol"], p.get("sector"), "/", p.get("industry"), "| margins:", f.get("profitMargins"),
          "| target:", f.get("targetMeanPrice"), "| rec:", f.get("recommendationKey"))

The inner keys of financials and keyStatistics follow Yahoo's own names, so print one record once with json.dumps(q, indent=2) to see exactly which fields your symbols carry before you build a screen on them.

A small portfolio report

Put the holdings in a dict, fetch one run, and print value, day change and weight. This is the script to schedule after the close:

HOLDINGS = {"AAPL": 25, "SAP.DE": 40, "SPY": 10, "BTC-USD": 0.15, "VOD.L": 500}

run = client.actor("highbrow_fame/yahoo-finance-quotes").call(
    run_input={"symbols": list(HOLDINGS)}
)
rows = []
for q in client.dataset(run.default_dataset_id).iterate_items():
    if q.get("price") is None:
        continue
    qty = HOLDINGS[q["symbol"]]
    rows.append({
        "symbol": q["symbol"], "currency": q["currency"], "qty": qty,
        "price": q["price"], "value": qty * q["price"],
        "day_change": qty * (q.get("change") or 0), "day_pct": q.get("changePercent") or 0,
    })

total = sum(r["value"] for r in rows)
print(f'{"symbol":<9}{"ccy":<5}{"qty":>8}{"price":>12}{"value":>14}{"day":>12}{"weight":>8}')
for r in sorted(rows, key=lambda r: -r["value"]):
    print(f'{r["symbol"]:<9}{r["currency"]:<5}{r["qty"]:>8}{r["price"]:>12,.2f}'
          f'{r["value"]:>14,.2f}{r["day_change"]:>+12,.2f}{r["value"]/total:>8.1%}')
print(f'total (mixed currencies): {total:,.2f}')

Values are in each symbol's own currency, so VOD.L is in GBp and SAP.DE in EUR; add the EURUSD=X and GBPUSD=X symbols to the same run and multiply if you want one base currency. Wrap the script in a cron entry for 22:30 UTC on weekdays, or save the input as a task in the Apify Console and schedule it there, then read the newest dataset from your code.

The same call with curl

No Python at hand? The synchronous endpoint runs the Actor and returns the dataset in one request:

curl -sS -X POST "https://api.apify.com/v2/acts/highbrow_fame~yahoo-finance-quotes/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"symbols": ["AAPL", "BTC-USD"], "includeHistory": true, "historyRange": "1mo"}'

Add &format=csv to the URL for a spreadsheet-ready response.

Cost per 1,000 symbols

The Actor charges $0.001 per symbol delivered on the free Apify plan, which is $1.00 per 1,000 symbols, falling to $0.70 per 1,000 on Gold and higher plans. The price is the same with or without history and company data, and unknown symbols are not charged. The seven-symbol quote run at the top costs $0.007; a 500-symbol watchlist refreshed every trading day costs $0.50 a day.

Try it with the prefilled input: https://apify.com/highbrow_fame/yahoo-finance-quotes

More copy-paste examples (Python, n8n workflow, LangChain tool): Yahoo Finance integration examples on GitHub

Austria apartments for rent: a daily new-listings feed from ImmoScout24 (Python)

ByteHarvester — Wed, 21 Oct 2026 08:03:21 +0000

Disclosure: I built the Apify Actor used in this tutorial. This post was written with AI assistance.

Finding a flat to rent in Vienna rewards whoever sees a listing first, and the comparisons you actually want, like rent per square metre by district, are not on the listing page. This tutorial builds a daily feed of new ImmoScout24 Austria rentals with the ImmoScout24 Austria Scraper (highbrow_fame/immoscout24-at-properties) on Apify. You set the filters once, a Python script runs every morning, keeps only listings it has not shown you before, computes rent per m², and writes a CSV you can open or push to Google Sheets. The Actor charges $1.50 per 1,000 properties on the free plan, so a 100-listing daily check costs about 15 cents a day.

What a listing record contains

Every property comes back with price (the monthly rent for rentals), priceText, currency, pricePerSqm, areaSqm, rooms, postcode, town, state, transaction, propertyType, title, features (for example BALCONY, GARDEN, FREE_OF_COMMISSION), sellerType, agency, listedAt, image, url and listingId. Reduced listings carry oldPrice and priceCutPercent. Private owners are anonymous: no name, no street, no map point, only postcode and town. With includeDetails: true you also get description, floor, yearBuilt, condition, heating, the energy certificate (heatingDemand, heatingDemandClass, energyEfficiencyClass), availableFrom, hasCommission, oneTimeCosts and monthlyCosts.

Step 1: set the filters

locations accepts Austrian cities, towns, Vienna districts, postcodes and states, so "Wien" covers the whole city and "1070" or "Neubau" narrows it to one district. The filters are plain fields:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

SEARCH = {
    "locations": ["Wien"],
    "transaction": "rent",
    "propertyType": "flat",
    "minArea": 50,
    "maxPrice": 1500,
    "minRooms": 2,
    "keyword": "Balkon",
    "sortBy": "newest",
    "maxListingsPerSearch": 100,
    "includeDetails": False,
}

run = client.actor("highbrow_fame/immoscout24-at-properties").call(run_input=SEARCH)
listings = [
    item for item in client.dataset(run.default_dataset_id).iterate_items()
    if not item.get("error") and item.get("price")
]
print(len(listings), "flats")

If you already have a search set up on immobilienscout24.at with every filter you want, paste its results URL into searchUrls instead and leave the field filters out. sortBy: "newest" is the right order for a feed: the newest 100 of a large search are the ones that changed since yesterday. maxPrice is the monthly rent in EUR.

The same input works outside Vienna. ["Graz", "Linz"] searches two cities in one run, ["Tirol"] a whole state, and because the place search reads "Salzburg" as the state, type the postcode 5020 for the city itself. Each place is one search, so maxListingsPerSearch applies per place. When you reach the shortlist stage, re-run the chosen searchUrls with includeDetails: true to get monthlyCosts, oneTimeCosts, hasCommission, availableFrom and the energy certificate, which together tell you what the flat really costs to move into and to heat.

Step 2: feed mode in 15 lines

The Actor has no built-in only-new switch, so the feed lives in your script: remember every listingId you have delivered in a key-value store in your Apify account and skip the ones you have seen. The first run seeds the memory and reports everything.

store = client.key_value_stores().get_or_create(name="immoscout-wien-feed")
kv = client.key_value_store(store.id)

record = kv.get_record("seen-ids")
seen = set(record["value"]) if record else set()

new_listings = [l for l in listings if l["listingId"] not in seen]
seen.update(l["listingId"] for l in listings)
kv.set_record("seen-ids", sorted(seen))

print(len(new_listings), "new since last run")

Run the script once a day from cron, a GitHub Actions schedule, or any other timer, and new_listings is your feed. If you ever change the filters, give the store a new name so the feed starts clean. Keep maxListingsPerSearch a little larger than a day's worth of new listings for your filters; if len(listings) keeps hitting the limit, raise it.

Step 3: rent per m² and the district comparison

The Actor already fills pricePerSqm when the site shows it. Compute it yourself from price and areaSqm as a fallback, then compare each new flat with the median of its postcode across everything you fetched today:

from statistics import median
from collections import defaultdict

def rent_per_sqm(l):
    if l.get("pricePerSqm"):
        return round(l["pricePerSqm"], 2)
    if l.get("areaSqm"):
        return round(l["price"] / l["areaSqm"], 2)
    return None

by_postcode = defaultdict(list)
for l in listings:
    r = rent_per_sqm(l)
    if r:
        by_postcode[l["postcode"]].append(r)
district_median = {pc: median(v) for pc, v in by_postcode.items()}

for l in new_listings:
    r = rent_per_sqm(l)
    l["rentPerSqm"] = r
    l["vsDistrictMedianPct"] = (
        round((r / district_median[l["postcode"]] - 1) * 100, 1)
        if r and l["postcode"] in district_median else None
    )
    pct = l["vsDistrictMedianPct"]
    vs = f"{pct:+}% vs district" if pct is not None else "no district median"
    cut = f' (cut {l["priceCutPercent"]}% from {l["oldPrice"]})' if l.get("oldPrice") else ""
    print(f'{l["postcode"]} {l["town"]:<10} {l["price"]:>5} EUR {l.get("areaSqm") or "?":>4} m2 '
          f'{r} EUR/m2 {vs}{cut}')
    print("   ", l["url"])

A flat at -18% against its postcode median deserves a look today, not next week. A priceCutPercent on a listing you saw last week is the other signal worth acting on, so you may want to keep reduced listings in the feed even when the ID is already known.

Step 4: CSV and Google Sheets export

Write the enriched feed to a CSV that opens straight in Excel, Numbers or Sheets. The features list is joined into one cell:

import csv
from datetime import date

FIELDS = ["listedAt", "postcode", "town", "price", "areaSqm", "rooms", "rentPerSqm",
          "vsDistrictMedianPct", "oldPrice", "priceCutPercent", "sellerType", "agency",
          "features", "url"]

path = f"wien-rent-{date.today()}.csv"
with open(path, "w", newline="", encoding="utf-8") as f:
    w = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
    w.writeheader()
    for l in new_listings:
        w.writerow({**l, "features": ", ".join(l.get("features") or [])})
print("wrote", path)

For Google Sheets you have two routes. The no-code one: in the Apify Console, save the input as a task and add the Google Sheets integration under the task's Integrations tab, which appends every run's dataset to a sheet. The code one: upload the CSV above with gspread or the Sheets API from the same cron job. The raw dataset is also available as CSV from the API, if you want it without any Python: https://api.apify.com/v2/datasets/<datasetId>/items?format=csv.

Running costs

The Actor charges $0.0015 per property delivered on the free Apify plan, which is $1.50 per 1,000 properties, and less on paid plans down to $1.05 per 1,000. Opening listings for their details costs nothing extra, only time. A 100-listing daily run is $0.15 a day, or about $4.50 a month, and a place ImmoScout24 does not know comes back as a free record rather than a charged one.

Try it with the prefilled input: https://apify.com/highbrow_fame/immoscout24-at-properties

More copy-paste examples (Python, n8n workflow, LangChain tool): ImmoScout24 Austria integration examples on GitHub

OfferUp price tracker: get new listings for any search as a webhook alert

ByteHarvester — Tue, 20 Oct 2026 09:01:38 +0000

Disclosure: I built the Apify Actor used in this tutorial. This post was written with AI assistance.

Refreshing an OfferUp search every morning to catch a fairly priced road bike or a used camera body is a job for a script, not a person. This tutorial builds that script around the OfferUp Scraper (highbrow_fame/offerup-listings) on Apify. It has a feed mode that returns only listings you have not seen before, it can POST a summary to a Slack or Discord webhook on its own, and it charges $1.50 per 1,000 listings delivered, so a daily check of one search costs cents rather than dollars a month. You will end up with a scheduled daily run, a webhook alert, and a short Python filter that only pings you for price drops.

What the Actor returns

One record per listing: listingId, url, title, price, originalPrice, currency, isFirmPrice, condition, category, description, city, state, postedAt, localPickup, shippingAvailable, shippingPrice, sellerType, image and imageCount. For vehicles you also get make, model, year, trim, mileage and titleStatus as separate fields. Phone numbers and private sellers' names are not delivered, and contact details inside descriptions are stripped. In feed mode each new listing also carries firstSeenAt.

Step 1: define the search

You can paste a search URL from offerup.com into searchUrls, or describe the search with fields. The field version is easier to version-control:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

SEARCH = {
    "keywords": ["road bike"],
    "locations": ["Austin, TX"],
    "radiusMiles": "20",
    "category": "sports-and-outdoors",
    "minPrice": 200,
    "maxPrice": 900,
    "conditions": ["used", "open-box"],
    "sortBy": "newest",
    "maxListingsPerSearch": 60,
    "includeDetails": True,
}

run = client.actor("highbrow_fame/offerup-listings").call(run_input=SEARCH)
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item.get("error"):
        continue
    print(f'${item["price"]:>6}  {item["condition"]:<9} {item["city"]}, {item["state"]}  {item["title"]}')
    print("        ", item["url"])

locations takes US ZIP codes or "City, ST". radiusMiles is a string from the set 5, 10, 20, 30 or 50. sortBy: "newest" matters for a daily run: OfferUp's default relevance order reshuffles between runs, while newest-first is stable, so the same input returns a predictable window. includeDetails adds description, condition, post date and firm-price flag in one extra request per 50 listings at no extra charge.

Step 2: switch on feed mode and the webhook

Two fields turn a search into a feed:

onlyNewListings: true makes the Actor remember every listing it delivered for this exact input, in a key-value store in your own Apify account named feed-<actor>-<hash>. The first run returns everything. Every later run with the same input returns only listings not seen before, and seen items are neither saved nor charged. Memory lasts 60 days per item.
alertWebhookUrl makes the Actor POST one JSON message when new items appear: {actor, newCount, sampleItems, datasetUrl, runId} with up to five sample items, plus a text field so a Slack or Discord incoming webhook renders it directly.

FEED = {
    **SEARCH,
    "onlyNewListings": True,
    "alertWebhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX",
}

Create the incoming webhook in Slack (Apps → Incoming Webhooks) or Discord (channel settings → Integrations → Webhooks) and paste its URL. Treat the URL as a secret: it sits in the run input, and the sample items are sent to it. Change any filter and the hash changes, so a new feed starts from scratch, which is what you want.

Step 3: schedule it daily on Apify

The cleanest place to run the feed is Apify itself, so nothing on your laptop has to stay awake. In the Apify Console open the Actor, fill the input above, save it as a task, and add a schedule from the task's Schedules tab. Or create the schedule from Python once:

import json

actor_id = client.actor("highbrow_fame/offerup-listings").get().id

schedule = client.schedules().create(
    name="offerup-road-bike-austin",
    cron_expression="0 13 * * *",
    timezone="America/Chicago",
    is_enabled=True,
    is_exclusive=True,
    actions=[{
        "type": "RUN_ACTOR",
        "actorId": actor_id,
        "runInput": {
            "body": json.dumps(FEED),
            "contentType": "application/json; charset=utf-8",
        },
    }],
)
print("schedule", schedule.id, "next run", schedule.next_run_at)

From now on, every day at 13:00 Central the Actor searches, drops everything it has seen, and posts to your channel only when there is something new. Schedules themselves carry no charge; you pay only for the runs.

Step 4: price-drop filtering in a few lines of Python

The webhook tells you about every new listing in range. Sometimes you only want the ones that were marked down, or that sit well under the market. OfferUp exposes the earlier asking price as originalPrice, so a price drop is simply price < originalPrice. Run this from cron in place of the Apify schedule; it calls the same feed input, so deduplication still happens in the Actor:

import requests

DISCORD_WEBHOOK = "https://discord.com/api/webhooks/0000/XXXX"
CEILING = 500  # alert on anything at or under this price even without a cut

run = client.actor("highbrow_fame/offerup-listings").call(run_input=FEED)
hits = []
for item in client.dataset(run.default_dataset_id).iterate_items():
    if item.get("error") or item.get("price") is None:
        continue
    dropped = item.get("originalPrice") and item["price"] < item["originalPrice"]
    if dropped or item["price"] <= CEILING:
        tag = f'was ${item["originalPrice"]}' if dropped else "under ceiling"
        hits.append(f'${item["price"]} ({tag}) {item["title"]} - {item["city"]}, {item["state"]}\n{item["url"]}')

if hits:
    requests.post(DISCORD_WEBHOOK, json={"content": "New OfferUp price alerts:\n" + "\n".join(hits[:10])}, timeout=10)

The input is the unchanged FEED, so the Actor keeps the same feed memory and still posts its full new-listings summary to Slack, while this script sends only the price drops to Discord. If you want a single channel, drop alertWebhookUrl from the input before the first run and let the script do all the posting. Swap the Discord content payload for {"text": ...} if the target is Slack. Extend the filter however you like: isFirmPrice is False on listings open to offers, postedAt lets you skip anything older than a day, and for cars mileage and year are plain integers you can compare.

What it costs

The Actor charges $0.0015 per listing delivered, which is $1.50 per 1,000 listings, with listing details included at no extra charge. Feed mode only bills the new listings, so after the first run a daily check of a 60-listing search typically delivers a handful of records a day and costs well under a dollar a month. Links that are not OfferUp searches and places OfferUp cannot find come back as free records.

Try it with the prefilled input: https://apify.com/highbrow_fame/offerup-listings

Generative engine optimization (GEO): check if ChatGPT, Perplexity and Gemini cite your brand

ByteHarvester — Mon, 19 Oct 2026 09:42:01 +0000

Disclosure: I built the Apify Actor used in this tutorial. This post was written with AI assistance.

If a buyer asks ChatGPT or Perplexity "which CRM should a 10-person sales team use" and the answer names three other companies, you have a visibility problem that no Google ranking report will show you. This tutorial fixes the measurement half of that problem with the AI Search Visibility Tracker (highbrow_fame/ai-search-visibility-tracker) on Apify. In about ten minutes you will know, for your own questions, whether the AI engines cite your domain, what share of the citations you hold against named competitors, and the exact URLs the models read. The first check is a free sample run, so you can see real output before paying a cent for results.

What GEO means in plain terms

Generative engine optimization (GEO) is the practice of getting your brand into the answers that AI assistants generate. Classic SEO targets a ranked list of links. GEO targets a paragraph of prose with a short list of sources behind it. The model writes that paragraph from the pages it retrieves, so the lever is the same as it always was: be present on the pages the model reads. The difference is that you cannot see those pages in a rank tracker. You need the source list for each answer, and you need it repeatedly, because AI answers change from run to run.

That is what the Actor returns: one record per question, per engine, per sample, with the answer text, every cited URL, and a match against the domains you care about.

Step 1: the free sample run

Install the client and start a sample run. sampleRun: true runs your first three queries three times each on the included Perplexity engine. The result fee is zero for a sample run; only the platform run-start fee of $0.0004 at the default memory applies.

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

QUERIES = [
    "CRM for a 10-person sales team recommendations",
    "simple CRM with a free plan for startups",
    "CRM that integrates with Slack for small agencies",
]

run_input = {
    "sampleRun": True,
    "queries": QUERIES,
    "brandDomains": ["lumenly.example"],
    "competitorDomains": ["brightdesk.example", "pipeflow.example"],
    "engines": ["perplexity-agent"],
    "language": "en",
}

run = client.actor("highbrow_fame/ai-search-visibility-tracker").call(run_input=run_input)
records = list(client.dataset(run.default_dataset_id).iterate_items())
print(len(records), "records in dataset", run.default_dataset_id)

Swap lumenly.example and the competitor domains for real bare hostnames (no https://, no www.). If you pass only brand, the Actor writes a starter set of questions for that domain, but your own buyer questions always beat generated ones. Keep the sample on the default engine: Perplexity needs no API key from you and answers in 24 languages, so "language": "de" gives you German sources for the German market.

Step 2: read brandCited, citation share and the source URLs

Every engine call writes a record with "type": "citation". The three fields that matter are the brand match, the citationShare map, and the citations list with the URLs the model used. The brand verdict is exposed as brandCited, with the per-domain detail in brandMatches, so the helper below reads whichever is present.

def brand_cited(rec):
    if "brandCited" in rec:
        return bool(rec["brandCited"])
    return any(m.get("cited") for m in rec.get("brandMatches", {}).values())

for rec in records:
    if rec.get("type") != "citation":
        continue
    print(f'\n[{rec["engine"]}] {rec["query"]}')
    print("  brand cited:", brand_cited(rec))
    for domain, share in rec.get("citationShare", {}).items():
        print(f'  {domain:<22} {share["hits"]} hits  {share["sharePct"]}% share')
    for c in rec.get("citations", []):
        print("  source:", c["url"])

Because the sample runs three samples per query, you also get one stability record per query. It tells you how many of the three samples cited each domain. A domain at 1.0 is the model's settled answer. A domain at 0.33 showed up once and may be noise. Filter on it before you draw conclusions:

for rec in records:
    if rec.get("type") != "stability":
        continue
    stable = {d: s["stability"] for d, s in rec["stability"].items() if s["stability"] >= 0.5}
    print(rec["query"], "->", stable)

The summary record at the end of the dataset closes the run and is never billed, same as stability, delta and error records.

Step 3: track it weekly with the previous-run delta

A snapshot is interesting once. The weekly change is what goes into a report. Pass the dataset ID of last week's run as previousRunDatasetId and the Actor writes a delta record with the domains gained and lost per query. The script below keeps the last dataset ID in a key-value store in your Apify account, so it works unchanged from any weekly cron job or CI schedule.

store = client.key_value_stores().get_or_create(name="geo-tracker-state")
kv = client.key_value_store(store.id)

weekly_input = {
    "queries": QUERIES,
    "brandDomains": ["lumenly.example"],
    "competitorDomains": ["brightdesk.example", "pipeflow.example"],
    "engines": ["perplexity-agent"],
    "samplesPerQuery": 3,
}
previous = kv.get_record("last-dataset-id")
if previous:
    weekly_input["previousRunDatasetId"] = previous["value"]

run = client.actor("highbrow_fame/ai-search-visibility-tracker").call(run_input=weekly_input)
kv.set_record("last-dataset-id", run.default_dataset_id)

for rec in client.dataset(run.default_dataset_id).iterate_items():
    if rec.get("type") != "delta":
        continue
    for query, domains in rec["gained"].items():
        print("GAINED", query, domains)
    for query, domains in rec["lost"].items():
        print("LOST  ", query, domains)
    print("unchanged queries:", rec["unchangedQueryCount"])

A line such as LOST "simple CRM with a free plan for startups" ['lumenly.example'] is the sentence that gets read in a Monday meeting. Post it to Slack from the same script if you like.

Mind the included allowance on the default engine: a free Apify plan covers 12 engine calls per run, a paid plan 200. Queries beyond that come back as not_measured records, unbilled, with a note on how to lift the limit. Four queries at three samples fits the free allowance exactly.

Step 4: what to do when competitors are cited instead

The competitorMatches map tells you which rival domains were cited for each question. The instinct is to rewrite your own landing page. Resist it for a moment and look at the citations list instead. Those URLs are the pages the model retrieved: a review site, a comparison article, a community thread, a vendor blog. If a competitor appears there and you do not, that list is your work list.

Review and directory pages cited across several queries: get listed and get reviews there.
Comparison articles on third-party sites: pitch an inclusion, or publish your own honest comparison on your domain so it can be retrieved.
Community threads: answer the question there with real substance.
Your own pages that never appear: check that the page answers the literal question in its first paragraph, with the product name and the use case spelled out.

Then re-run next week and read the delta. Nobody can force a citation, and this Actor measures rather than promises, but the source list turns a vague "be more visible to AI" into a short list of pages to earn.

What it costs

A full run charges $0.05 per citation record, which is $50 per 1,000 citation records. One record is one engine answering one question once, so ten questions on one engine at one sample cost $0.50, and the same at three samples cost $1.50. Stability, delta, summary and error records are free. The sample run has no result fee at all.

Try it with the prefilled input: https://apify.com/highbrow_fame/ai-search-visibility-tracker

Black Friday 2026 Shopify checklist: can ChatGPT read your products? (12 points + a free one-click tool)

ByteHarvester — Sun, 18 Oct 2026 18:08:58 +0000

Disclosure: I built Citebeam, the Shopify app mentioned in this post. This post was written with AI assistance.

Black Friday is on November 27, 2026 and Cyber Monday on November 30. Merchants are preparing right now, and more shoppers are asking an AI assistant what to buy instead of typing keywords into a search box. Shopify says its Catalog shares merchants' product data with AI shopping channels such as ChatGPT, Microsoft Copilot and Google Gemini. What those channels can show depends on what is in your product data.

Free check first: see in seconds how ready your Shopify store is for ChatGPT shopping → Citebeam free readiness checker

Citebeam checks your Shopify catalog in one click, shows what AI shopping channels can and cannot read, and fixes the common gaps for you. The catalog check is free.

Free catalog check before the sale: search "Citebeam" on the Shopify App Store, or go straight to apps.shopify.com/ai-visibility-vs-competitors. A few weeks are left. Fix your top sellers before the traffic arrives.

Nobody controls what an AI recommends. But products with missing data are the easiest ones for an assistant to skip, and fixing data helps normal search and your storefront too. The checklist below is useful on its own, with or without an app.

What an AI assistant can read from a product

Shopify's help center describes which product fields Catalog shares and which ones AI platforms consider:

Title and description. What the product is.
Images and alt text. Images are shared; alt text is a written description of each one.
Price and availability. Whether it can be bought, and for how much.
Options and variants. Size, color and so on, including the option names.
Category, product type, vendor, collections and tags. The "what kind of thing is this" fields.
Barcodes. GTIN, UPC, EAN or ISBN, which can help a platform recognize a specific, known item.
A published product page with a public URL.

An assistant can only work with what is actually in these fields. An empty category, a one-line description and images without alt text give it very little to go on. (Many themes also add schema.org markup to product pages; Google's Rich Results Test shows what yours outputs. Treat it as a bonus.)

The Black Friday 2026 Shopify checklist: 12 points to finish before November 27

Start with your top sellers and the products you will promote, then continue by traffic.

Required (a product can be left out of Catalog without these)

A clear title. Say what it is, not just a model name.
At least one image.
A price above zero. Shopify documents that free products are left out of Catalog.
Published and not hidden from search engines. Check the product status, the online store sales channel and the search-engine-hiding setting. Stores in password-protected mode are left out too. Citebeam flags unpublished and hidden products automatically and marks them as not eligible.

Details that help

A Shopify product category from the standard taxonomy, plus the category attributes (color, material, size) it offers. Citebeam flags missing categories automatically and can set one in one click, with preview and undo.
A real description. What it is, who it is for, materials, dimensions, care. Two short paragraphs beat one line. Do not paste the supplier's text word for word. Citebeam flags thin descriptions (under 150 characters) so you know which to rewrite first.
The manufacturer's barcode on every variant. Use the real GTIN, UPC, EAN or ISBN. Never invent one. The last digit of a GTIN is a check digit, so a numeric barcode that fails it is usually a typo. Citebeam flags missing barcodes and barcodes that fail the check digit. It never fills barcodes in for you.
Properly named variant options. "Size" and "Color", not "Option 1".
Vendor, product type, a collection and a few tags.
Alt text on every product image. Describe what the image shows in plain words, as you would to someone on the phone. Citebeam flags images without alt text and can write it in one click, with preview and undo.
An SEO title (up to 70 characters) and description (about 160). Citebeam flags missing SEO text and can fill it in one click, with preview and undo.
Availability. Out-of-stock products are less useful to shoppers. If something will not be restocked before the sale, think about whether it should stay published.

Avoid keyword stuffing, inflated claims and made-up barcodes. Accurate data helps; padded data does not.

Skip the afternoons: run the check with Citebeam

Going through 12 points by hand for every product is tedious once you pass a few dozen. Citebeam: AI Visibility is the Shopify app I built to do it for you:

Nothing to set up. It reads your products and runs 20 checks per product, grouped as required, important and recommended, using the fields and rules Shopify documents. A few thresholds are the app's own, and it says so.
A 0-100 readiness score, plus your top issues and what to do about each. Required problems come first, and you can open the list of products behind each issue. Gaps do not hide in a long catalog.
One-click fixes for four fields: product category, product type, SEO title and description, and image alt text. You see a preview first, nothing is saved until you click Apply, and every change can be undone. Titles, descriptions and barcodes stay in your hands.
Honest about barcodes. It flags missing or malformed ones and never makes one up.
Free to start. The free plan covers the catalog check for up to 250 products and 25 one-click fixes a month. Paid plans are listed on the App Store page.

Citebeam helps you find and close the gaps in minutes instead of afternoons. The readiness score shows how complete your data is against Shopify's documented rules, product by product, so you always know what to fix next. The result: a catalog with no easy reasons for an AI assistant to skip it.

Run the free catalog check now

Your Black Friday plan for the weeks left

This week: run the check and fix the blockers: unpublished products, missing images, hidden products.
Next: categories, descriptions and barcodes for top sellers and sale items.
The week before November 27: alt text and SEO text, then a last look at stock and prices.

The sale will not wait, and fixing the data on your top sellers first is the part you can control. Start the free catalog check today: search "Citebeam" on the Shopify App Store or open apps.shopify.com/ai-visibility-vs-competitors.

👉 Run the free Citebeam readiness check on your store, then fix the gaps with Citebeam before Black Friday.

Sources: Shopify Help Center pages on Shopify Catalog, Catalog requirements, optimizing products for Catalog, product category, and adding keywords for SEO.