DEV Community: Boon

I built a Shopify scraper that detects apps + pulls products in one API call

Boon — Sat, 02 May 2026 11:50:01 +0000

TL;DR — Existing Shopify app detectors (Koala Inspector, ShopScan, Fera, BuiltWith) are Chrome extensions or SaaS dashboards. None do batch. I had 1,200 stores to qualify and View Source + Cmd-F was killing my afternoons, so I shipped an Apify actor that takes a list of Shopify URLs and returns the full app stack (Klaviyo, Yotpo, Judge.me, Loox, ReCharge…) + product catalog + reviews in JSON. No headless browser, ~$0.005 per store, 1,000 stores in 25 minutes. Live here → Shopify Scraper – Apps Spy + Reviews.

The afternoon that broke me

Six weeks ago I was prospecting for a B2B side-project. The hypothesis: "Shopify stores running Klaviyo + a paid reviews app are the right ICP — they spend money on retention tooling, so they will pay for ours."

To validate, I needed a list of Shopify stores and their installed apps.

The Shopify App Store does not give you that. The "stores using X" databases do, but the public ones are stale and the good ones are paid SaaS at $99–499/month for filters I did not need.

So I did what every founder does at 11 PM: I opened View Source on a competitor list, hit Cmd-F, and started typing klaviyo.

It worked. Sort of. I did 40 stores in two hours, then stopped, because I had a list of 1,200.

That night I wrote the first version of what is now Shopify Scraper – Apps Spy + Reviews.

What I actually wanted

Every "Shopify scraper" I found online did one of two things:

Scraped a single store's products via /products.json — table-stakes, dozens of free Apify actors do it.
Spawned a headless browser to fingerprint a marketing site — slow, expensive, and brittle.

I wanted three things in one pass:

Full product catalog (titles, prices, variants, images, vendor, tags) — nothing exotic.
App detection: which third-party Shopify apps are installed (email, reviews, subscriptions, popups, search).
Reviews when a reviews app is detected — pull them via the public API, not by parsing widgets.

And I wanted it to be cheap, because I had ~1,200 stores in my first batch and I planned to run it monthly.

The "no headless browser" decision

The thing nobody tells you about Shopify scraping is that you almost never need a headless browser. The signals you want for app detection live in three places, and all three are reachable with a plain HTTPS GET:

The HTML of the homepage. Shopify apps inject <script> tags from their own CDN. cdn.judge.me, cdn.yotpo.com, loox.io/widget, klaviyo.com/onsite — you grep the HTML and you know.
/products.json. Shopify exposes the full catalog at this path on every store, paginated 250 items at a time. No auth, no headless. (You hit a soft rate limit around 2 req/s per IP, which is fine if you queue politely.)
App-specific public endpoints. Judge.me has a JSON reviews endpoint. Yotpo too. Same for Loox, Stamped, Reviews.io. Once you know which app is installed, you go straight to its API — no DOM parsing.

The whole actor is built around that observation. No Puppeteer, no Playwright, no proxy farm. Just got-scraping, cheerio, and p-queue to keep concurrency civilized.

The result is that scanning a single store costs ~3–6 HTTPS requests and runs in 2 to 8 seconds depending on catalog size. Cost on Apify infra: about $0.005 per store for the "tech stack only" mode.

The architecture (it is small on purpose)

I'll be honest — I almost over-engineered this. My first draft had Redis for de-dup, a queue, retry logic with exponential backoff, and a state machine. Then I deleted all of it.

Here is what shipped:

src/
├── main.js                   # orchestration (p-queue, per-store flow)
├── crawlers/
│   ├── products.js           # /products.json + sitemap fallback
│   ├── apps.js               # detect apps from homepage HTML
│   └── reviews.js            # per-app reviews fetchers
└── lib/
    ├── normalize.js          # canonicalize URLs, normalize product schema
    ├── schemas.js            # zod validation for outputs
    └── billing.js            # Apify pay-per-event charges

A run goes:

Canonicalize the store URL (handles www, custom domains, *.myshopify.com).
Fetch the homepage once. Confirm it is Shopify (the x-shopify-stage header is a giveaway).
From the same HTML, run the app detectors. Each detector is ~10 lines of regex matching against script tags + meta tags + inline JSON.
Fetch /products.json?page=N until you hit the cap or run out of products.
If the user asked for reviews and an installed reviews app was detected, fan out to that app's public reviews API.

That is it. The whole thing is ~900 lines of JavaScript. I run it with node --test for unit tests against snapshots and a tests/smoke-products.mjs that hits 5 real stores end-to-end.

What I learned about app detection

The regex-against-HTML approach has one trap. Shopify themes minify, version, and CDN-rewrite their assets, so you cannot match on a single string. The Klaviyo loader, for example, ships under at least four URL patterns I have seen:

static.klaviyo.com/onsite/js/klaviyo.js
static-tracking.klaviyo.com/onsite/js/...
a.klaviyo.com/media/...
inline _learnq queue calls

You match any of those, and you call it Klaviyo. Same logic for every other app — every detector is an array of patterns, OR'd together, returning a single boolean. I wrote a snapshot test per app with a real store HTML page so a Klaviyo URL change does not silently break detection.

The detectors I shipped on day one:

Email/SMS: Klaviyo, Omnisend, Postscript, Mailchimp, Attentive
Reviews: Yotpo, Judge.me, Loox, Stamped, Reviews.io, Okendo
Subscriptions: ReCharge, Bold, Loop, Skio
Popups & SMS capture: Privy, Justuno, Klaviyo Forms
Search & discovery: Searchanise, Boost, Algolia
Loyalty: Smile.io, Yotpo Loyalty, LoyaltyLion

If you tell me an app I missed, I add a detector. Each one is a 15-minute job.

The pay-per-event pricing problem

Apify lets you charge per event instead of per compute minute. For a scraper that runs in seconds, this is the right model — your customer pays for the rows they get, not for compute time.

The mistake I made on my first push was leaving Apify's default dataset_item event on. Combined with my custom product_extracted event, every product was being charged twice. I caught it in monetization review and removed the synthetic event.

The pricing I landed on:

store_analyzed — $0.003 per store (covers detection + products fetch)
product_extracted — $0.0005 per product
apps_detected — $0.001 per store at standard+
review_extracted — $0.0003 per review

A 500-product store with reviews costs roughly $0.30 end to end. For comparison, the SaaS competitors charge $99 or more for similar lookups, batched and capped.

What surprised me

Three things, in order of how badly I underestimated them.

1. /products.json is more honest than the storefront. It exposes products that are unpublished from the theme but still live (out-of-stock holdovers, B2B-only SKUs). Useful for trend research. Sometimes shocking.

2. Reviews-app detection is a lead signal. A store on Judge.me Free plan vs. Yotpo Premium tells you a lot about their stage. I ended up using this internally to prioritize cold outbound — different pitch for a $30/month stack vs. a $1,200/month stack.

3. People want this as an MCP server. Two of my first three users asked if they could query it from Claude / ChatGPT. I have it on the roadmap. (My GPT Crawler MCP and Vinted MCP Server are the two MCP actors I shipped first; the Shopify one is next.)

How to use it in one minute

// On Apify, paste this in the actor input box
{
  "store_urls": ["https://allbirds.com", "https://gymshark.com"],
  "extract_level": "standard",  // products + apps stack
  "max_products_per_store": 250
}

