This blog dives into how select field values behave in Webflow, how integrations interpret them, and how you can design them for reliability and scalability.

What Webflow Sends When a Form Is Submitted

When a user chooses an option from a dropdown and submits a form in Webflow:

• Webflow collects all form inputs (text, email, select values, etc.)

• It packages them into a form submission object

• That object can be delivered internally (email notifications) or externally via integrations like Zapier or direct APIs

For tools like Zapier, Webflow’s form submission trigger captures these values exactly as they exist at the time of submission.

Labels vs Values — Why It Matters

Every option in a select field has two conceptual components:

• Label – What the user sees

• Value – What the system sends (in Webflow this is typically the same as the label unless custom code is used)

In Webflow’s Designer, when you add a select field, the “Value” property you see in the settings is effectively the same as the human label — which becomes the actual data sent during form submission.

This can create hidden problems:

Inconsistent Naming

• Different capitalizations or spacing mean different data downstream:

  • Startup

  • startup

  • Start-Up

To humans, these look similar — but automation platforms treat them as different strings.

Impact: Filters, routing rules, and logic conditions can break.
Solution: Standardize values early — use lowercase, hyphens/underscores, and predictable identifiers.

Why Select Values Break Integrations

Mismatched Expectations in Third-Party Tools

Integration tools like Zapier pull form data based on field names and values. If a select value doesn’t match what your automation expects, actions either fail silently or misroute data.

Example:

• Your Zapier automation expects the value enterprise_plan, but Webflow sends Enterprise Plan

• Zap doesn’t match the condition → it skips or drops the submission

In such cases, your workflow doesn’t trigger — and you might not even receive an error message.

Upstream Dependencies in Databases and APIs

For integrations with backends like Xano or custom APIs:

• Select values often become part of the payload

• They may represent IDs, statuses, flags, or lookup keys

If the expectation on Xano’s side is a numeric ID but Webflow sends a text string, your endpoint either errors out or discards the field.

Even when values are correct structurally, hidden whitespace or unicode characters (like emojis) can cause mismatches.

The Role of Hidden Inputs and Integration Workarounds

Advanced integrations often require passing machine-friendly identifiers rather than human labels.

For instance, with Webflow + Wized + Xano:

• You might use a select field for a human label (e.g., “Moderate”)

• But then store a corresponding hidden input with the actual ID that your backend expects

• That hidden input must be updated with JavaScript based on selection

Common issues show up when scripting fails to capture element IDs or update hidden inputs — a symptom of DOM timing or selector mismatches.

This pattern of having separate UI fields vs data fields is a powerful design pattern but requires discipline and testing.

Automation Case Study: Webflow → Zapier → Airtable

Here’s a typical workflow many professionals use:

1. Webflow form submission occurs

2. Zapier captures the form

3. Zapier sends structured data to Airtable

Because Zapier requires at least one form submission before the Webflow connection can reliably pull field metadata, it’s recommended to submit a test first.

In Airtable:

• If you map a select field from Webflow to an Airtable single select field, the value must exactly match one of Airtable’s options

• An unexpected string leads to a create error or a “new option” being inadvertently created

Best Practices for Designing Reliable Select Field Values

Here’s a framework professionals use to avoid common pitfalls:

🔹 Standardize Data Values

• Use lowercase, underscore-separated identifiers (e.g., enterprise_plan)

• Avoid emojis and special unicode characters — integration layers often choke on them

🔹 Document Value Contracts

Treat your select options like API contracts. Document them in your design specs or integration docs so that backend and automation engineers know what to expect.

🔹 Test With Real Integrations First

Before deploying forms live, connect to Zapier or your backend and test real submissions. This catches mapping mismatches early.

🔹 Use Hidden Inputs for Backend IDs

If your backend expects numeric IDs rather than labels, store them in hidden fields updated by JavaScript.

Pitfalls and Quirks in Webflow Integrations

🔸 Forms Not Showing in Zapier UI

Sometimes new forms or fields don’t show up immediately in Zapier’s form dropdown. A workaround is to manually supply the form ID in a custom field instead of relying on UI selection.

🔸 Reference and Multi-Reference Fields

If you’re mapping to Airtable or CRM systems that rely on reference fields or multi-select options, you may need an intermediary transformation layer — because Zapier may not natively support certain mappings.

Why This Matters Beyond Webflow

You’re not just designing a dropdown; you’re defining a data contract that downstream systems rely on for:

• Routing logic

• CRM segmentation

• Analytics mapping

• Backend workflows

• Reporting dashboards

A single inconsistent value can cascade into:

• Lost leads

• Failed automations

• Inaccurate reports

This is no longer “beginner stuff” — it’s the difference between a prototype and a reliable production pipeline.