Create a dynamic lookup table

Unlock the power of dynamic lookup tables with Zapier and Airtable! Say goodbye to static limitations and discover how to easily update your tables in real-time.

Create a dynamic lookup table

Picture this: you've set up an impressive Lookup Table in Zapier to seamlessly match values between App A and App B.

It's like magic, transforming 'Apple, Banana, Citron' into '123, 456, 789'—until you need to make an update. Suddenly, you find yourself knee-deep in a static table that lives within one Zap, frustrated by manual adjustments.

If that sounds like you, breathe easy. You're about to discover how to give that static Lookup Table a dynamic makeover, thanks to the power of Airtable.


Read on.

The setup

We have an Airtable base setup like this, for instance:

Example Airtable base with names, IDs and additional info

App A returns the name of the fruit, but we need the IDs!

The steps to use:

  • Formatter > Utilities > Line-Item to Text

  • Find Many Records (With Line Item Support) in Airtable

Line-Item to Text

The separator to use:

<TriggerValue>", {Fruit}="<TriggerValue>

We’ll then want to test this step. Feel free to change {Fruit} to the name of the Airtable field you’re using.

Set up the Line-Item to Text step

Find Many Records (With Line Item Support) in Airtable

Set up the Find Many Records in Airtable step

The search formula to use:


Replace XXX with the “Output Text” object from the “Line-item to Text” step.

We can now test this step.


Selec the IDs

We can now map the IDs we were looking for in a following action step.

Looking For An Interactive Demo? I gotchu!

Overcoming the 10-Record Limit: A Creative Solution

You might have hit a snag if you tried to return more than 10 records using the "Find Many Records (With Line Item Support) in Airtable" step. If you find this limiting, you're not alone—and while you can always ask Zapier to consider lifting this cap, we have an ingenious workaround for you right now.

Here's How:

  1. Join the Transform App: First things first, get yourself an invite to the Transform app integration. Accept your invite here.

  2. Prep a Google Sheets Spreadsheet: Set up a Google Sheets file and make sure you have at least three columns:

    • A 'Name' column, or whatever string you want to use for lookup.

    • An 'ID' column.

    • A 'Lookup' column—populate every cell in this column with an "X."

Important Note:

This approach is ideal for looking up more than 10 values dynamically. Just keep in mind that the number of records you can search within is capped at 500.

Next, select the "Lookup Spreadsheet Rows (output as Line Items)" action in Google Sheets. Choose the appropriate spreadsheet and worksheet, and set your sights on locating 'X' in the lookup column.

Look up X in the lookup column

Ready, Set, Test: Navigating to a 500-Record Limit

Once you've got your Google Sheets and Transform app set up, it's time for a test run. If all goes according to plan, you should be able to fetch up to 500 records. That's just the beginning; let's delve into the Transform action to make this truly dynamic.

Follow These Steps:

  1. Choose the Transform Action: Select "Lookup Table from Key-Value Lists in Transform" as your next action.

  2. Input an Array for the Lookup Key: Here's where it gets interesting. Instead of a text or string, you'll need to input an array. Yes, an array.

  3. Fill in the Keys and Values:

    • Keys List Field: Populate this field with the values from your Google Sheets step—these are what you'll be looking up.

    • Values List Field: Input the corresponding IDs from your Google Sheets. These are the values your keys will map to.

Set up the transform step in the Zap

Finally, we can test this, and this should return the respective IDs:

Result of the Transform alternative

Wrapping Up: Dynamic Lookup Tables Made Possible

So there you have it—two inventive workarounds that breathe life into what was once a static lookup table. While both approaches come with their own set of limitations, the chances of these becoming real stumbling blocks are slim to none.

Why This Matters: The Practical Application You've Been Waiting For

Consider the challenge of running an eCommerce store. You've got App A that's stellar for listing your products, and App B that's a powerhouse for managing your inventory. But here's the catch: you need to translate product names from App A into product IDs in App B for seamless integration.

That's where dynamic lookup tables come into play. They effortlessly fetch the required product IDs from App B based on product names from App A. But what if you add a new product line?

No worries—you can sidestep manual table updates by setting up a clever Zap chain: a new product in App A triggers product creation in App B, which in turn triggers a new Airtable record. This chain captures both the fresh product name from App A and its corresponding new ID from App B.

With this setup, you're not just automating—you're automating smartly.

Happy Building!