Dataset Join & Merge (VLOOKUP for Datasets)

Join two datasets on a shared key, like a SQL join or a spreadsheet VLOOKUP, without writing a script. Point it at two Apify datasets (or paste two JSON arrays), name the key field (email, sku, id, url, or several fields together), pick a join type, and get one combined table back: every left row enriched with the matching right columns, only the rows that matched, everything from both sides, or just the rows on one side with no match on the other. Download the result as a real CSV or Excel file.

Why use Dataset Join & Merge?

Every scraping or data project ends up with two tables that need to become one, and Apify's storage can't do that on its own:

• Enrich a lead list: scraped companies on the left, your CRM export on the right, joined on domain or email, so you can see plan, owner, or last contact next to each lead.
• Combine two scrapers' output: product listings from one Actor and reviews or prices from another, joined on product URL or SKU.
• Find what's missing: a left anti join returns the rows in list A that do not appear in list B. New leads not yet in your CRM. Products on a competitor's site you don't stock. Contacts who haven't replied.
• Reconcile two exports from different systems that use different field names for the same key (email on one side, contact_email on the other). Supported directly.
• Stack two datasets into one (Union mode) when they have the same shape and you just want one table.

No scraping involved at all, it only processes data you already have, so there's nothing to break when a website changes and nothing to worry about on data-source terms.

How to use it

1. Pick your two tables: an existing Apify dataset for Left dataset and Right dataset, or paste JSON arrays into Left data (inline) / Right data (inline).
2. Set Key field(s) on the left to whatever identifies a row (e.g. email). If the right side calls it something else, set Key field(s) on the right too (e.g. contact_email). Use several fields for a composite key (firstName + lastName).
3. Choose a Join type. The default, Left join, keeps every left row and adds the matching right columns, which is exactly what a VLOOKUP does.
4. Run it. The joined rows land in the dataset; turn on Export result as file for a ready-to-open CSV or Excel download.

Join types, in plain English

Join type	Keeps	Typical use
Left join (default)	Every left row, plus right columns where a match exists	Enrich a list (VLOOKUP)
Inner join	Only rows that exist on both sides	Overlap between two lists
Right join	Every right row, plus left columns where a match exists	Same as left, mirrored
Full outer join	Everything from both sides, matched where possible	One master table
Left anti join	Only left rows with no match on the right	"Who's in A but not in B?"
Right anti join	Only right rows with no match on the left	The reverse
Union	Every row from both sides, stacked (no key needed)	Combine two same-shape datasets

Input

• Left dataset / Right dataset: pick existing Apify datasets via the resource picker (limited-permissions safe, the Actor can only read the datasets you point at).
• Left data / Right data (inline): paste a JSON array directly instead, for one-off joins.
• Key field(s) on the left / right: the field(s) to match on. Right key fields default to the same names as the left.
• Join type: see the table above.
• Key matching: Normalized (default) matches case-insensitively, trims whitespace, and treats 123 and "123" as equal, which is what you want for emails, names and IDs coming from two different systems. Exact is strict.
• Right fields to bring in: optionally only copy specific right columns (like choosing which VLOOKUP columns to return).
• When a field exists on both sides: prefix the right one (right_price), keep left, or keep right.
• If a key matches several right rows: All fans out like a SQL join (one output row per pair); First behaves like a spreadsheet VLOOKUP.
• Add join-status fields: on by default, adds _joinStatus (matched, left_only, right_only) and _matchCount to every row so you can filter afterwards. Turn off for a clean output with only your own columns.
• Export result as file: optional CSV and/or Excel download.

Output

One row per joined (or passed-through) record, for example a left join of a customer list onto a plan lookup:

{
  "email": "BEN@example.com",
  "name": "Ben Okafor",
  "company": "Okafor & Co",
  "plan": "Starter",
  "mrr": 19,
  "_joinStatus": "matched",
  "_matchCount": 1
}

The run's key-value store also holds a JOIN_SUMMARY record with match rates for both sides, counts of matched / unmatched rows, and any warnings (a misspelled key field, rows missing their key, a right side that isn't actually unique). You can download the dataset in various formats such as JSON, CSV, or Excel directly from the Output tab, or turn on the built-in export for a ready-to-open file.

Pricing

Pay-per-event, anchored the same way as every low-maintenance data tool in this line: $0.002 per joined row (a matched left+right pair, the enriched row you actually wanted), $0.001 per passthrough row (an unmatched row kept by a left/right/full/anti join, or any row in Union mode), and $0.01 per file export. Enriching a 1,000-row lead list where 800 rows find a CRM match costs about $1.80, with the CSV download adding a cent. A 5,000-row anti join ("which of these aren't in my CRM yet") that returns 400 unmatched rows costs about $0.40. There's no separate platform-usage charge; it's included.

Tips

• If your match rate comes back lower than expected, check the run's warnings first: a misspelled key field name, or a right side where the key field is missing on many rows, are the two usual causes. The Actor tells you explicitly when none of the rows on one side have the key field at all.
• Use Normalized key matching (the default) unless you specifically need strict matching. Two exports of "the same" email column almost always differ in case or trailing whitespace.
• If the right side should be a unique lookup table but the warnings say keys repeat, either run it through a dedupe step first or set If a key matches several right rows to First so each left row comes out exactly once.
• Turn Add join-status fields off when you'll feed the output straight into another tool that expects only your own columns.

FAQ

Can I join on a field that has a different name on each side? Yes. Set Key field(s) on the left to e.g. email and Key field(s) on the right to e.g. contact_email. The output keeps the left name.

What if a left row matches several right rows? With the default (All) you get one output row per match, exactly like SQL, and _matchCount tells you how many there were. Choose First for spreadsheet-style VLOOKUP behaviour.

Does this deduplicate? No, it joins. If you need deduplication first, run your dataset through a dedupe/cleaning tool and then join the cleaned output here.

Is my data safe? This Actor never sends your data anywhere outside your own Apify account's storage. It doesn't scrape, doesn't call any external API, and doesn't retain anything beyond the run's own output.

If this saved you a manual VLOOKUP or a one-off join script, a review on the Store page helps a lot. Found a bug or want a feature? Use the Issues tab, replies come from a real person, usually within hours.