What Is a Mail Merge Field and How to Use Variables in Email Templates

A mail merge field : also called a merge variable or merge tag : is a placeholder in an email template replaced with recipient-specific data at send time. The simplest form, {{first_name}}, swaps in each recipient’s actual name from the connected data source. More advanced fields support fallback values, formatted strings, and conditional logic via Liquid syntax : the mechanism that makes one template feel personal to a thousand recipients.

What Is a Mail Merge Field

A mail merge field is a placeholder token in an email template that the sending engine replaces with recipient-specific data before the message leaves the server. When you write Hi {{first_name}}, the engine swaps in “Alice” for one recipient and “Bob” for another : no manual editing between sends, no copy-paste errors.

• Placeholder token: A tagged string such as {{first_name}} or *|FNAME|* that the sending engine recognizes and replaces at send time with the value from the recipient’s data row.
• Data binding: Each placeholder maps to a named column in the connected data source : a Google Sheet, CSV file, or CRM record : so the engine knows which value to pull for each recipient.
• Rendering engine: The email tool’s backend processor that reads the template, locates every token, and substitutes the correct per-row value before any message is dispatched from the server.

“Mail merge is a method of taking data from a database, spreadsheet, or other form of structured data, and inserting it into documents such as letters, mailing labels, and name tags.”

: Wikipedia, Mail merge

A mail merge field is the foundational unit of personalization in email automation : the difference between a mass blast and a message that feels individually written for each recipient.

Why Are Mail Merge Fields Important

Three reasons mail merge fields matter: they scale personalization without manual writing, they create one-to-many sends that feel one-to-one, and they enable conditional logic for advanced targeting. Any solopreneur doing cold outreach at volume without them is either copying and pasting names manually or sending generic email that gets ignored.

• Scaled personalization: Merge fields allow a single template to produce 500 individualized messages : each addressed correctly, referencing the right company, and using the recipient’s title : without writer or editor involvement per send.
• Reply rate lift: Emails referencing the recipient’s first name, company, or role in the opening line consistently outperform generic openers; B2B cold email benchmarks show personalized first lines drive 2-3x higher reply rates versus batch sends.
• Conditional relevance: Advanced merge logic (if/else via Liquid syntax) lets one template send different body copy depending on the recipient’s segment, industry, or CRM stage : without duplicating the campaign.
• Data consistency: Merge fields pull values from a single source of truth (Google Sheet, CRM), eliminating copy-paste errors that result in “Hi {{first_name}}” landing in an inbox.
• Audit trail: When merge fields reference named columns, every send is traceable : which row produced which email : making deliverability troubleshooting and A/B testing far easier than manual variants.

For a practical look at how merge fields power a complete Gmail cold outreach workflow, see our GMass cold email review with merge fields.

Mail merge fields are not optional for anyone sending cold email at volume : they are the minimum requirement for reply rates worth tracking.

How Does Mail Merge Field Replacement Work

Three steps execute in sequence at send time: the tool reads the data source row by row, parses the template for placeholder tokens, then swaps each token with the matching column value before dispatching the message. The process is synchronous : one row produces one email : with no batch randomization or shared state between recipients.

• Data source ingestion: The tool reads the connected spreadsheet, CSV, or CRM and loads each row as a key-value map : column headers become field names, cell values become field values.
• Template tokenization: The sending engine parses the email template (subject, preheader, body, signature) for known placeholder patterns : {{...}}, *|...|*, or [[...]] depending on the tool’s syntax.
• Token substitution: Each matched token is replaced with the corresponding value from the current row’s data map. Missing values trigger either a fallback or an error, depending on the tool’s configuration.
• Per-recipient rendering: The fully rendered email : with all tokens replaced : is assembled in memory for each recipient separately, then handed to the SMTP layer for delivery.
• Delivery dispatch: The SMTP layer sends each rendered message as an individual email from the sender’s account, with no indication in the headers that merge substitution occurred.

Merge field replacement runs per-recipient, per-row : making each send a unique rendering of the same template, not a copy of a single rendered email.

What Syntax Do Different Tools Use

GMass and Lemlist use {{Column Name}}. Mailchimp uses *|FNAME|*. HubSpot uses {{contact.firstname}}. Each tool requires the exact format specified in its documentation : mixing syntax from one tool into another template causes literal token rendering in the sent email.

Always copy the exact syntax from the tool’s documentation : a single misplaced curly brace or pipe character causes the raw token to appear in the sent email instead of the personalized value.

Can You Use Liquid Syntax for Advanced Personalization