Output (one record per product, with apps_detected attached):

{
  "store_domain": "allbirds.com",
  "product_title": "Wool Runner",
  "price": 110,
  "available": true,
  "vendor": "Allbirds",
  "apps_detected": {
    "email": ["Klaviyo"],
    "reviews": ["Yotpo"],
    "subscriptions": [],
    "search": ["Searchanise"]
  },
  "product_url": "https://allbirds.com/products/mens-wool-runners"
}

If you want reviews, set extract_level: "full" and a max_reviews_per_product. The actor will route to the correct reviews API based on what was detected.

Direct link, free $5 credit on Apify, no account-creation drama: Shopify Scraper – Apps Spy + Reviews.

FAQ

Is scraping `/products.json` allowed?

Shopify exposes /products.json publicly on every store by default. Stores that disable it (rare) return 404 and the actor logs a skip. The actor never authenticates, never bypasses access controls, and respects standard rate limits.

What about reCAPTCHA or Cloudflare?

For the standard catalog and app-detection flow, no. /products.json and the homepage HTML are not gated. For some reviews APIs, very high request volumes can trigger rate-limits — the actor backs off and retries with jitter.

How is this different from Koala Inspector, ShopScan or BuiltWith?

Koala Inspector, ShopScan and Fera are excellent Chrome extensions for one-store lookups, but none of them do batch — you cannot paste 500 URLs and get a CSV back. BuiltWith is a generic tech-stack tool with broad coverage but its Shopify-app detection is shallow and you cannot pull products in the same call. This actor is purpose-built for Shopify and runs in batch via API: deeper app detection (subscriptions, reviews, popups, search, loyalty), full product catalog, and reviews — all in one pass, billed pay-per-event.

How long does a 1,000-store scan take?

About 25 minutes at default concurrency, costing ~$3 of Apify credits at the standard level. A full run with reviews is closer to an hour and ~$15 depending on review volume.

Can I get one record per variant instead of per product?

Yes. Set include_variants: true in the input and the dataset returns one row per SKU with size/color/price/availability normalized.

What is next

I want to add three things, in order:

Revenue estimation at the pro tier — based on review velocity and product velocity, both of which are observable.
MCP server mode so you can query it from Claude desktop / Cursor.
Theme detection — useful for agency outbound, less useful for me, but I keep being asked.

If you use it and something breaks, ping me — I am the only maintainer and I read every issue. The actor is on Apify Store at kazkn/shopify-scraper-apps-spy.

Tags: #shopify #ecommerce #api #indiehackers

How to Batch-Scrape 10 Vinted Search URLs in One Run: A Reseller's Workflow

Boon — Fri, 24 Apr 2026 15:29:40 +0000

Two weeks ago, a reseller I work with asked me a surprisingly common question:

"I track 12 different brands across Vinted. That means 12 different search URLs, 12 different filter combinations, 12 different countries depending on where inventory is cheapest. Right now I run them one by one. How do I automate all of this without writing orchestration code?"

The short answer: paste all 12 URLs at once.

The tool: Vinted Turbo Scraper.

This article breaks down the exact batch workflow I set up for him — and why it's the most underused feature of the Actor.

📺 Watch the Tutorial

Why Batch URLs Matter (More Than Speed)

Speed is great. But for serious resellers and market researchers, throughput is what actually moves the needle.

Here's the reality of single-URL scraping:

Workflow	Time per URL	Total for 10 URLs	Manual Steps
Run manually, one by one	3–5 min	30–50 min	10 separate runs, 10 separate exports
Batch all URLs in one run	3–5 min total	3–5 min	1 run, 1 export

Most people never think about batching because:

Vinted's own site doesn't suggest it
Most Python scrapers on GitHub are built for single requests
Apify Actors often look like they only accept one input

Vinted Turbo Scraper accepts an array of URLs. Not one. An array. Paste 10, get 10 datasets merged into a single export.

Real-World Use Cases

Before diving into the how-to, here's who actually uses this feature:

Multi-brand resellers — tracking Nike, Adidas, Jordan, New Balance, and vintage Patagonia simultaneously across the same country domain.

Cross-country arbitrageurs — monitoring the same keyword across Vinted.fr, Vinted.de, Vinted.nl, and Vinted.pl to spot price gaps.

Category monitors — running separate searches for Men's Sneakers, Women's Sneakers, and Kids' Sneakers with different size filters.

Deal hunters — setting up 15–20 hyper-specific filter combos (brand + price + size + condition + color) and running them all nightly via Apify's scheduler.

How to Batch-Scrape Vinted URLs: Step-by-Step

Step 1: Prepare your search URLs

This is identical to single-URL mode. For each segment you want to track:

Go to Vinted (any country domain)
Apply filters: brand, size, price range, condition, color, category
Copy the URL from your browser bar
Repeat for every segment you want

Example URL set for a sneaker reseller:

https://www.vinted.fr/catalog?search_text=jordan&price_from=50&price_to=100&size_from=42&size_to=44&status_id=6
https://www.vinted.fr/catalog?search_text=nike&price_from=30&price_to=80&size_from=40&size_to=45&status_id=6
https://www.vinted.de/catalog?search_text=jordan&price_from=40&price_to=90&status_id=6
https://www.vinted.nl/catalog?search_text=nike&price_from=35&price_to=85&status_id=6

Each URL already contains the exact filters you need. No rebuilding required.

Step 2: Configure the Actor for batch mode

Open Vinted Turbo Scraper on the Apify Store
Click Try for free
In the Input tab, locate the searchURLs field
Paste your URLs — one per line, or as a JSON array:

Plain text input:

https://www.vinted.fr/catalog?search_text=jordan...
https://www.vinted.fr/catalog?search_text=nike...
https://www.vinted.de/catalog?search_text=jordan...
https://www.vinted.nl/catalog?search_text=nike...

JSON input (for API/programmatic runs):

{
  "searchURLs": [
    "https://www.vinted.fr/catalog?search_text=jordan&price_from=50&price_to=100",
    "https://www.vinted.de/catalog?search_text=jordan&price_from=40&price_to=90",
    "https://www.vinted.nl/catalog?search_text=nike&price_from=35&price_to=85"
  ]
}

Step 3: Run and export

Click Start. The Actor processes each URL sequentially but without the overhead of browser restart between URLs. Results from all URLs are merged into a single output dataset.

Export options:

CSV — flat table, one listing per row, with an added source_url column showing which search URL each listing came from
JSON — structured object with all fields + source attribution
Excel — same as CSV, formatted for Excel
Google Sheets — live push to a shared spreadsheet
API — consume via the Apify API, perfect for custom pipelines

Step 4: Automate with scheduling (optional but recommended)

Apify has a built-in scheduler. I set mine to run every day at 6 AM CET:

Go to the Actor's Schedules tab in Apify Console
Create a new schedule: Daily at 06:00
Paste your URL array into the schedule input
Set the destination: Google Sheets, webhook, or just store in Apify's key-value store

Every morning, I wake up to a fresh dataset in my Google Sheet. Zero manual work.

What the Output Actually Looks Like

When you batch URLs, the Actor adds one critical field to every record:

