n8n Recipe Scraper: Issues with Splitting JSON Ingredients and Supabase Inserts

Below is some guidance on both issues you described:

---

1. Splitting the JSON Node Containing Ingredients

When you want to split a JSON node’s output into multiple items for further processing (for example, one ingredient per item), you need to ensure that the node you’re splitting actually outputs an array. Here are some common points to check:

• Ensure Proper Array Structure:
  Confirm that the JSON node (or the previous node that supplies your ingredient data) returns an array. If the ingredient data is nested inside an object, you may need to reference that field using dot notation (for example, using an expression like {{$json.ingredients}}).

• Use a Splitting Node:
  If you’re trying to process each ingredient individually, consider using the Loop Over Items (Split In Batches) node. This node takes in the JSON array and outputs items one batch at a time. Even if your workflow doesn’t really require batching (i.e. one item per batch), it’s the standard method for “splitting” an array into multiple executions.

• Double-check Your Expression:
  When targeting nested fields, remember that you must write the property key in dot-notation as text within the node settings—not as an expression in some cases. For instance, if your ingredients are under data.ingredients, you might need to reference it exactly as that.

If no output is generated and you see errors, it’s often because the node isn’t getting the expected array. Try adding a Set node before the splitting to inspect the exact structure of the JSON data.

---

2. Design Pattern for Merging Data After the Split

Your expectation is correct with one important detail:

• Node Execution per Item:
  In n8n, when you split an array into individual items with a Loop Over Items (or similar) node, every subsequent node receives the data for its item. That means your second Supabase node will indeed run once per split item.

• Data Merging Behavior:
  n8n automatically passes along all data from previous nodes unless you change that behavior. If you have data from a Supabase insert (say, for the recipe) that you need by every ingredient record, that data is merged into each item’s context. This allows you to reference fields from both the split ingredient and the earlier recipe insert.

So, if your connections are set up so that the split goes into the second Supabase node—and that node is connected to the previous Supabase node—it will process each ingredient item with the merged data from two nodes earlier. This is the intended behavior.

---

Recap & Recommendations

• For the splitting error:
  Verify that the node feeding into the split actually outputs an array and use a Loop Over Items / Split In Batches node if necessary. Also, check your field reference (using the proper dot notation) so that the ingredient array is correctly targeted.

• For the data merging/design pattern:
  Yes, n8n will run the second Supabase insert once for each split ingredient. Each execution will contain the merged data from previous nodes (including the earlier Supabase insert) as long as the connections are properly configured.

If you continue to experience issues, inspecting the output at each node (using the built-in execution data viewer) can help pinpoint where the data isn’t being structured as expected. This step‑by‑step check is often the fastest way to resolve issues with splits and data merges in n8n.

Happy automating!