Yes : in GMass, Lemlist, and most modern cold email tools. Liquid adds conditionals, filters, and loops to standard merge fields, enabling one template to produce dramatically different output based on per-recipient data values without duplicating the campaign or writing separate templates for each segment.

• Default filter: {{first_name | default: "there"}} renders “there” when the first_name column is empty : preventing the raw token from landing in the inbox when data is missing.
• Capitalize filter: {{company | capitalize}} normalizes inconsistent casing in the data source : “acme corp” becomes “Acme Corp” regardless of how it was entered in the spreadsheet.
• Conditional blocks: {% if title != blank %} as {{title}}{% endif %} appends the recipient’s title to the greeting only when the field is populated : gracefully omitting it when not.
• Segment-aware body copy: {% if industry == "SaaS" %}...{% else %}...{% endif %} renders entirely different body paragraphs per segment without creating separate campaign files.
• String truncation: {{company | truncate: 20}} caps long company names that would otherwise break the subject line character limit or visual layout in the preview pane.

“GMass supports advanced merge tags including Liquid filters, allowing senders to write fallback values, conditionals, and string transforms directly inside the email template without any coding setup.”

: GMass, Mail Merge in Gmail Documentation

Liquid syntax turns a static merge field into conditional logic : one template handles multiple segments, fallback values, and string formatting without duplicating campaigns or writing manual variants.

What Categories of Merge Fields Exist

Five categories cover the full spectrum of merge field usage: identity fields (first name, last name), company fields (name, industry), role fields (title, seniority), activity fields (last email opened, last click), and custom fields (pain point, opener line). Most cold outreach campaigns use two to three categories simultaneously.

For a full comparison of how Gmail tools handle each field category, see our Gmail mail merge tool comparison.

Identity and company fields cover 80% of cold outreach needs : role and custom fields add the final layer of specificity that separates a good cold email from a great one.

What Are Custom Merge Fields

Custom merge fields are user-defined columns in the data source that go beyond standard identity and company fields. Common custom fields include pain_point, opener_line, recent_news, common_connection, and mutual_contact : each requiring manual or AI-assisted pre-population before the send.

• pain_point: A one-sentence description of the specific problem the recipient’s role or company faces : written individually per prospect, used as the opening hook in the email body to establish relevance before the pitch.
• opener_line: A personalized first sentence referencing something specific to the recipient : a recent LinkedIn post, a company announcement, or a shared connection : that signals the email was not mass-produced.
• recent_news: A short reference to a funding round, product launch, or press mention relevant to the recipient’s company, inserted into the body to add timeliness and show active research.
• common_connection: The name of a mutual contact or shared community : a university, Slack group, or industry event : used as a warm social proof signal in the opening line.
• icebreaker: A two-to-three word qualifier added to the subject line or greeting to reference something the recipient recently published, said, or achieved : driving curiosity before the recipient reads the body.

Custom merge fields require upfront research investment : but they are what separate the top-quartile reply rates (10%+) from industry average (3.4%) in B2B cold outreach.

How Many Merge Fields Should You Use Per Email

Three to five merge fields per email is the optimal range for B2B cold outreach. Fewer than three fields produces a generic feel; more than five increases data quality risk : each additional field is another potential source of missing or mismatched values that could cause visible token errors at scale.

• Minimal (1-2 fields): First name in subject line and greeting. Acceptable for high-volume warm audiences where data quality is guaranteed, but insufficient for cold outreach where personalization is the primary deliverability and reply-rate lever.
• Optimal (3-5 fields): First name, company name, role or title, and one custom field (opener_line or pain_point). Covers identity, context, and relevance without overloading the data preparation step or risking multiple visible errors per send.
• Advanced (6+ fields): Appropriate for high-touch, small-list ABM campaigns where each row is manually researched and verified. Not recommended for lists above 200 recipients without a data validation step before send.
• Subject line fields: Limit to one merge field in the subject line. Multiple merge fields in subjects read as obviously automated and reduce open rates relative to a single, well-chosen personalization token.
• Fallback coverage: Every optional merge field (any field that might be empty for some recipients) requires a defined fallback value. Without fallback coverage, missing data produces literal token text in the sent email : an immediate spam and trust signal.

Three to five fields with complete fallback coverage consistently outperforms both sparse (one field) and over-engineered (six-plus fields) approaches in B2B cold email campaigns.

How Do You Handle Missing Merge Data

Four strategies cover missing merge data: static fallback (render a safe default when the field is empty), conditional block (skip the entire section when the field is absent), default-to-empty (silently omit the field), and block-level if/endif logic (conditionally render entire paragraphs based on field presence).

“The most common cause of merge field failures in GMass campaigns is missing fallback values on optional fields : a preventable issue that results in literal token text (‘Hi {{first_name}}’) landing in recipient inboxes at scale.”

