HTML · FORM CONTROL

HTML input type=email: validation, multiple and autocomplete

Last reviewed November 2, 2026

<input type="email"> is a text field the browser checks before submit: the value must have one @, a local part and a domain made of valid labels. It does not run a full RFC 5322 check or look up the domain. On phones it brings up an email keyboard, and multiple accepts a comma-separated list.

Edit the live example Copy the snippet

Live, editable example
Copy-paste snippet
Attributes & common mistakes

Live demo · nothing is sent

What gets submitted

Fill in the form above and press its button. The demo stops the request and lists every name=value pair the browser would send, plus the controls it leaves out.

With a free access key in the form, these fields land in your splitforms dashboard; access_key and botcheck are read by splitforms, not stored as lead data.

Edit the HTML and re-run it

Example HTML (changes re-run the live demo)

Runs in a sandbox. Nothing is sent.

Minimal snippet

email-example.html

<label for="email">Email</label>
<input type="email" id="email" name="email"
       autocomplete="email" required>

Copy-paste code

HTML Email Input code you can paste today.

Replace YOUR_ACCESS_KEY with a key from your free splitforms dashboard. The form posts to one endpoint — submissions land in your inbox and dashboard with spam filtering built in.

Get free access key

input-type-email.html

<form action="https://splitforms.com/api/submit" method="POST">
  <input type="hidden" name="access_key" value="YOUR_ACCESS_KEY">

  <label for="name">Name</label>
  <input type="text" id="name" name="name" autocomplete="name" required>

  <!-- One address, checked by the browser, filled by autofill -->
  <label for="email">Email</label>
  <input type="email" id="email" name="email" autocomplete="email" required>

  <!-- multiple: a comma-separated list, each address checked -->
  <label for="cc">Copy the reply to (optional, separate with commas)</label>
  <input type="email" id="cc" name="cc" multiple>

  <label for="message">Message</label>
  <textarea id="message" name="message" rows="4" required></textarea>

  <!-- Honeypot: hidden from people, bots fill it in -->
  <input type="checkbox" name="botcheck" style="display:none" tabindex="-1" autocomplete="off">

  <button type="submit">Send</button>
</form>

Key facts

What does type=email check?

The browser checks the value against the HTML Standard's valid email address rule, which the spec calls a willful violation of RFC 5322: simpler than the RFC, and strict about the domain. An empty field passes unless it is required.

What does type=email check?
Fact	Detail
The rule	Exactly one `@`. Before it: letters, digits, dots and symbols such as `+`, `_`, `-` and `'`. After it: one or more labels split by dots, each 1–63 letters, digits or hyphens, not starting or ending with a hyphen.
Not checked	Whether the domain exists, has mail servers or a real top-level domain. `name@example` passes, and so does a typo such as `name@gmial.com`.
Not supported	Quoted local parts (`"john doe"@example.com`), IP-address domains (`name@[192.0.2.1]`) and non-ASCII letters before the `@`, even though RFC 5322 or later RFCs allow some of them.
Spaces	Leading and trailing spaces and line breaks are stripped from the value. A space inside the address fails.
JavaScript	`el.validity.typeMismatch` is `true` while a non-empty value is not a valid address. `el.checkValidity()` runs the check.
Mobile keyboard	Most mobile browsers show an email keyboard with `@` and `.` close at hand. `inputmode="email"` asks for the same keyboard on a plain text field.
Autofill	`autocomplete="email"` tells the browser the field wants the person's email address, so it can offer the saved one.
Security	None. Anyone can POST to the form's action URL without running the check, so validate the address on the server too.

Sources: WHATWG HTML Standard: email state · WHATWG: valid email address · WHATWG: suffering from a type mismatch · WHATWG: autofill email · MDN: <input type="email"> · MDN: ValidityState.typeMismatch · RFC 5322: Internet Message Format

Validation table

Which email addresses does type=email accept?

Each row is what current browsers do with the HTML Standard's rule. Some addresses the browser accepts would bounce, and some the RFC allows are rejected, which is why the browser check is a typo filter and not proof the address works.

Which email addresses does type=email accept?
Address	Browser result	Why
`name@example.com`	Valid	One `@`, a local part and a dotted domain.
`name+tag@example.co.uk`	Valid	`+` is allowed before the `@`; any number of domain labels.
`user@localhost`	Valid	No dot is needed after the `@`.
`first..last@example.com`	Valid	Any mix of dots is allowed before the `@`, though RFC 5322 rejects two dots in a row there.
`name@gmial.com`	Valid	The domain is never looked up, so typos pass.
`name.example.com`	Invalid	No `@`.
`name@@example.com`	Invalid	Two `@` signs.
`name@-example.com`	Invalid	A domain label can't start or end with a hyphen.
`name@example..com`	Invalid	Two dots in a row leave an empty domain label.
`name @example.com`	Invalid	A space inside the address.
`"john doe"@example.com`	Invalid	Quoted local parts are not supported, although RFC 5322 allows them.
`name@[192.0.2.1]`	Invalid	IP-address domains are not supported.