{
  "url": "https://www.vinted.fr/items/987654321-nike-air-max-90",
  "title": "Nike Air Max 90",
  "price": 55.00,
  "currency": "EUR",
  "brand": "Nike",
  "size": "43",
  "condition": "Good",
  "seller_username": "paris_sneakers",
  "location": "Paris, France",
  "thumbnail": "https://images1.vinted.net/...",
  "source_url": "https://www.vinted.fr/catalog?search_text=nike&price_from=30&price_to=80",
  "scraped_at": "2026-04-24T06:03:15.000Z"
}

Key field: source_url tells you exactly which search query produced each listing. This is essential when you're running 10+ URLs simultaneously and need to segment results later.

Cost Breakdown for Batch Workflows

Scenario	URLs per run	Avg listings per URL	Total results	Cost per run
Small batch (3 brands, 1 country)	3	400	1,200	$1.80
Medium batch (5 brands, 2 countries)	10	350	3,500	$5.25
Large batch (15+ segments)	15	300	4,500	$6.75

With Apify's $5 monthly free credits, a small batch workflow costs you nothing.

For active resellers running daily large batches: $6.75 × 30 days = ~$200/month. The time saved is roughly 2–3 hours per day of manual scraping, monitoring, and data cleaning. At any consulting rate, the ROI is immediate.

Common Batch Pitfalls (and How to Avoid Them)

Pitfall 1: Mixing country domains in one run

The Actor handles .fr, .de, .nl, .pl, .es, .it, .be, etc. natively. No issue. But be aware that pricing will be in local currencies — EUR for Eurozone, GBP for UK, PLN for Poland. Normalize in your export pipeline or spreadsheet.

Pitfall 2: URLs with too few filters

An overly broad URL (e.g., just search_text=vintage with no price/size filters) can return 10,000+ results per URL. The Actor caps per-URL extraction to prevent runaway costs, but it's better to filter aggressively on Vinted first.

Pitfall 3: Identical URLs

Deduplication happens at the dataset level, but identical URLs waste compute. Check your URL list before running.

Pitfall 4: Expecting real-time inventory

Vinted listings appear and disappear fast — especially underpriced items. A scheduled run every 6 hours catches most opportunities without hitting rate limits.

Integrating Batch Results Into Your Workflow

Here's the exact stack I use with a reseller partner:

Step	Tool	Purpose
1. Scrape	Vinted Turbo Scraper (Apify)	Pull 15 URLs nightly
2. Normalize	Google Sheets (Apify integration)	Clean + currency unification
3. Alert	n8n	Price-drop notifications via Telegram
4. Act	Manual	Buy the listing, message seller, relist

The entire pipeline from "run Actor" to "receive Telegram alert for a €45 Jordan 1" is under 5 minutes.

FAQ

Q: What's the maximum number of URLs per run?

Tested comfortably up to 50 URLs per run. Beyond that, splitting into multiple runs is safer for stability. Each URL is processed sequentially, so it's more about total runtime than URL count.

Q: Does batch mode cost more?

No. Pricing is $0.0015 per result, regardless of how many URLs produced that result. 1,000 listings from 1 URL = $1.50. 1,000 listings from 10 URLs = $1.50.

Q: Can I batch across different Vinted country domains?

Yes. Mix .fr, .de, .nl, .pl, .es, .it, .be, etc. in the same input array. The Actor handles domain detection automatically.

Q: What if one URL fails?

Failed URLs are logged in the Actor's run log. Successful URLs still produce their dataset. No total-run failure from a single bad URL.

TL;DR

Vinted Turbo Scraper accepts multiple search URLs in one run
Results merge into a single export with source_url attribution
Schedule daily runs, push to Google Sheets, build alert pipelines
Pricing is per-result, not per-URL — batching is free in terms of cost structure
Supports all 26 Vinted country domains in a single batch

👉 Launch Vinted Turbo Scraper

Related tools:

Vinted Smart Scraper — Deep seller analytics + cross-country price comparison
Vinted MCP Server — Natural language Vinted queries via AI
How I Scrape 1,000 Vinted Listings in Under 2 Minutes — Speed-focused guide with video tutorial

How I Scrape 1,000 Vinted Listings in Under 2 Minutes (Without Writing a Single Line of Code)

Boon — Fri, 24 Apr 2026 15:14:21 +0000

Two months ago, a friend running a sneaker resale business called me with a very specific problem:

"I need to pull every Jordan 1 listing under €80 in France, Germany, and Spain. I don't know Python. I don't have proxies. And I don't have three days to fight Cloudflare. How do I do this in under five minutes?"

I pointed him to a tool I'd built exactly for this: the Vinted Turbo Scraper on Apify. He had his first CSV ready before he finished his coffee.

📺 Watch the Tutorial in Action

https://www.youtube.com/watch?v=rWtZVDMflbo

The Speed Benchmark Nobody Talks About

Most Vinted scrapers on GitHub advertise "fast" extraction. What that usually means is:

40–120 seconds to authenticate + parse a single page
Another 30–60 seconds per subsequent page
A 403 ban after 200–400 requests because you're hammering Vinted's CDN with a single residential IP

With Vinted Turbo Scraper, I consistently hit ~500 items per minute on country-specific searches (confirmed across Vinted.fr, Vinted.de, Vinted.nl, and Vinted.pl). A filtered search URL returning ~1,000 listings completes in under 2 minutes from URL paste to CSV download.

Here's what a typical run looks like:

Search URL	Filters Applied	Listings Scraped	Total Runtime	Cost
`vinted.fr/catalog?search_text=jordan&price_from=50&price_to=80`	Brand: Jordan, Price €50–€80	1,024	1 min 58 s	$1.54
`vinted.de/catalog?search_text=nike&size_from=43&size_to=44`	Brand: Nike, Size 43–44	876	1 min 42 s	$1.31
`vinted.nl/catalog?search_text=vintage&status_id=6`	Status: Available, Keyword: vintage	2,341	4 min 12 s	$3.51

Key insight: The architecture skips the heavy DOM-rendering overhead. Instead of crawling each listing page with a full browser, Turbo extracts structured data directly from Vinted's internal API endpoints — the same endpoints the mobile app hits. That's where the speed comes from.