: Growth Hack Suite, GMass Cold Email Review

Static fallback handles 90% of missing-data scenarios : block-level conditionals are reserved for campaigns where entire sections should be omitted rather than replaced with generic text.

What Happens If a Merge Field Is Missing

Without a fallback: the literal token renders in the email : “Hi {{first_name}}” instead of “Hi Alice” : instantly signaling mass automation to the recipient. With a fallback defined: the email renders gracefully with the default value. Three failure modes cover the full range of missing-data outcomes.

• Literal token rendering: The tool sends the raw placeholder string unchanged when no fallback is set and the data cell is empty : the recipient sees “Hi {{first_name}}” in the email body, destroying the personalization illusion and signaling automation.
• Send failure or skip: Some tools configured in strict mode will skip the recipient entirely when a required merge field is missing : preventing token-in-inbox errors but silently reducing the sent count without notification.
• Blank field render: Tools with default-to-empty behavior silently omit the field value : “Hi ” instead of “Hi Alice” : which reads as broken formatting rather than raw token text, but still signals a data quality issue to attentive recipients.
• Cascading errors: When a missing field drives conditional logic (e.g., an if/endif block that uses the field’s value as a condition), the entire block may fail to render : removing paragraphs from the email body that the sender intended to include.
• Spam trigger: Literal token text in sent emails is a strong spam signal for inbox providers : high volumes of “Hi {{first_name}}” sends can trigger filtering rules that affect deliverability for the entire sending domain.

Literal token rendering is both the most common and most damaging merge field failure : a single missing fallback on a 500-recipient campaign produces 500 broken emails and measurable deliverability damage.

How Do You Test Merge Fields Before Live Send

Three test methods catch merge field errors before full send: sending to yourself (manual review of one to three rendered samples), using the tool’s built-in test send feature (renders five sample rows automatically), and validating that Google Sheet column headers match the template token names exactly before campaign launch.

• Self-send test: Add a row in the data source with your own email address and test values, then send the campaign to that single row. Review the received email to verify subject line, greeting, body fields, and fallback values all render correctly before scaling to the full list.
• Tool test send: Most platforms (GMass, Lemlist, Mailchimp) include a “send test” feature that selects five to ten sample rows from the data source and sends a preview to the sender’s address : covering a range of data scenarios including rows with missing optional fields.
• Column header validation: Compare the column headers in the Google Sheet or CSV with the merge field names in the template. A mismatch (e.g., “First Name” vs. “first_name” in a case-sensitive tool) causes token render failures for every recipient in the list.
• Empty row test: Add a test row with all optional fields left blank : only Email populated. Send a single test to this row to verify that every optional merge field either falls back gracefully or is conditionally omitted rather than rendering as a raw token.
• Subject line preview: Check the subject line render in the tool’s preview pane across multiple sample rows before send. Subject line token failures (literal text appearing where the name should be) are visible to every recipient before they open the email : a first-impression failure with no recovery.

A five-minute test sequence before each send : self-send, tool preview, header validation : eliminates the most common merge field failures before they affect deliverability or recipient perception.

How Do GMass Merge Fields Work With Google Sheets

GMass reads the connected Google Sheet where row one column headers become the merge field names. The template wraps each column header in double curly braces : a column named “First Name” becomes {{First Name}} in the template. At send time, GMass processes each data row, substitutes the header-matched value, and dispatches the rendered email from the connected Gmail account.

The Google Sheets integration is direct : no CSV export, no import step, no data sync delay. GMass reads the Sheet in real time at send time, meaning updates to the Sheet (adding rows, correcting values) are reflected in the next send without republishing the campaign. This makes GMass particularly effective for ongoing outreach sequences where the list evolves between send cycles.

GMass’s Google Sheets-to-Gmail merge is the simplest implementation of mail merge fields available : column headers become field names, double curly braces wrap them, and the Sheet drives every send without a separate data pipeline.

Frequently Asked Questions

What is the simplest mail merge field?

{{first_name}} is the simplest and most universally supported merge field. It gets replaced with the recipient’s first name from the connected data source : a Google Sheet column named “first_name” or “First Name” depending on the tool’s case sensitivity.

Bottom line: Most tools support this exact syntax. Copy the column header exactly into the curly brace template to ensure correct rendering.

Are merge fields case-sensitive?

It depends on the tool. GMass matches column headers exactly : “First Name” and “first_name” are treated as different fields. Lemlist is case-insensitive. Always confirm the tool’s behavior in documentation before building a campaign at scale.

