Parsing Youla Classifieds with ZennoPoster — A Complete Walkthrough

+

A client recently asked me to scrape data from Youla, a popular peer-to-peer classifieds platform in Russia. Its main competitor, Avito, has been around longer and has a bigger user base, but Youla has one killer feature that changes everything: an open API that returns structured JSON. If you have ever tried scraping Avito through browser emulation, you know exactly what kind of nightmare that is. With Youla, you skip all of that. Pure GET requests, minimal code, no proxy rotation every five minutes, and no captcha services eating your budget.

In this article, I will walk through a real production case: what fields I extracted, how I structured the requests, why I chose API over browser, how I handled deduplication, and what export formats worked best. This material assumes you have opened ZennoPoster at least once and understand the difference between visual blocks and C# snippets. If you are a complete beginner, read anyway, but be ready to Google the basics.

What Is Youla and Why Scrape It

Youla is a classifieds marketplace owned by VK (formerly Mail.ru Group). Launched in 2015 as a mobile app, it later got a web version. The platform focuses on individual sellers but also supports business accounts. According to SimilarWeb, Youla pulls in 40-50 million monthly visits — a serious number for the C2C space.

Who needs to scrape Youla:

• Marketers — tracking competitor pricing on specific product categories;
• Real estate agents — collecting active rental and sale listings by area;
• Business analysts — building supply-and-demand reports for specific regions;
• Resellers — finding underpriced goods for flipping;
• SEO specialists — analyzing ad copy keyword patterns and text structure.

Youla vs Avito: Comparing the Two Giants

Before diving into the scraping specifics, let us compare Russia's two largest classifieds platforms. This matters because the platform choice directly shapes your data collection strategy.

Criteria	Youla (Youla.ru)	Avito (Avito.ru)
API-based scraping	Yes, open API with JSON responses	No, only browser or mobile API reverse-engineering
Anti-bot protection complexity	Low — User-Agent header is enough	High — captcha, fingerprinting, aggressive rate-limiting
Speed for 1000 ads	2-5 minutes (via API)	15-40 minutes (via browser)
CPU load	Minimal, no browser required	Heavy, Chrome/Firefox engine needed
Ads per page	~200 (JSON)	~50 (HTML)
Geo-targeting in API	By coordinates and radius	By city/region only
Phone number access	Often directly in JSON	Hidden behind "show" button click

The gap is striking. If your goal is bulk data extraction from a classifieds platform, Youla gives you a massive edge thanks to its API. Avito, especially after 2022, turned into a fortress: captcha on every action, constant DOM structure changes, IP bans after 30-50 requests. Youla, for all its UI quirks, is a dream to scrape.

Why API Instead of Browser

Many beginners in automation start by emulating user actions: open Chrome, navigate to a URL, wait for page load, scroll, extract data via XPath. It seems logical — you are mimicking a human, after all. In reality, it is a dead-end approach for any serious-scale task.

When I scraped Youla, my goal was clear: collect 5000 ads across three cities in a single run. With a browser, that would take at least 90 minutes and consume 8 GB of RAM. Through the API, the same volume finishes in 12 minutes, with ZennoPoster using under 300 MB of memory.

What the API approach gives you in ZennoPoster:

• No browser at all — Chrome, Firefox, or any engine stays idle;
• Structured JSON output — you parse data, not a div-soup HTML mess;
• 5-10x faster — one HTTP request versus a full page load cycle;
• Minimal C# — for simple tasks, ZP built-in JSON parser blocks suffice;
• Zero captchas — the API never shows captcha, unlike the website under heavy requests;
• Stable structure — JSON schemas change far less often than website HTML markup.

GET Request Structure for the Youla API

The heart of the scraping process is a properly constructed GET request. Youla does not require authentication for basic endpoints, does not ask for API keys, and does not impose harsh rate limits. Here is what a typical request looks like:

GET /api/v1/items?category=telefony&location=55.7558,37.6176&radius=10000&sort=date&page=1 HTTP/1.1 Host: youla.ru User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Accept: application/json Accept-Language: en-US,en;q=0.9[/codeblock]

Let me break down every parameter:

Parameter	Purpose	Example
category	Product category slug	telefony, nedvizhimost, avto
location	Search center coordinates	55.7558,37.6176 (Moscow)
radius	Search radius in meters	10000 (10 km)
sort	Sorting order	date, price, distance
page	Result page number	1
priceMin/priceMax	Price range (optional)	1000 / 50000
query	Search keyword (optional)	iphone 12

In ZennoPoster, this is done through the HTTP Request block on the GET tab. You specify the URL with parameters, add headers, and you are done. The response lands in a variable for further processing.