The live demo above runs your own browser's check: type any of these into the email field and submit.

Sources: WHATWG: valid email address · MDN: <input type="email"> validation

multiple

How does multiple work on an email input?

With multiple, the field takes a comma-separated list. The browser strips spaces around each address, checks every one, and submits the whole list as one field, such as cc=ana@example.com,li@example.com. An empty list is valid unless the field is required.

How does multiple work on an email input?
Behaviour	Detail
Separator	Commas only. Spaces around each address are removed, so `a@example.com, b@example.com` becomes `a@example.com,b@example.com`.
Validation	Every address must be valid. One bad address makes the whole field fail with `typeMismatch`.
What gets submitted	One name/value pair holding the joined list, not one entry per address. Split it on `,` on the server.
`pattern`	Checked against each address on its own.
`minlength` / `maxlength`	Count the whole list, not each address.

Sources: WHATWG: valid email address list · WHATWG: the multiple attribute · MDN: multiple

Attributes · <input type=email>

Which HTML Email Input attributes matter?

These attributes decide how the <input type=email> behaves and what actually gets emailed to your inbox when someone submits.

HTML Email Input attributes and what each one does
Attribute	What it does	Docs
`type="email"`	Makes the field check for a valid address and show an email keyboard on phones.	MDN
`autocomplete="email"`	Lets the browser fill in the saved email address. Use it on every field that asks for the person's own email.	MDN
`multiple`	Accepts a comma-separated list of addresses and checks each one.	MDN
`required`	Blocks the submit while the field is empty. Without it, an empty email field is valid.	MDN
`pattern`	Adds your own rule on top, for example only company addresses. Checked per address with `multiple`.	MDN
`minlength / maxlength`	Limit the length of the whole value.	MDN
`list`	Points at a `<datalist>` of suggested addresses.	MDN
`validity.typeMismatch`	JavaScript: `true` while a non-empty value is not a valid address.	MDN

Common mistakes

HTML Email Input not working? Here's why.

Most broken forms come down to a few small mistakes with the <input type=email>. Check these before you ship, then forward every submission to Slack or a webhook.

A valid address is not a working address
The browser only checks the shape. name@gmial.com passes. Check the domain on the server, or send a confirmation email when the address really matters.
Don't set type=email and a strict regex that fights it
A pattern runs as well as the built-in rule, never instead of it. A pattern that allows quoted local parts can't make them pass, and an overly strict one turns away real addresses such as ones with +tags.
The browser check can be skipped
novalidate, form.submit() and direct POST requests skip it. Re-check the address on the server before you reply to it or add it to a list.
multiple sends one string
With multiple the server gets one comma-separated value, not an array. Split it on commas before you use the addresses.

Sources: WHATWG HTML Standard: email state · WHATWG: valid email address · MDN: <input type="email">

Server side

Why browser validation isn't enough

type="email" catches typos such as a missing @, but it never checks that the domain exists or can receive mail, and anyone can skip it with a direct POST. Re-check the address on the server with the same rule the browser uses, then check the domain. Test addresses against common patterns with the email regex tester, and check a domain's MX, SPF and DMARC records with the email deliverability checker.

The regex below is the one the HTML Standard gives for a valid email address, so the server accepts exactly what the browser accepts.

check-email.js

// The HTML Standard's "valid email address" rule
const EMAIL = /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;

export function isEmail(value) {
  return EMAIL.test(String(value).trim());
}

// For multiple: split the one comma-separated value first
export function emailList(value) {
  return String(value).split(",").map((s) => s.trim()).filter(Boolean);
}

Regex patterns for form fields

Alphanumeric regex tester

Test letters and numbers, spaces, handles and Unicode patterns.

Email regex tester

Test email patterns against edge cases and your own list.

Phone number regex tester

Check numbers against E.164, US/Canada and digits-only patterns.

Password regex generator

Pick strength rules and copy the regex or HTML pattern.

ZIP code regex

US ZIP, ZIP+4, Canadian and UK postal code patterns.

Number regex tester

Test digits, decimals, money and thousands separators.

Date regex tester

Date formats, strict ranges and leap-year aware ISO patterns.

Name regex tester

Validate names with accents, hyphens and apostrophes.

Username regex tester

Test username length, separators and reserved names.

IP address regex tester

Validate IPv4, IPv6 and CIDR input with strict octets.

URL regex tester

Check website fields with regex, type=url or new URL().

HTML pattern attribute

How browsers anchor and check a pattern on an input.

HTML required attribute

Stop a form from sending while a field is empty.

Validate a form with JavaScript

Use checkValidity, custom messages and your own rules.

Time regex tester

Validate 24-hour, AM/PM and ISO 8601 time formats.

Credit card regex tester

Match card brands by prefix and length, then run a Luhn check.

Hex color regex tester

Match hex, rgb() and hsl() colors with range checks and swatches.

UUID regex tester

