Dataset Builder: Structured Data Extraction Without Code

Written by the RTILA Team — the engineers and product builders behind RTILA X, building web automation software since April 2020.

Dataset builder web scraping is the fastest way to turn messy, unstructured web pages into clean, usable spreadsheets or JSON without writing a single line of code. In RTILA X, the Dataset Builder feature handles everything from selecting repeating page elements to applying transformations that normalize your output. If you have ever copied product names, prices, or image URLs from a website by hand, this guide will show you how to automate that process in minutes. We will cover the item_selector, the properties array, property types, advanced rules like required_fields and deduplicate_by, and we will walk through a practical e-commerce example. You will see how structured data extraction works in the real world and why web scraping without code is not just possible, but reliable and repeatable.

What Makes RTILA X’s Dataset Builder Different?

When we built the Dataset Builder, we started with a simple goal: you should be able to point at a set of similar elements on a page and get a structured dataset back without configuring a parser. Most competitors force you to write XPath or CSS selectors by hand for every field. RTILA X flips that model. You define one repeating container with an item_selector, then you add individual properties for the data points you want inside each container. That is it.

In our testing on a live demo shop with 48 product cards, we configured a complete dataset in under four minutes. We extracted product title, price, rating, image URL, and product link for all 48 cards. No JavaScript, no HTML parsing code, no browser console. The entire configuration lived in the Dataset Builder panel. You can save that configuration as part of a project and rerun it whenever the site changes. That is the core value of dataset builder web scraping with RTILA X: you build once, extract many times.

Unlike cloud-based scraping tools, RTILA X runs locally on your machine. Everything happens inside the Tauri v2 shell with the Deno + Patchright engine. Your data never passes through a third-party server unless you choose to send it somewhere via Trigger Chains. This local-first architecture also means you can schedule extractions with the Task Scheduler or export standalone bots that run on any Windows, macOS, or Linux device.

The Core: item_selector and the Properties Array

At the heart of the Dataset Builder is the item_selector. This is a CSS selector that matches the repeating element you want to capture. For a typical product listing page, the item_selector might be .product-card or article.product. For a search results page, it might be .search-result-item. The key rule is that every item matched by the item_selector contains the same set of inner elements you plan to extract.

Once you define the item_selector, you build a properties array. Each property is a single field in your output dataset. You give it a name, a property type, and a selector (or a path depending on the type). RTILA X supports these property types out of the box: text, html, attribute, property, count, page_url, selector_path, list, and index. You can read more about how each type behaves on the property types reference, but here is a quick overview:

• text grabs the visible text inside the matched element.
• html returns the raw HTML of the element.
• attribute extracts the value of a specific HTML attribute, like href or src.
• property reads a JavaScript property from the element.
• count returns the number of elements matched by a nested selector.
• page_url captures the URL of the current page.
• selector_path stores the CSS path of the element relative to its item.
• list collects multiple values into an array.
• index gives you the zero-based position of the item within the item_selector set.

For most product scraping tasks, you will use text, attribute, and page_url. For example, to extract a product title, you set the property type to text and the selector to h2.title. To extract the product link, you set the type to attribute with the attribute name href and the selector a.product-link. The properties array can have as many fields as you need, and you can rename them to anything that makes sense for your final CSV, JSON, or database export.

One thing our support team sees often: people forget that property selectors are relative to the item_selector, not to the whole page. In RTILA X, every property selector runs inside each matched item. So if your item_selector is .product-card, a property selector h2.title will look for h2.title inside each .product-card, not across the entire document. This relative scoping is what makes the properties array so clean and predictable.

Advanced Dataset Rules: required_fields, deduplicate_by, and Parent Inheritance

Real websites are messy. Sometimes a product card is missing a price, or two cards share the same product ID. That is why the Dataset Builder includes three rules that make structured data extraction robust: required_fields, deduplicate_by, and parent dataset inheritance.

required_fields is a simple allowlist. You mark certain properties as required. If an item does not contain a required property, RTILA X skips that item entirely instead of adding a row with missing values. For example, you could mark price as required. Any product card without a price element is ignored. This keeps your output clean and prevents empty rows from breaking downstream tools.

deduplicate_by removes duplicate rows based on one or more property names. In e-commerce, the same product might appear twice on a page because of a “sponsored” listing and an organic listing. If you deduplicate by product_link or product_id, RTILA X keeps only the first unique occurrence. The result is a dataset without redundant entries.

Parent dataset inheritance is a feature we introduced based on user feedback from our AppSumo launch (116 reviews, 4.7/5 at the time). When a page contains a parent element with shared metadata, you can define a parent dataset that applies to every child item. For instance, a category page might have a breadcrumb like “Home > Electronics > Laptops”. You can extract the category name once as a parent dataset, then automatically attach it to every product row. This avoids extracting the same breadcrumb from each product card and keeps your data normalized.

Another advanced capability is nested list properties with css=self. Introduced in version 8.3.0, this lets you extract a list of values inside each item without breaking the item_selector. For example, a product card might have multiple color swatches. You set a property type to list and use css=self to tell RTILA X that the nested list should be collected from the current item context. The result is an array of color names per product. This is particularly useful for product variants, tag clouds, or any repeating sub-element inside a main item.

The fallback selector chain is the last piece of the reliability puzzle. When RTILA X finds zero items with your primary item_selector, it automatically tries a series of fallback selectors you define. This is perfect for sites that change their class names between page loads or use different markup for mobile versus desktop. Instead of failing silently, the Dataset Builder falls back to the next selector in the chain. You can add up to five fallback selectors per item_selector. In our testing, this reduced failed extractions by roughly 70% on sites with dynamic class names.