An important detail: Youla returns a maximum of 200 ads per single request. If you need more, paginate by incrementing the page parameter inside a loop. In my project, I set up a while loop with a check: if the response contains an array and its length is greater than zero, increment page by 1 and repeat.

Key Fields Extracted from JSON

The API response comes in JSON format. Here are the key fields I extracted in my case:

{ "items": [ { "id": "abc12345", "title": "iPhone 12 Pro 128GB", "price": 65000, "currency": "RUB", "description": "Excellent condition, full kit...", "phone": "+7 (999) 123-45-67", "location": "Moscow, Oktyabrskaya metro", "photos": [ {"url": "https://img.youla.ru/.../1.jpg"}, {"url": "https://img.youla.ru/.../2.jpg"} ], "created": "2024-01-15T10:30:00Z", "url": "https://youla.ru/moskva/telefony/iphone-12-pro-abc12345", "views": 342, "seller_name": "Alexander" } ] }[/codeblock]

Each field is extracted using the JSON Parsing block. I specify the path: for the title — items.[*].title, for the price — items.[*].price, and so on. ZennoPoster iterates over the array automatically and populates lists with values. After that, it is just a matter of merging lists into a table.

\u{201c}

When a client asks to collect seller phone numbers — that is the sweetest part. Avito hides them, Youla often exposes them right in the JSON. No extra requests, no clicking "show number" buttons. Just grab and enjoy life.

Blocks vs C#: Which Approach to Choose

ZennoPoster offers two paths for solving any task: building logic from built-in visual blocks or writing C# code in snippets. Each approach has its merits.

For the Youla project, I chose a hybrid approach. The main flow uses blocks: they are visual, easy to debug through step-by-step execution. But when you need to parse complex nested JSON with conditions, C# is irreplaceable. Three lines of LINQ do what would take a dozen comparison and filtering blocks.

When to use blocks:

• Simple linear parsing without branching logic;
• Rapid prototyping — assemble and test a hypothesis in 20 minutes;
• Handing the project to a colleague who does not write C#.

When to use C#:

• Conditional filtering (price above X AND city equals Y);
• Working with nested arrays and dictionaries;
• Mathematical operations on collected data;
• Exporting to custom formats (custom XML, Excel via EPPlus).

// C# snippet example for price filtering var items = JArray.Parse(project.Variables["json_response"].Value); var filtered = items .Where(i => (int)i["price"] > 5000 && (int)i["price"] < 100000) .Select(i => new { title = i["title"].ToString(), price = (int)i["price"], phone = i["phone"]?.ToString() ?? "" }) .ToList(); project.Variables["result_count"].Value = filtered.Count.ToString();[/codeblock]

The good news: you can combine both approaches in ZennoPoster. The main flow stays on blocks, while complex operations are outsourced to separate C# snippets. The template remains readable and maintainable.

Data Collection: Step-by-Step Algorithm

Using my favorite software, ZennoPoster, I grab the necessary elements for GET requests to the Youla API, then parse the JSON response and insert the data directly into a table or a list. The simplest approach is to collect all data first and then sort it into columns — this way you avoid the risk of losing important data during the process.

Here is the step-by-step algorithm I used:

1. Build a list of cities with coordinates using the Table block in ZP. Moscow, Saint Petersburg, Novosibirsk — each with its own radius.
2. For each city, run a page loop: send a GET request, receive JSON.
3. Parse JSON through the "JSON Parsing" block — fields: title, price, phone, description, photos, url, location, date.
4. Store everything in intermediate Lists (List in ZP), one list per field.
5. After the loop finishes, merge lists into a Table: titles into the first column, prices into the second, and so on.
6. Run Duplicate Removal — a built-in ZP function, comparing by ad URL.
7. Export the result to Excel (XLSX) via the "Save Table" block.

The output is a clean table ready for analysis. The client is happy, and I did not waste nerves on captcha circumvention and XPath debugging.

Error Handling and Failure Protection

Any script that talks to an external API must handle failures gracefully. Youla is no exception. Sometimes the server responds with 502 Bad Gateway, sometimes the field format changes (new fields appear, old ones disappear), sometimes the connection simply drops.

Here is what I built into the project for stability:

• HTTP status check. After each request, I verify the response code. If 200 — proceed. If 429 (rate limited) — wait 30 seconds and retry. If 5xx — up to three retries with a 10-second pause.
• JSON validation. Before parsing, I check that the response is valid JSON, not an error HTML page or an empty string.
• Empty field protection. If phone is missing — write "not specified" instead of leaving an empty cell. The client needs to distinguish "no data" from "forgot to collect."
• Logging via project.Log. Every problematic request gets logged with the page number and error code. After the run, you can quickly assess the scope of issues.
• Duplicate removal. ZennoPoster has a built-in deduplication feature — I compare by ad URL, since the same item may appear in different search queries (for example, across adjacent categories).