Match UUID v4, v7 and GUIDs with version and variant checks.

Use your validation patterns as you assemble a form with our HTML contact form code or HTML form generator.

Copy-paste ready

The HTML Email Input example below is a complete, working form — paste it into any HTML page and it submits, no edits to the markup required.

No backend to build

Your html email input form posts to one endpoint. No server, PHP, or API route — accepted submissions are saved to your dashboard before owner notification email is attempted; delivery time and inbox placement depend on provider and recipient settings.

A form that really submits

Unlike a static reference snippet, this <input type=email> form actually sends data to a free splitforms backend, with spam filtering built in.

How it works

How to add HTML Email Input to any page.

Copy the html email input example, drop in your free access key, and paste it into any page — submissions start landing in your dashboard.

Copy the code

Copy the HTML Email Input example below.

Add your access key

Replace YOUR_ACCESS_KEY with a free splitforms key from the dashboard.

Paste into your site

Drop the form into any HTML page. Submissions arrive in your dashboard.

Get free access key All HTML elements

How SplitForms works

What happens after someone submits your form?

splitforms receives the submission, filters spam, saves it to your dashboard and emails you — then, on paid plans, sends it on to your webhooks and integrations. No backend infrastructure to build.

A SplitForms contact form submission launching straight to your inbox

Add your endpoint

Point your form to your unique SplitForms endpoint. That's it.

HTML form pointing at a SplitForms submit endpoint

Receive submissions

We instantly capture and organize every submission in your inbox.

Submissions inbox with searchable leads and status pills

Route anywhere

Send data to email, spreadsheets, CRMs, webhooks, and 7,000+ apps.

Generic integration tiles for email, sheets, chat, CRM, automate, and webhook

Start Free Read the Docs

No credit card required. Set up in under 60 seconds.

Connect & automate

Where can submissions go besides email?

On paid plans, submissions can also go to Slack, Discord, Google Sheets, Notion, Airtable, Zapier or any signed webhook — and splitforms works on the platforms you build on, from WordPress and Shopify to Next.js. With Stripe connected, your forms can take payments too.

NewTake payments on your formsDeposits, bookings, order forms — submitters check out through Stripe and the money goes straight to your Stripe account. Included on every paid plan.See payment forms →Need time slots? Online booking →

View all integrations →

Setup guides for the stacks you use

HTMLReactNext.jsAstroWebflowWordPress

Questions

HTML Email Input questions, answered.

View all FAQs

What does input type=email validate?

It checks that the value has exactly one @, a local part made of letters, digits, dots and a few symbols, and a domain of dot-separated labels made of letters, digits and hyphens. It does not run a full RFC 5322 check, so quoted names and IP-address domains fail, and odd but allowed-by-browser forms like user@localhost pass.

Does type=email check the domain exists?

No. The browser never looks up the domain, so name@gmial.com passes as long as it has the right shape. To catch fake or mistyped domains, check the domain's MX records on the server, or send a confirmation email. The splitforms email deliverability checker shows a domain's MX, SPF and DMARC records.

How do I allow several emails?

Add the multiple attribute: <input type="email" name="cc" multiple>. People separate addresses with commas, the browser strips spaces around each one and checks every address, and the form submits them as one comma-separated value that you split on the server.

What autocomplete value should an email field use?

autocomplete="email". It tells the browser the field wants the person's own email address, so autofill can offer the saved one.

Does type=email show a special keyboard on mobile?

Yes, on most mobile browsers: an email keyboard with the @ and . keys easy to reach. inputmode="email" asks for the same keyboard on a field that is not type=email.

Is an empty email field valid?

Yes. The email check only runs on a non-empty value, so add required if the address is mandatory.

Can I change the email error message?

Yes. Call setCustomValidity("Your message") in the field's invalid event when validity.typeMismatch is true, and clear it with setCustomValidity("") in its input event, or the field stays invalid.

Simple pricing

How much does splitforms cost?

Free gives you 500 submissions for $0 — no card, no time limit. Pro is $5/month for 5,000 submissions a month, and Annual is $49/year for 15,000 a month with every Pro feature.

Free

$0— 500 submissions

No card, no time limit

Best for testing

For side projects and indie devs.

500 free submissions
Unlimited forms
Email notifications included
Smart spam filtering
Submissions dashboard
Redirect after submit
MCP server included

Get Started

Recommended

Pro

$5/ month

Billed monthly

Every paid feature, for agencies and growing products.

5,000 submissions per month
Unlimited forms
Webhooks and integrations
CC/BCC, auto-replies and routing
File uploads with 500 MB storage
Stripe payments on your forms
3 team seats
Cancel anytime

Annual

$49/ year

About $4.08 per month, billed yearly

Best value

Every Pro feature with triple the volume — $0.27 per 1,000 at full use.

15,000 submissions per month
Unlimited forms
Everything in Pro
File uploads with 5 GB storage
3 team seats
Priority email support

No credit card required on Free • Cancel anytime • Full pricing and FAQ