A Practical Example: E-commerce Product Cards Without Code

Let us walk through a real workflow. Suppose you want to build a competitor price list from an online store. The store has a category page with 100 product cards, each showing a name, price, image, and rating. You want a CSV with these columns: title, price, image_url, rating, page_url.

First, open RTILA X and start a new project. Add a goto command to navigate to the category URL. Then add an extract_data command and open the Dataset Builder panel.

Set your item_selector to the CSS class that wraps each product card. In this example, we will use .product-grid-item. If you are unsure, right-click any product card in the browser preview and choose “Inspect”. The class name will appear in the dev tools. Enter that class as the item_selector.

Next, build your properties array:

• title — type text, selector .product-title
• price — type text, selector .price-current
• image_url — type attribute, attribute src, selector img.product-image
• rating — type text, selector .star-rating
• page_url — type page_url (no selector needed)

Mark price as required so any card missing a price is skipped. Deduplicate by page_url to remove repeated product listings.

Click “Run”. RTILA X will wait for the page to load, find all items matching .product-grid-item, extract the five properties for each, and return a dataset. You can preview the first 20 rows directly in the app. If the page uses infinite scroll, add an infinite_scroll command before extract_data to load all products automatically.

The output appears as a table. From there, you can export to CSV, JSON, or send it to a Trigger Chain for further processing. For example, you could use a transformation to remove the currency symbol from the price, or you could send the data to Google Sheets via a google_sheets trigger.

This is web scraping without code in action. You never touched a selector engine, never wrote a loop, and never worried about pagination logic. The Dataset Builder handled the structured data extraction end-to-end.

How Transformations Improve Your Dataset

Extracting raw text is often not enough. Prices could include currency symbols, dates might be in different formats, and URLs might be relative. That is why RTILA X includes 11 transformation types that you can apply to any property before the dataset is saved. You can trim whitespace, add a prefix or suffix, replace text, use regex, extract parts of a string, cast data types, parse JSON, extract JSON paths, run custom scripts, or join multiple values.

For our e-commerce example, suppose the price property returns $1,299.00. You want a numeric value for sorting. You can add a transformation to price with type replace to remove the dollar sign and commas, then a cast transformation to convert the string to a number. The result is 1299.00 as a float. You can read the full list of transformation types in the transformations guide.

Transformations are applied in the order you define them, so you can chain several together. They run automatically every time you extract the dataset, so your output is always clean without extra manual steps.

Why This Matters for Your Daily Work

You might be thinking, “I can already use a generic scraping tool.” Here is what sets RTILA X apart in practice. Because the Dataset Builder is part of a larger automation platform, you can combine it with other commands like http_request, crawl_links, and run_script. You can schedule a daily extraction that checks a competitor’s pricing page and alerts you via Slack when a price drops below a threshold. You can build a standalone bot that runs on a colleague’s machine without them needing RTILA X installed. You can even export the dataset directly to PostgreSQL, MySQL, or Snowflake using Trigger Chains.

The local-first architecture means your scripts and datasets stay on your machine unless you choose to share them. Our lifetime pricing (starting at $149 for Business 1 Device) means you are not paying a monthly subscription for servers you do not need. And the 60-day money-back guarantee means you can test everything on your own terms.

In our experience building RTILA X since 2020, the most common reason people abandon no-code scraping tools is that the tool breaks when a site changes. The fallback selector chain and required_fields together solve that problem. Combined with Checkpoint & Resume, which allows you to resume a failed extraction from the exact row where it stopped, the Dataset Builder is built for production use, not just one-off experiments.

Conclusion: Start Extracting Structured Data Today

Dataset builder web scraping is the fastest path from a messy webpage to a clean, structured dataset. With RTILA X, you define an item_selector, add a properties array, apply transformations, and let the tool handle the rest. You can extract text, attributes, nested lists, and page URLs from any repeating element. Advanced rules like required_fields, deduplicate_by, and parent dataset inheritance keep your output accurate. Fallback selectors keep it reliable even when the site changes. And because it is all local-first, you own your data and your automations.

We tested this workflow on real e-commerce sites during our development sprints, and we continue to use it internally for market research. The Dataset Builder is not a side feature—it is the core of what makes RTILA X a serious web automation tool. If you are ready to try it, download RTILA X for free from the download page. The Free Community plan gives you unlimited runs on one device, no credit card required. Build your first dataset today and see how much time you reclaim.

FAQ

Can I extract data from a website without writing any code using RTILA X?

Yes. RTILA X’s Dataset Builder is designed specifically for web scraping without code. You select an item_selector, define your properties with point-and-click configuration, and run the extraction. No JavaScript, Python, or CSS knowledge is required. The tool handles all the browser automation behind the scenes using the Deno + Patchright engine. If you can right-click and inspect an element, you can build a dataset.

What property types does the RTILA X Dataset Builder support?

The Dataset Builder supports nine property types: text, html, attribute, property, count, page_url, selector_path, list, and index. You can combine them in any order within a properties array. For example, use text for product names, attribute for image URLs, page_url for the current page link, and list for multiple tags per item. Each type has a specific purpose and is documented in the property types reference.

How do I handle websites where the product card layout changes between visits?

RTILA X includes a fallback selector chain specifically for this scenario. When your primary item_selector matches zero elements, the Dataset Builder automatically tries each fallback selector you have defined. You can add up to five fallbacks per dataset. Additionally, you can use required_fields to skip items that are missing critical data, and deduplicate_by to remove duplicate rows caused by layout variations. In our testing, these three features together reduced failed extractions by about 70% on sites with dynamic class names.

---

Written by the RTILA X team. We build and test every feature we write about on real websites, every week.