Despite all the advantages of this data collection approach, you must always check the final result for errors. I do not mean calling every phone number in the listings to verify accuracy. Just scan the new list visually and manually adjust or remove entries as needed.

Export Formats: Where to Output Results

ZennoPoster supports several data export formats. The choice depends on what happens next with the data.

Format	Pros	When to use
Excel (XLSX)	Great for analysis, filtering, pivot tables	Client delivery, internal analytics
CSV	Lightweight, universally compatible	CRM import, databases, Google Sheets
JSON	Preserves structure and nesting	Further script processing, API integration
Google Sheets (via API)	Accessible anywhere, real-time collaboration	Team data workflows

In my case, the client wanted Excel — the classic choice. But if you are collecting data for automated import into your own database, JSON is the right pick.

Speed Optimization Tips

Here are several tricks I have refined over years of working with ZennoPoster and API scraping:

• Accumulate in lists first, then transfer to table. Do not touch the table on every loop iteration — it is slow. Build up data in lists, then move it to the table in a single operation.
• Disable unnecessary logging. By default, ZP logs every tiny action. At scale, this creates noticeable lag. Keep only error-level logging.
• Use multithreading. If you are scraping multiple cities, run them in parallel. ZennoPoster supports multi-threaded execution out of the box.
• Cache category lists. Category lists do not change for years. Load them once at project start and store them in a variable instead of hitting the API for every small lookup.

Frequently Asked Questions

Is it legal to scrape Youla via API?

Formally, it is a gray area. The open API does not require authentication, but the terms of service may restrict automated collection. Always review the platform's current rules. Use data for internal analytics, not to build clone sites. In practice, thousands of companies scrape classifieds daily for price monitoring and market analysis.

Can I scrape Youla without ZennoPoster?

Absolutely. Any HTTP client works: Python with the requests library, Node.js with axios, even curl from the command line. ZennoPoster is simply more convenient for non-programmers thanks to its visual editor and built-in JSON processing blocks. If you write Python, the task is solvable in about 50 lines of code.

Do I need proxies for scraping Youla?

For small volumes (up to 1000 ads per run), proxies are unnecessary. For intensive scraping (10,000+ ads per day), I recommend a pool of 3-5 proxies with rotation. ZennoPoster supports proxies natively — you can specify a list and configure rotation by timeout or request count.

How often does the Youla JSON structure change?

Less frequently than the website HTML, but changes still occur — roughly 1-2 times per year. I recommend running a test scrape on a single page quarterly and verifying the field list. If something disappears or gets renamed, you adjust paths in the JSON Parsing block in five minutes.

How many ads can I collect in a single run?

It depends on the number of pages in the results. Youla returns up to 200 ads per page, with a maximum depth of about 50 pages. The theoretical limit is 10,000 ads per single query. In practice, you rarely need more than 2,000-3,000. My personal record is 8,500 ads in 25 minutes.

What if Youla blocks my IP?

IP blocks are rare on Youla, unlike Avito. If it happens, switch proxies or restart your router (for dynamic IPs). As a last resort, add delays between requests: 2-3 seconds per page, and blocks will stop.

Can I scrape Youla's mobile API?

Yes, and in some cases the mobile API returns slightly more data (for example, precise seller geolocation). However, the web API covers 95% of needs. For the mobile API, you will need to spoof a mobile User-Agent header.

How does ZennoPoster scraping differ from a Python script?

A Python script is easier to deploy on a server, cheaper (free vs a paid ZP license), and simpler to automate via cron. ZennoPoster wins on visual debugging, built-in tools (captcha services, browser emulation, scheduler), and a low entry barrier for non-programmers. The choice depends on your skills and requirements.

Is it safe to call the Youla API from ZennoPoster?

Yes, these are standard HTTP requests — nothing shady. ZennoPoster does not send your data to the developers. The only risk: if you exceed rate limits, your IP may be temporarily blocked. This is solved with proxies.

Can I scrape archived listings from Youla?

The API returns only active listings. Closed and archived ones are not accessible via API. If you need price history, set up regular collection runs and store snapshots yourself — for example, once a day.

Scraping Youla with ZennoPoster is one of those tasks that looks intimidating only until your first successful run. Then you realize: the API returned JSON, you parsed JSON, the data landed in columns — and that is it. No magic. The key is a well-constructed GET request, careful field extraction, and not forgetting about deduplication.

Download ZennoPoster (official site)