Who This Is For (and Who It's Not For)

Use Turbo if you:

Need filtered Vinted data now, not next week
Don't want to manage proxy rotation, sessions, or CAPTCHA solving
Are a reseller, researcher, or analyst who needs structured exports (JSON / CSV / Excel / Google Sheets)
Want to batch multiple search URLs in a single run (I'll cover this in detail in my next article)

Use something else if you:

Need deep seller analytics, trending product tracking, or cross-country price comparison → that's Vinted Smart Scraper
Want to build and maintain your own scraping infrastructure from scratch (you genuinely enjoy fighting anti-bot teams)
Need to scrape private messages or PII (we don't do that, and you shouldn't either)

The Actual Setup. No Code Required.

This is the exact workflow I showed my friend. It takes under three minutes:

Step 1: Build your search URL on Vinted

Go to vinted.com (or any country domain: .fr, .de, .nl, .pl, etc.)
Apply any filters you want: brand, size, price range, item condition, category, color
Copy the URL from your browser bar

That's it. Every filter you applied is encoded directly in that URL. No need to rebuild anything in a form.

Step 2: Paste into the Actor on Apify

Open the Vinted Turbo Scraper Actor on the Apify Store
Click Try for free (you get $5 Platform Credits every month)
Paste your Vinted search URL into the input field
Click Start

Step 3: Download your dataset

Once the status shows Succeeded, go to the Output tab:

Click Export → CSV or JSON for direct download
Or click Google Sheets to push to a live spreadsheet
Or grab the API URL to consume results programmatically in Python, Node.js, or any automation tool

The output structure is flat and predictable — no nested JSON hell:

{
  "url": "https://www.vinted.fr/items/123456789-jordan-1-mid-chicago",
  "title": "Jordan 1 Mid 'Chicago'",
  "price": 75.00,
  "currency": "EUR",
  "brand": "Jordan",
  "size": "44",
  "condition": "Very good",
  "description": "Barely worn. No creases.",
  "seller_username": "sneakerhead_paris",
  "seller_url": "https://www.vinted.fr/member/987654321-sneakerhead_paris",
  "location": "Paris, France",
  "thumbnail": "https://images1.vinted.net/t/01_01234abc.jpg",
  "images": ["https://images1.vinted.net/...", "https://images2.vinted.net/..."],
  "scraped_at": "2026-04-24T10:15:30.000Z"
}

Performance Under the Hood

Here's why this outperforms home-rolled Python scripts:

Factor	Typical Python Scraper	Vinted Turbo Scraper
Authentication	Manual cookie/session mgmt	Auto bootstrap via Playwright (one-time)
Proxy rotation	Manual 3rd-party proxy pools	Built-in Apify residential proxies
Rate-limit protection	None / naive sleep()	Adaptive backoff + request shaping
Data extraction	Regex / BeautifulSoup on HTML	Direct API endpoint parsing (JSON native)
Export	Custom script required	CSV, JSON, Excel, Sheets, or API out of the box
Maintenance	You own every breakage	Managed by the Actor, updated when Vinted changes

The Economics

Pricing is straightforward: $0.0015 per result (so $1.50 per 1,000 listings).

With the free $5 monthly Apify credits, you can scrape roughly 3,300 listings per month at zero cost.

For a small reseller running 20 searches per week at ~500 results each, that's $15/week = $60/month for data that would take 10+ hours to collect manually.

FAQ

Q: Is this legal? Are you scraping private data?

No. We only extract publicly visible listing data — the same information any visitor sees on a Vinted search page. No private messages, no login-required data, no PII.

Q: Will I get IP-banned?

The Actor runs on Apify's infrastructure with residential proxy rotation. In 30 days of active usage, we maintained a 90.8% success rate across 121 runs. Individual bans are handled transparently — failed runs are retried automatically.

Q: Can I schedule this to run daily?

Yes. Apify's scheduler lets you set up recurring runs. I use it to monitor specific keywords ("vintage Patagonia", "Nike Dunk") and get fresh data pushed to a Google Sheet every morning.

Q: What countries are supported?

All 26 Vinted country domains: France, Germany, Netherlands, Poland, Spain, Italy, UK, Belgium, Czech Republic, Austria, Portugal, Lithuania, Luxembourg, Slovakia, Hungary, Romania, Bulgaria, Greece, Croatia.

Try It

If you have a filtered Vinted search URL open right now, copy it and test the Actor:

👉 Launch Vinted Turbo Scraper

For technical documentation, API examples in Python/JS, and integration guides, check the Actor's full README.

Related Tools

Vinted Smart Scraper — Cross-country price comparison, seller analysis, trending products
Vinted MCP Server — Query Vinted data with natural language via Claude/Cursor

Built by KazKN. Questions? Open an issue or DM on X.

The Hybrid Vinted Scraping Architecture That Outperforms Pure Browser Crawls

Boon — Thu, 23 Apr 2026 11:30:16 +0000

The Hybrid Vinted Scraping Architecture That Outperforms Pure Browser Crawls

When you scrape Vinted at scale, you quickly hit a wall.

Not a firewall metaphor. A literal one. Datadome. Cloudflare. Aggressive rate limits. Token rotation that invalidates your session mid-crawl. And if you are still running headless Chromium for every single request, you are burning proxy credits and clock cycles for no reason.

After months of iteration — and enough failed runs to fill a datacenter — the architecture that actually works is hybrid: use a real browser only where Vinted forces you to, then switch to lightweight HTTP for the actual data extraction.

This is how Vinted Turbo Scraper implements that hybrid model, what makes it faster than pure-browser approaches, and why the architecture is the real product.

Why Pure Browser Crawling Is a Trap

Most tutorials tell you to fire up Playwright or Puppeteer, navigate to a Vinted search page, scroll endlessly, and extract DOM nodes. This works for five items. It collapses at scale.

Here is why:

Problem	Browser-Only Impact
Proxy cost	Every image, font, and JS asset loads through your proxy. Bandwidth is not free.
Memory bloat	Chromium instances chew 200-500MB each. At concurrency 5, you are eating gigabytes.
Fingerprint fatigue	Datadome profiles browser behavior. Repeating the same navigation pattern = flag.
Session decay	Cookies and tokens expire. A pure browser crawl does not gracefully re-authenticate.
Speed ceiling	Rendering a full React-powered catalog page takes 2-5 seconds. Per page.

A pure browser crawl is not "robust." It is expensive, slow, and detectable.

The insight is simple: Vinted serves catalog data via an internal JSON API. Once you have a valid session cookie, you can query that API directly with HTTP requests. No rendering. No DOM traversal. No asset loading.

The challenge is getting that cookie in the first place.

The Hybrid Model: Browser for Session, HTTP for Extraction

Vinted Turbo Scraper uses a two-phase approach:

Phase One: Session initialization via Playwright — Navigate to the target catalog page once, let Datadome validate the browser fingerprint, capture cookies, and grab the user agent string.
Phase Two: HTTP API extraction via got-scraping — Use the captured session to fire lightweight JSON API requests, paginating through results at ~200 items per minute.

This is not theoretical. Here is how the crawler initialization blocks media assets to keep proxy usage minimal:

preNavigationHooks: [
    async ({ page }) => {
        await page.route('**/*', (route) => {
            const type = route.request().resourceType();
            // Block images, media, fonts to save proxy bandwidth
            if (['image', 'media', 'font'].includes(type)) {
                route.abort().catch(() => {});
            } else {
                route.continue().catch(() => {});
            }
        });
    }
]

By aborting image and font requests before they hit the proxy, we cut bandwidth consumption by roughly 70%. On metered residential proxies, that translates directly to cost savings.

Translating Vinted Search URLs into API Calls

Vinted search URLs encode filter parameters in query strings: catalog[], brand_id[], size_id[], color_id[], status[], and more.

The internal API expects these same values but with slightly different parameter names and array bracket syntax. The Turbo Scraper extracts and rewrites these parameters automatically:

function translateToApiUrl(urlStr: string, domain: string): string | null {
    const u = new URL(urlStr);
    const params = new URLSearchParams(u.searchParams);

    const arrayMaps: Record<string, string> = {
        'catalog[]': 'catalog_ids',
        'color_id[]': 'color_ids',
        'size_id[]': 'size_ids',
        'status[]': 'status_ids',
        'brand_id[]': 'brand_ids',
    };

    const STRIP = new Set([
        'search_id', 'time', 'search_by_image_uuid',
        'search_by_image_id', 'currency', 'page', 'per_page'
    ]);

    const apiParams = new URLSearchParams();
    const accumulated: Record<string, string[]> = {};

    for (const [k, v] of params.entries()) {
        if (STRIP.has(k)) continue;
        if (arrayMaps[k]) {
            if (!accumulated[arrayMaps[k]]) accumulated[arrayMaps[k]] = [];
            accumulated[arrayMaps[k]].push(v);
        } else {
            apiParams.set(k, v);
        }
    }

    // Critical fix: append brackets for multi-value arrays
    for (const [key, vals] of Object.entries(accumulated)) {
        for (const v of vals) apiParams.append(`${key}[]`, v);
    }

    return `https://www.${domain}/api/v2/catalog/items?${apiParams.toString()}`;
}

This translator is the bridge between the URL your user copies from their browser and the internal API endpoint that returns raw JSON. Without it, you would need users to manually map catalog IDs — which defeats the purpose of a "zero-config" scraper.

The Human-Friendly Mapping Layer

Vinted uses numeric IDs for filters. Users do not know that "Nike" maps to brand ID 53 or that "new with tags" maps to status ID 6.

The actor maintains internal dictionaries that resolve plain text to these IDs:

const BRAND_MAP: Record<string, number> = {
    'nike': 53, 'zara': 12, 'h&m': 7, 'adidas': 14,
    'levis': 10, 'ralph lauren': 88, 'calvin klein': 33,
    'guess': 35, 'puma': 15, 'vans': 16, 'converse': 17,
    'tommy hilfiger': 94, 'lacoste': 93, 'the north face': 114,
    'asics': 631, 'new balance': 267, 'carhartt': 362, 'dickies': 1007
};

const CONDITION_MAP: Record<string, number> = {
    'neuf avec étiquette': 6, 'new': 6, 'new_with_tags': 6,
    'neuf sans étiquette': 3, 'new_without_tags': 3,
    'très bon état': 2, 'very_good': 2,
    'bon état': 1, 'good': 1,
    'satisfaisant': 4, 'satisfactory': 4,
};

const SIZE_MAP: Record<string, number> = {
    '35': 54, '36': 55, '37': 56, '38': 57, '39': 58, '40': 59,
    '41': 60, '42': 61, '43': 62, '44': 63, '45': 64, '46': 65, '47': 66,
    'xxs': 205, 'xs': 206, 's': 207, 'm': 208, 'l': 209, 'xl': 210, 'xxl': 211
};

This lets users pass intuitive inputs like ["Nike", "Adidas"] or ["new", "very_good"] instead of reverse-engineering Vinted's internal taxonomy. The actor falls back to raw numeric IDs for anything not in the map, so power users are not constrained either.

HTTP Extraction Loop: Where the Speed Lives

Once the session cookie is captured, the actor switches to got-scraping for the heavy lifting:

const res = await gotScraping({
    url: apiReqUrl,
    responseType: 'json',
    proxyUrl,
    headers: {
        'User-Agent': userAgent,
        'Accept': 'application/json, text/plain, */*',
        'Accept-Language': 'fr-FR,fr;q=0.9,en-US;q=0.8,en;q=0.7',
        'Cookie': cookieStr,
        'Referer': `https://www.${domain}/`,
        'X-Money-Object-Enabled': 'true',
        'Sec-Fetch-Dest': 'empty',
        'Sec-Fetch-Mode': 'cors',
        'Sec-Fetch-Site': 'same-origin',
    },
    timeout: { request: 15000 }
});

The Sec-Fetch-* headers are not decoration. They signal to Vinted's edge that this is a same-origin AJAX request, not an external scraper. Combined with a matching Referer and the validated Cookie string, the request sails through.

Each page returns 96 items. The loop paginates until data.pagination.current_page >= data.pagination.total_pages or the maxItems limit is hit.

Result: ~200 items per minute sustained, with a memory footprint under 512MB per worker.

Input Schema Deep Dive

The actor accepts minimal but precise JSON input. Here is the exact schema:

{
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "startUrls": "https://www.vinted.co.uk/catalog?catalog[]=1844&brand_ids[]=53&size_ids[]=207&status_ids[]=6&price_from=20&price_to=50&currency=GBP&order=price_low_to_high"
}

Field	Type	Required	Description
`startUrls`	string or array	Yes	One or more Vinted search URLs. Supports batch processing.
`maxItems`	number	No (default: 100)	Cap on results per run. Use for cost control.
`proxyConfiguration`	object	No (recommended)	Defaults to Apify residential proxies. Essential for Datadome evasion.

You can pass multiple URLs as a comma-separated string or an array of objects with url keys. The actor processes them sequentially in a single run, combining outputs into one unified dataset.

Integration Patterns: From Scraper to Pipeline

Raw data is worthless without a destination. The actor integrates with Apify's ecosystem for downstream automation:

Destination	Trigger	Use Case
Google Sheets	Apify integration	Live inventory tracking
Slack	Webhook	Alert team on new listings
Airtable	Zapier/Make bridge	Visual database for resellers
Custom API	Dataset webhook	Push to your own backend
CSV/Excel	Manual download	One-off market analysis

For recurring monitoring, pair the actor with Apify Scheduler. Set it to run every 15 minutes against a filtered search URL and pipe results to a Slack channel or Google Sheet. You catch new listings before manual browsers refresh the page.

Real-World Performance Benchmarks

Here are observed numbers from production runs across different proxy tiers:

Proxy Type	Speed	Reliability	Cost per 1k Items	Best For
Apify Proxy (Datacenter)	~300 items/min	Low (blocks after ~500)	~$0.30	Quick tests
Apify Proxy (Residential)	~200 items/min	High (rarely blocked)	~$1.50	Production runs
Custom Proxy	Variable	Depends on quality	Variable	Power users

The residential proxy is the sweet spot: fast enough for real-time workflows, reliable enough for continuous monitoring, and priced predictably per result.

Architecture Comparison: Browser vs Hybrid vs Pure HTTP

Approach	Speed	Cost	Reliability	Complexity
Pure Browser	~20-40 items/min	High (full asset load)	Medium (detectable patterns)	Low
Pure HTTP	~300+ items/min	Minimal	Low (session requires bootstrapping)	High
Hybrid (Turbo)	~200 items/min	Low (blocked assets)	High (session + retry logic)	Medium

Pure HTTP is fastest on paper, but without a valid session cookie, every request returns a 403. The hybrid approach trades absolute speed for operational reliability — the metric that actually matters when you are running automated workflows.

When to Use Turbo vs Smart Scraper

Vinted Turbo Scraper is part of a two-tool ecosystem. Choose based on your use case:

Feature	Turbo Scraper	Smart Scraper
URL-based input	Yes	No (form-based)
Batch URL processing	Yes	No
Cross-country comparison	No	Yes
Seller analysis	No	Yes
Sold items tracking	No	Yes
Trending discovery	No	Yes
Price monitoring	Yes	Yes (cross-border)
Speed	Faster	Slower (richer data)
Cost	Lower	Higher

Use Turbo when you have a Vinted search URL ready and need structured data fast. Use Smart when you are doing deep market intelligence, seller profiling, or cross-country arbitrage.

Anti-Ban Mechanisms Beyond Proxies

Proxy rotation is table stakes. The actor adds three additional layers:

Request fingerprint rotation via Crawlee — Built-in proxy configuration rotates IPs per session.
Aggressive retry with exponential backoff — maxRequestRetries: 5 with a 30-second handler timeout.
Graceful session recycling — If an HTTP request fails with a 403, the Playwright session is refreshed before retry.

The output is a clean JSON schema with optional lightweight mode:

{
  "id": 8464268321,
  "title": "Levi black skinny jeans 33\" waist",
  "url": "https://www.vinted.co.uk/items/8464268321-levi-black-skinny-jeans-33-waist",
  "price": 20,
  "currency": "GBP",
  "brand": "Levi's",
  "size": "M / UK 12-14",
  "condition": "New with tags",
  "photos": ["..."],
  "favouriteCount": 1,
  "seller": {
    "id": 73959532,
    "username": "maxi83199",
    "profileUrl": "https://www.vinted.co.uk/member/73959532-maxi83199"
  },
  "scrapedAt": "2026-03-24T10:25:41.604Z"
}

Structured. Timestamped. Ready for pipelines.

FAQ: Technical Details

Q: Does this use headless browsers for every request?
A: No. Only for initial session bootstrap. Data extraction uses lightweight HTTP requests via got-scraping.

Q: How many items can I extract per run?
A: The maxItems parameter lets you cap runs. We have tested up to 10,000 items in a single run without memory issues.

Q: Is there a Vinted API this connects to?
A: Vinted does not offer a public API for catalog data. This actor acts as a practical alternative by reverse-engineering the internal endpoints.

Q: Will my IP get banned?
A: With residential proxies and the hybrid architecture, blocks are rare. The actor implements retry logic and session refresh for edge cases.

Q: Can I run this on a schedule?
A: Yes, via Apify Scheduler or cron triggers. Ideal for monitoring new listings.

Q: What output formats are available?
A: JSON (structured), CSV, Excel, or direct API export to integrations.

The Honest Bottom Line

No scraper is "unbanable." Platforms evolve. What the hybrid architecture buys you is time — time between Vinted deploying a new detection mechanism and you pushing an update.

Because this is packaged as an Apify Actor, that update propagates to every user instantly. No pip upgrade. No breaking dependency chains. No "works on my machine."

If you are still maintaining a custom Python Selenium script that breaks every two weeks, you are not scraping Vinted. You are debugging Vinted.

Switch to infrastructure that was built to survive the platform, not chase it.

Ready to extract Vinted data at scale?

Actor: Vinted Turbo Scraper on Apify
Pricing: $1.50 per 1,000 results. No subscription. Free plan covers thousands of items.

Questions about the architecture or want to integrate this into a pipeline? Drop a comment below.

Ne Jamais Rater une Bonne Affaire sur Vinted : Le Système Automatisé en 2026

Boon — Sat, 11 Apr 2026 20:42:15 +0000

🚫 Ne Jamais Rater une Bonne Affaire sur Vinted : Le Système Automatisé en 2026

Tl;dr : Si tu passes 30 minutes par jour à refresh Vinted pour trouver cette veste Carhartt en taille M à moins de 30€ — ton temps vaut plus que ça. Voici le système sans-code qui te notifie en temps réel, sans risque de ban, sans infrastructure, et sans rien payer en plus de ton Apify.

Le problème est simple, la solution est nulle part

Vinted, c'est le flea market de 85 millions d'utilisateurs en Europe. Le problème ? Les bonnes affaires disparaissent en moins de 15 minutes. Tu postes un message pour demander la taille, le vendeur a déjà conclu avec quelqu'un d'autre.

Tu as deux options :

Passer 3h/jour à scroller — c'est ce que font 95% des utilisateurs. Inefficace, chronophage, frustrant.
Automatiser — mais construire son propre scraper en 2026, c'est s'exposer à la protection Datadome de Vinted, aux blocs Cloudflare, aux bans IP, et aux headers qui changent chaque semaine.

J'ai testé la voie #2 pendant 3 mois. Mon script Python a tenu 11 jours avant le premier 403. Le script corrigé a tenu 6 jours. À chaque mise à jour de Vinted, je recommençais de zéro.

La solution : arrêter de construire l'infrastructure quand quelqu'un l'a déjà faite.

L'architecture sans-code qui fonctionne en 2026

Le système repose sur deux briques :

Apify Vinted Turbo Scraper → extraction fiable des listings avec les bons headers et le bypass Datadome intégré
Telegram Bot API → notification push en temps réel sur ton téléphone

Le flux :

[Marque + Prix Max + Taille] → [Apify Actor] → [JSON propre] → [Telegram Bot] → [Notification 🔔]

Pas de serveur. Pas de cron custom. Pas de maintenance.

Étape 1 : Configure le Turbo Scraper sur Apify

Le Turbo Scraper te permet de filtrer par :

{
  "searchTerms": ["Carhartt", "Arc'teryx", "Nike ACG"],
  "priceMin": 5,
  "priceMax": 35,
  "sizeIds": ["m", "38", "40"],
  "country": "fr",
  "sortBy": "created_desc"
}

L'actor renvoie un JSON structuré :

[
  {
    "title": "Veste Carhartt WIP Detroit",
    "price": 29,
    "size": "M",
    "url": "https://www.vinted.fr/items/12345678",
    "seller": "thriftking_92",
    "created": "2026-04-11T14:32:00Z",
    "photo": "https://images.vinted.com/..."
  }
]

Tu récupères ce JSON via le webhook de l'Actor ou via API endpoint.

Étape 2 : Envoie les résultats sur Telegram

2 options, selon ton niveau :

Option A : Zapier / Make (zéro code)

Connecte le webhook Apify → Zapier → Telegram Bot. 10 minutes chrono, fonctionne pour 95% des cas.

Option B : 20 lignes de Node.js (contrôle total)

const TelegramBot = require('node-telegram-bot-api');
const axios = require('axios');

const bot = new TelegramBot(process.env.TELEGRAM_TOKEN, { polling: true });

app.post('/webhook', async (req, res) => {
  const items = req.body;

  for (const item of items) {
    const msg = `
🔔 *Nouvelle trouvaille Vinted !*

*{item.title}*
💰 {item.price}€ — Taille {item.size}
👤 {item.seller}
🔗 {item.url}
    `;

    await bot.sendMessage(process.env.CHAT_ID, msg, {
      parse_mode: 'Markdown',
      disable_web_page_preview: false
    });
  }

  res.json({ status: 'ok', items_processed: items.length });
});

Déploie ça sur Railway, Render ou ton VPS. Coût : ~5€/mois max.

Étape 3 : Automatise le scheduling

Tu n'as pas besoin de tourner ton script 24/7. Configure un run Apify planifié :

Schedule : toutes les 30 minutes
Coût : ~0.02€ par run (actor compute)
Résultat : notifications en temps réel sans server costs

Le coût mensuel réel : 1-3€ pour 1 440 runs/mois. Ton café coûte plus cher.

Ce que j'ai découvert après 6 mois d'usage

Les meilleures deals (marques streetwear, vêtements de sport) postés le matin sont souvent pris avant 10h. Schedule à 6h30, 7h30 et 8h30.
Filtrer par created_desc uniquement te donne les listings des 30 dernières minutes. Plus large = plus de bruit.
Le paramètre sizeIds est clé : Vinted ne filtre pas toujours correctement côté client. Ton actor doit le faire en post-processing.

Le piège à éviter en 2026

Ne construis pas ton propre parser HTTP. Vinted a déployé en 2025-2026 une couche Datadome de 4ème génération qui détecte les headers Selenium, les patterns de navigation automatisés et les IPs de data centers en moins de 3 requêtes.

Le Vinted Turbo Scraper sur Apify utilise des IPs résidentielles rotatives et des fingerprints browsers réels. C'est la différence entre 1h de dev + 2 jours de maintenance versus 10 minutes de config + 0 maintenance.

Tu veux tester en 2 minutes ?

Voici le lien direct vers l'actor Apify :

👉 Vinted Turbo Scraper — Apify Store

Premiers 3€ de compute offerts pour les nouveaux comptes. C'est suffisant pour tester le système complet.

Si tu veux une config Telegram clé-en-main avec le scheduling automatique, contacte-moi en commentaire — je partage le repo GitHub avec la stack complète (Node.js + Railway + Telegram).

Les deals n'attendent pas. Automatise ou regarde-les partir.

[Cet article est écrit à titre informatif. Vérifie les Conditions d'Utilisation de Vinted et la législation locale avant d'automatiser la récupération de données.]

Why building a Vinted scraper from scratch is a trap in 2026

Boon — Wed, 08 Apr 2026 09:23:29 +0000

If you're a data extraction developer or just someone trying to build a Vinted new listings alert system, you've probably noticed something over the past few months: Vinted's anti-bot protection has become completely paranoid.

I tried building my own Vinted scraper in Python last week to monitor some specific vintage deals. Total disaster.

Here is what happens if you try the DIY route right now:

Pure HTTP requests (Requests, HTTPX): Instant 403 Forbidden. Their Cloudflare/Datadome setup immediately flags the TLS fingerprint of standard libraries.
Headless Browsers (Playwright/Puppeteer): It works briefly, but it's incredibly slow and consumes massive amounts of RAM. Plus, Vinted will eventually flag your residential proxy IP if you don't rotate perfectly.

After burning through two different proxy providers and getting blocked anyway, I gave up on maintaining my own infrastructure for this.

While looking for an alternative, I stumbled upon an Apify Vinted actor called Vinted Turbo Scraper.

It essentially acts as a hybrid engine—it bypasses the Datadome checks natively and just returns clean JSON.

Instead of fighting with headers and proxies, this is literally all the code I run now:

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("IV3WPdQlMFG1cwXuK").call(run_input={
    "searchUrl": "https://www.vinted.com/catalog?search_text=carhartt",
    "maxItems": 50
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"])

It’s significantly cheaper than running my own headless cluster and I don't have to deal with WAF bypasses anymore. If you need to scrape Vinted listings efficiently, don't reinvent the wheel.

How to monitor Vinted automatically for new listings (Without getting IP banned)

Boon — Tue, 07 Apr 2026 22:09:34 +0000

If you're into flipping clothes or just trying to snag the best vintage deals, you already know that speed is everything. A good deal on Vinted is gone in literally seconds.

A few weeks ago, I decided to build a simple Python script to send a Discord notification whenever a specific brand was uploaded in my size. I thought it would take an hour. I was wrong.

The Datadome Nightmare

If you've ever tried to build a vinted scraper, you've probably hit a wall of 403 Forbidden errors. Vinted uses heavy anti-bot protections to block automated traffic.

I tried everything:

Rotating free proxies (instantly blocked)
Premium residential proxies (worked for a bit, then got flagged)
Playwright/Puppeteer (way too slow and resource-heavy to run 24/7 on my small VPS)

To truly monitor vinted automatically, you need something that handles TLS fingerprinting natively. I was about to give up on my vinted new listings alert project when I stumbled across a pre-built solution.

The Discovery

Instead of reinventing the wheel and fighting anti-bot systems daily, I found an apify vinted actor that handles the heavy lifting. It's called Vinted Turbo Scraper.

Here is the tool I use now: Vinted Turbo Scraper

It uses a hybrid approach: it uses a real browser context to bypass the WAF, grabs the session tokens, and then uses fast HTTP requests to extract the data at scale.

How I set up my Discord Alert

Using this actor, my code went from a 300-line messy Puppeteer script to a simple API call.

I just set up a webhook in Discord, and use a simple cron job that hits the Apify API every 5 minutes. The actor returns clean JSON with all the new items matching my search URL.

// Simple example of how clean the data is
const items = data.items.map(item => ({
    title: item.title,
    price: item.price,
    brand: item.brand,
    url: item.url
}));

If you're a developer trying to build a vinted vintage deals automation pipeline, save yourself the headache. Stop fighting WAFs and use the right tools for the job.

Scraping Vinted in 2026: Why your Python script keeps getting 403 Errors

Boon — Mon, 06 Apr 2026 22:19:08 +0000

If you've tried to build a vinted scraper recently using requests or BeautifulSoup in Python, you probably hit a brick wall. Specifically, a 403 Forbidden wall.

I spent the weekend trying to scrape vinted to get notifications for some vintage jackets I was hunting. My IP got banned within 10 requests. Vinted uses Datadome and Cloudflare to aggressively block basic scraping attempts.

The problem with DIY Vinted Automation

When you try to monitor new listings automatically, Vinted's WAF checks your TLS fingerprint. Standard HTTP libraries (like Python's requests or Node's axios) leak signatures that scream "I am a bot".

You can try rotating proxies or using Playwright/Puppeteer, but Playwright is too heavy to run a fast loop (you want alerts in seconds, not minutes). I was basically out of memory running 5 browser tabs just for one search query.

The bypass I found

After getting tired of dealing with TLS fingerprinting and headless browser crashes, I looked for managed solutions. I stumbled upon this vinted turbo scraper actor on Apify:
Vinted Turbo Scraper on Apify

It handles the Datadome bypass natively. It uses a hybrid approach:

It uses a real browser to fetch the initial tokens and solve challenges.
It switches to lightweight HTTP requests for the actual data extraction.

This means you get the bypass rate of a real browser but the speed and low cost of an API. It literally returns JSON data from any Vinted search URL instantly.

If you are a vinted data extraction developer or just trying to set up a vinted new listings alert, stop wasting your time fighting Datadome. Just use the Apify actor and plug the JSON into your Discord webhook or database.

It completely saved my weekend project. If you've found other ways to bypass the 403s without spending hundreds on residential proxies, let me know below!

How to Track Vinted Price Drops for Reselling (Automation)

Boon — Sun, 05 Apr 2026 22:26:45 +0000

When reselling on Vinted, finding underpriced items is only half the battle. The other half is tracking when a seller drops their price so you can instantly send an offer.

If you try to monitor multiple closets or search queries manually, you'll lose out to faster buyers.

I used to run a custom Python script to track my favorite items, but Vinted's Cloudflare protection (and Datadome) made it a nightmare to maintain. You get a 403 Forbidden error unless your proxy and TLS fingerprint are perfect.

Instead of maintaining my own scraper and rotating proxies, I found a tool that handles the bypassing for me: the Vinted Turbo Scraper on Apify.

Why it works

It runs a hybrid architecture. It grabs valid CSRF tokens with a real browser session in the background, then uses raw HTTP requests to fetch the data at crazy speeds. You never have to worry about getting blocked.

How I track price drops:

I pass my target Vinted search URLs into the scraper.
I set the Apify actor to run on a schedule (e.g., every 10 minutes).
I push the clean JSON output to a Google Sheet using Make.com (formerly Integromat).
A simple formula compares the new price field with the previous data. If it drops below my target threshold, it sends me a Discord ping.

If you're building any kind of vinted automation, price monitor, or alert system, don't waste time fighting WAFs. Just use a maintained data extraction tool.

How to Build a Vinted to Telegram Alert Bot in 2026 (Zero Code)

Boon — Sun, 05 Apr 2026 05:21:03 +0000

If you're flipping vintage clothes or reselling items from Vinted, you already know that good deals disappear in seconds. Refreshing the app manually is a waste of time.

I wanted to build a simple Telegram bot to send me a notification the exact second a specific brand (like Carhartt or Nike) was posted in my size.

I initially tried coding a Python scraper using requests and BeautifulSoup, but Vinted's Cloudflare and Datadome protection blocked me with 403 Forbidden errors immediately. Playwright worked, but it was incredibly slow and heavy to run 24/7 on a cheap VPS.

Instead of building from scratch, I found the Vinted Turbo Scraper on Apify.

How it works

This tool handles all the proxy rotation and TLS fingerprinting for you. You just give it a standard Vinted search URL, and it returns clean JSON data.

To connect it to Telegram without coding:

Go to Make.com or Zapier.
Set up a trigger: Apify -> Watch for Actor Run.
Add an action: Telegram -> Send a Message.
Map the fields (Title, Price, URL, Image) from the Apify JSON output to your Telegram message format.

That's it. You can schedule the Apify actor to run every 5 minutes. Whenever it finds new items matching your search URL, your Telegram bot instantly pings your phone.

It's by far the easiest vinted automation setup I've tested, and it completely bypasses the anti-bot headache.

Never miss a Vinted deal: How to monitor listings automatically (2026)

Boon — Sun, 05 Apr 2026 04:20:07 +0000

If you are flipping clothes, you already know that the best vintage deals on Vinted are gone in seconds.

I used to refresh the app manually like a maniac. Then I tried building a Python script to scrape Vinted listings, but my IP got instantly banned by Datadome. Vinted's security is no joke right now.

After looking around for a workaround, I stumbled upon the Vinted Turbo Scraper on Apify.

It’s honestly a game changer. You just paste your Vinted search URL (e.g., filtered for Nike, size L, under 20€), and it extracts all the new listings into clean JSON.

Since it handles all the proxy rotation and bypasses Cloudflare automatically, you never get blocked. I hooked it up to a simple Discord webhook, so now I get pinged the second a new item drops.

If you need to monitor vinted automatically and want a reliable apify vinted actor, save yourself the headache of building it from scratch.

How to Bypass Vinted 403 Errors & Cloudflare (2026 Fix)

Boon — Sat, 04 Apr 2026 13:06:46 +0000

If you've tried to scrape Vinted recently using Python (requests) or Node.js (axios), you've probably hit a wall of 403 Forbidden errors or Cloudflare/Datadome blocks.

Vinted's anti-bot system is extremely aggressive. If you try to pull data from their internal API, you need the right x-csrf-token and flawless TLS fingerprinting. A standard headless Playwright setup will get flagged almost instantly unless you're heavily patching the browser.

After spending days trying to rotate residential proxies and tweak headers, I found a much cleaner solution that bypasses the headache entirely.

Instead of fighting the WAF yourself, you can just use the Vinted Turbo Scraper on Apify.

Why it works

It uses a hybrid asymmetric architecture: it runs a real browser session in the background just to harvest the valid CSRF tokens and cookies, and then uses fast HTTP requests to do the actual data extraction.

This means you get the speed of HTTP scraping without getting blocked by Datadome.

How to use it

You just feed it a Vinted search URL (like https://www.vinted.com/catalog?search_text=vintage+nike), and it outputs clean JSON.

{
  "id": 123456789,
  "title": "Vintage Nike Hoodie",
  "price": "25.00",
  "currency": "EUR",
  "brand_title": "Nike",
  "url": "https://www.vinted.com/items/123456789-vintage-nike-hoodie"
}

It's highly optimized for speed, so you can poll it frequently if you're building a Discord sniper bot or an alert system. It handles all the proxy rotation, TLS spoofing, and token refresh logic under the hood.

If you are tired of debugging 403 Forbidden responses, give this vinted automation tool a try. It completely saved my current project.

DEV Community: Boon

I built a Shopify scraper that detects apps + pulls products in one API call

The afternoon that broke me

What I actually wanted

The "no headless browser" decision

The architecture (it is small on purpose)

What I learned about app detection

The pay-per-event pricing problem

What surprised me

How to use it in one minute

FAQ

Is scraping /products.json allowed?

What about reCAPTCHA or Cloudflare?

How is this different from Koala Inspector, ShopScan or BuiltWith?

How long does a 1,000-store scan take?

Can I get one record per variant instead of per product?

What is next

How to Batch-Scrape 10 Vinted Search URLs in One Run: A Reseller's Workflow

📺 Watch the Tutorial

Why Batch URLs Matter (More Than Speed)

Real-World Use Cases

How to Batch-Scrape Vinted URLs: Step-by-Step

Step 1: Prepare your search URLs

Step 2: Configure the Actor for batch mode

Step 3: Run and export

Step 4: Automate with scheduling (optional but recommended)

What the Output Actually Looks Like

Cost Breakdown for Batch Workflows

Common Batch Pitfalls (and How to Avoid Them)

Integrating Batch Results Into Your Workflow

FAQ

TL;DR

How I Scrape 1,000 Vinted Listings in Under 2 Minutes (Without Writing a Single Line of Code)

📺 Watch the Tutorial in Action

The Speed Benchmark Nobody Talks About

The Speed Benchmark Nobody Talks About

Who This Is For (and Who It's Not For)

The Actual Setup. No Code Required.

Step 1: Build your search URL on Vinted

Step 2: Paste into the Actor on Apify

Step 3: Download your dataset

Performance Under the Hood

The Economics

FAQ

Try It

Related Tools

The Hybrid Vinted Scraping Architecture That Outperforms Pure Browser Crawls

The Hybrid Vinted Scraping Architecture That Outperforms Pure Browser Crawls

Why Pure Browser Crawling Is a Trap

The Hybrid Model: Browser for Session, HTTP for Extraction

Translating Vinted Search URLs into API Calls

The Human-Friendly Mapping Layer

HTTP Extraction Loop: Where the Speed Lives

Input Schema Deep Dive

Integration Patterns: From Scraper to Pipeline

Real-World Performance Benchmarks

Architecture Comparison: Browser vs Hybrid vs Pure HTTP

When to Use Turbo vs Smart Scraper

Anti-Ban Mechanisms Beyond Proxies

FAQ: Technical Details

The Honest Bottom Line

Ne Jamais Rater une Bonne Affaire sur Vinted : Le Système Automatisé en 2026

🚫 Ne Jamais Rater une Bonne Affaire sur Vinted : Le Système Automatisé en 2026

Le problème est simple, la solution est nulle part

L'architecture sans-code qui fonctionne en 2026

Étape 1 : Configure le Turbo Scraper sur Apify

Étape 2 : Envoie les résultats sur Telegram

Option A : Zapier / Make (zéro code)

Option B : 20 lignes de Node.js (contrôle total)

Étape 3 : Automatise le scheduling

Ce que j'ai découvert après 6 mois d'usage

Le piège à éviter en 2026

Tu veux tester en 2 minutes ?

Why building a Vinted scraper from scratch is a trap in 2026

How to monitor Vinted automatically for new listings (Without getting IP banned)

The Datadome Nightmare

The Discovery

How I set up my Discord Alert

Scraping Vinted in 2026: Why your Python script keeps getting 403 Errors

The problem with DIY Vinted Automation

Is scraping `/products.json` allowed?