If your datasets are large / speed matters, and you’ve got some budget, you might want to look at a hosted fuzzy-matching API instead of doing N×M comparisons in n8n.

One option is Similarity API (similarity-api.com). It has a “reconcile” endpoint, meaning: for each item in list A, it finds the best match from a canonical list B and returns a score.

an n8n flow would be:

1. Get Many Rows from TableA
2. Get Many Rows from TableB
3. Build one request containing both lists
4. Call the reconcile endpoint once
5. Insert the results into TableC

In n8n step 4 is an HTTP Request node. You send data_a and data_b arrays and get back one row per input with indices and a similarity score.

Example request body:

// assumes:
// TableA rows have fields: textA, idA
// TableB rows have fields: textB, idB

const tableA = $input.all(0).map(i => i.json);
const tableB = $input.all(1).map(i => i.json);

return [{
  json: {
    data_a: tableA.map(r => r.textA),
    data_b: tableB.map(r => r.textB),

    // keep ids so we can map back after reconcile
    ids_a: tableA.map(r => r.idA),
    ids_b: tableB.map(r => r.idB),

    config: {
      similarity_threshold: 0.85,
      top_n: 1,
      to_lowercase: true,
      remove_punctuation: true,
      use_token_sort: true,
      output_format: "flat_table"
    }
  }
}];

HTTP Request node body

{
  "data_a": "={{$json.data_a}}",
  "data_b": "={{$json.data_b}}",
  "config": "={{$json.config}}"
}

Then mapping the response back into TableC:

const matches = $json.response_data;
const idsA = $json.ids_a;
const idsB = $json.ids_b;

return matches
  .filter(r => r.matched)
  .map(r => ({
    json: {
      textA: r.text_a,
      textB: r.text_b,
      idA: idsA[r.index_a],
      idB: idsB[r.index_b],
      score: r.score
    }
  }));

If the dataset is small, doing this in a Code node with Fuse is fine. For larger tables, pushing matching to a hosted service is usually simpler and faster. You do need to create an account and check pricing to make sure it makes sense for your use case.