Bottom line: Default to matching the exact case from the tool’s documentation. Consistent lowercase_underscore naming across all campaigns prevents case-sensitivity errors across tools.

What is a fallback value?

A fallback value is a default string used when the merge field data is empty for a specific recipient. Defined inline in the template : {{first_name | there}} renders “there” when first_name is blank : it prevents the raw token from appearing in the sent email.

Bottom line: Without a fallback, missing data renders the literal token (“Hi {{first_name}}”) in the recipient’s inbox : an immediate signal of mass automation that damages both reply rate and deliverability.

Can merge fields contain spaces?

Yes : in spreadsheet-driven tools like GMass, column headers with spaces work correctly: “First Name” becomes {{First Name}} in the template and renders the cell value without issue. In code-driven or API-first tools, underscores are safer than spaces to avoid parsing errors.

Bottom line: Spaces work in Google Sheets-connected tools. If you use multiple tools in the same workflow, standardize on lowercase_underscore naming to maintain compatibility across platforms.

What is Liquid syntax in email templates?

Liquid is an open-source templating language originally built by Shopify that adds conditionals, filters, and loops to standard merge fields. In email, Liquid enables {% if %} blocks for segment-aware copy, | default: filters for fallbacks, and | capitalize for string formatting : without any coding setup beyond writing the tag in the template.

Bottom line: Liquid transforms a static merge field into conditional logic. GMass and Lemlist support it natively : no plugins or integrations required.

Can I have conditional content per recipient?

Yes : with Liquid syntax. {% if company_size > 500 %}Enterprise paragraph{% else %}SMB paragraph{% endif %} renders different body copy based on the recipient’s field value. This allows one campaign to serve multiple segments without creating separate templates for each audience.

Bottom line: Conditional content is what separates good cold email from great cold email. A single if/else block can double the relevance of your template without doubling the copywriting effort.

Can merge fields call external APIs?

Some advanced tools (Lemlist, Smartlead) support API-driven merge fields that pull real-time data at send time : such as a recipient’s latest LinkedIn post or live company data. Most tools, including GMass, do not : merge values must be pre-populated in the data source before the send is initiated.

Bottom line: API merge fields add latency and cost. Reserve them for high-value, low-volume ABM campaigns. For high-volume cold outreach, pre-populate all fields in the Google Sheet before send.

Can I personalize subject lines with merge fields?

Yes : all major cold email tools support merge fields in the subject line. Personalized subject lines referencing the recipient’s first name or company lift open rates 10-25% versus generic subjects. Limit subject line personalization to one merge field : multiple fields read as obviously automated.

Bottom line: One merge field in the subject : typically first_name or company_name : is enough to signal personal outreach. More than one reduces the effect and increases data-quality risk if any field is blank.

How do I prevent merge field failures?

Three steps prevent most merge field failures: deduplicate the data source to remove rows with missing required fields, set fallback values for every optional field in the template, and run a test send to five sample rows (including at least one row with empty optional fields) before launching the full campaign.

Bottom line: Most merge field failures are caused by skipping the test step. A five-minute pre-send check : self-send, tool preview, header validation : eliminates the most common errors before they affect deliverability.

What is a custom field in the context of mail merge?

A custom merge field is a user-defined column in the data source that goes beyond standard identity and company fields. Custom fields like pain_point, opener_line, or recent_news require manual or AI-assisted pre-population for each row : they cannot be pulled from standard CRM records without enrichment.

Bottom line: Custom fields drive the highest reply-rate lift of any personalization variable. The tradeoff is data preparation time : each row needs a unique value written or generated before the campaign can send.

Can I generate merge field content with AI?

Yes : AI tools (ChatGPT, Claude, Gemini) can draft custom opener lines, pain points, or icebreakers for each row in the Google Sheet before the merge runs. The workflow: export the prospect list to a Sheet, use an AI prompt to generate per-row custom field content in bulk, then connect the enriched Sheet to GMass for the merge send.

Bottom line: AI-generated custom fields are the fastest way to scale hyper-personalization : 200 unique opener lines in under 30 minutes : without hiring researchers or copywriters for each campaign.

How do GMass merge fields differ from Mailchimp merge tags?

GMass uses {{Column Name}} syntax matching Google Sheet column headers directly : no field setup required beyond naming the column. Mailchimp uses *|FNAME|* legacy syntax requiring field registration in the Audience Manager before use. GMass also supports Liquid conditionals natively; Mailchimp’s conditional logic is more limited and syntax-specific.

Bottom line: GMass merge fields are simpler to set up for Google Sheets-driven cold outreach : column header equals field name, no pre-registration needed. Mailchimp’s system suits newsletter audiences where fields are pre-structured in the CRM.