Fuzzy List Reconciler - VLOOKUP That Tolerates Typos

Fuzzy List Reconciler is a VLOOKUP that tolerates typos. Give it two lists (CSV or JSON), tell it which key column(s) to join on, and it returns the matched pairs with a similarity score, plus everything that didn't match and the near-misses just below your threshold — so you can reconcile messy data from two sources without writing any code.

It runs on the Apify platform: call it from the API, an AI agent (via Apify MCP), Make/Zapier integrations, or on a schedule. No accounts, no scraping, no personal-data harvesting — it only processes the two lists you supply.

What does Fuzzy List Reconciler do?

Real-world lists never line up exactly. Acme Corp in one export is Acme Corporation in another; José becomes Jose; John Smith becomes Smith, John. A plain join drops all of those. This Actor uses string-similarity matching (Jaro-Winkler, Levenshtein, token-sort, token-set) with normalization (accent folding, punctuation stripping, whitespace/case) to match records that a human would call "the same", and gives every pair a 0–1 score so you stay in control of how strict the match is.

Typical jobs:

• Reconcile two data exports — CRM vs billing, vendor list vs accounting system.
• Enrich a list — attach revenue/IDs from list B onto the closest name in list A.
• De-duplicate across sources — find the same entity spelled differently in two files.
• QA an import — see which rows would fail to match before you load them.

Why use Fuzzy List Reconciler?

• No setup, API-callable. Desktop options (Excel Fuzzy Lookup, OpenRefine, Python rapidfuzz) need installs and scripting. This runs in the cloud and returns clean JSON.
• Agent-friendly output. Concise, flat, structured records — no HTML blobs — ready for LLM agents through Apify MCP.
• You tune the strictness. Pick the algorithm, threshold, and whether it's 1:1, VLOOKUP- style, or many-to-many.
• See the near-misses. Rows that almost matched are reported separately so you can lower the threshold with confidence instead of guessing.

How to use Fuzzy List Reconciler

1. Paste or link your left list and right list (JSON array, CSV text, an http(s) URL to a file, or base64:-prefixed content — format is auto-detected).
2. Set Left key column(s) and Right key column(s) — the fields to match on. Use a comma-separated list for composite keys (e.g. first_name,last_name).
3. Pick an algorithm and a threshold (0.85 is a good start).
4. Choose a match strategy (1:1 reconcile, VLOOKUP-style, or all pairs above threshold).
5. Run it, then download the results as JSON, CSV, Excel, or HTML.

Input

Field	Type	Description
leftData	string	First list: JSON array, CSV text, http(s) URL, or base64: content.
rightData	string	Second list, same accepted formats.
leftKey	string	Column(s) in the left list to match on (comma-separated for composite keys).
rightKey	string	Column(s) in the right list — must have the same number of columns.
algorithm	enum	jaro_winkler (names), levenshtein (edit distance), token_sort (word-order agnostic), token_set (subset/superset).
threshold	number	Minimum similarity (0–1) to count as a match. Default 0.85.
matchStrategy	enum	best_one_to_one, best_per_left (VLOOKUP), or all_above_threshold.
normalize	boolean	Fold accents, strip punctuation, collapse whitespace, lowercase. Default true.
nearMatchMargin	number	How far below the threshold to still report a "near match". Default 0.15.
includeUnmatched / includeNearMatches	boolean	Toggle unmatched / near-match records in the output.

Input example

{
  "leftData": "[{\"company\":\"Acme Corp\"},{\"company\":\"Globex Inc.\"},{\"company\":\"Initech\"}]",
  "rightData": "name,cik\nAcme Corporation,111\nGlobex,222\nUmbrella LLC,333",
  "leftKey": "company",
  "rightKey": "name",
  "algorithm": "jaro_winkler",
  "threshold": 0.85,
  "matchStrategy": "best_one_to_one"
}

Output

Each dataset record has a type of matched, near_match, unmatched_left, or unmatched_right. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

[
  {
    "type": "matched",
    "similarity": 0.9125,
    "algorithm": "jaro_winkler",
    "left_index": 0, "right_index": 0,
    "left_key": "acme corp", "right_key": "acme corporation",
    "left":  { "company": "Acme Corp" },
    "right": { "name": "Acme Corporation", "cik": "111" }
  },
  {
    "type": "unmatched_left",
    "left_index": 2,
    "left_key": "initech",
    "left": { "company": "Initech" },
    "best_candidate_index": 1,
    "best_candidate_key": "globex",
    "best_similarity": 0.4365
  },
  {
    "type": "unmatched_right",
    "right_index": 2,
    "right_key": "umbrella llc",
    "right": { "name": "Umbrella LLC", "cik": "333" }
  }
]

Output fields

Field	Description
type	matched | near_match | unmatched_left | unmatched_right.
similarity	Similarity score (0–1) for matched / near-match pairs.
algorithm	Algorithm used for scoring.
left / right	The full original records from each list.
left_key / right_key	Normalized key strings that were compared.
left_index / right_index	Zero-based positions in the input lists.
best_candidate_key / best_similarity	For unmatched-left rows: the closest right row and its score.

Pricing / cost estimation

This Actor is billed pay-per-event: one event per non-empty output record (matched pair, near-match, or unmatched row). Empty rows are never charged, and the run honors your max-charge cap. Reconciling two ~500-row lists produces roughly 500–1,000 records. Want only the hits? Set includeUnmatched and includeNearMatches to false to reduce billed records.

Tips and advanced options

• Names: start with jaro_winkler at 0.85. Reordered words (John Smith / Smith John): use token_sort. Subset/superset (IBM / IBM Corporation): use token_set.
• Too many false matches? Raise the threshold. Missing obvious matches? Lower it and inspect the near_match records first.
• Use best_per_left when list B is a lookup table that may match many rows in list A (VLOOKUP). Use best_one_to_one for a true reconciliation where each row is used once.

FAQ and support

• Does it scrape anything? No. It only processes the two lists you provide — no websites, no logins, no personal-data collection.
• How big can the lists be? Matching is pairwise (list A × list B), so very large pairs grow in cost/time; split huge jobs into batches.
• Found a bug or want a feature? Use the Issues tab on the Actor page.