Guides

HTML Contact Form Without JavaScript: How It Works

You do not need a script to get a contact form working. Here is what the browser does on its own, where plain HTML stops, and how a hosted endpoint covers the rest.

· The SimpleForm Team

You have a static page, a deadline, and a contact form that has to work. Every tutorial you find starts with a fetch call, an event listener and a build step, and none of that is needed to get a message from a visitor into your inbox. Skip the plumbing and the form still works, and it keeps working when a script fails to load, a content blocker strips it, or the visitor has JavaScript turned off.

An HTML contact form without JavaScript is a standard <form> element whose method is POST and whose action is a URL that accepts the submission. The browser itself collects the fields, builds the request and navigates to the response. SimpleForm is a hosted form backend that provides that URL, so a static site needs no server code of its own.

How does an HTML form submit without JavaScript?

The browser serialises every named field inside the form and sends it to the action URL using the form's method. That behaviour is defined by the HTML standard and described in the MDN reference for the form element. No script is involved at any point.

Two details trip people up. First, only fields with a name attribute are sent, so an input without one is silently dropped. Second, the page navigates away to whatever the server returns, which is why the response matters as much as the request.

<form action="https://simpleform.dev/f/YOUR_TOKEN" method="POST">
  <label for="name">Name</label>
  <input id="name" name="name" type="text" required>

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

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

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

That is the whole form. The token in the URL is the endpoint you get when you create a form in the SimpleForm dashboard.

What can plain HTML validate on its own?

Plain HTML can check that a field is filled in, that it looks like an email address, and that its length or pattern fits a rule. It cannot check anything that needs to know about your data, such as whether an email domain really receives mail.

AttributeWhat the browser checksWhat it cannot check
requiredField is not emptyWhether the value is meaningful
type="email"Value has the shape of an email addressWhether the mailbox exists
minlength / maxlengthCharacter countContent quality or spam
patternValue matches a regular expressionAnything beyond that expression

The type="email" check is deliberately loose; the MDN page for the email input explains that it accepts some strings that no real mailbox would. Treat browser validation as a convenience for honest visitors, not as a security boundary. Anyone can send a POST request that skips your page completely, so the receiving end has to cope with bad input.

Where does the submission go when there is no server?

It goes to a hosted endpoint that receives the POST on your behalf. You do not run a server, but something has to, and that is the job a form backend does. With SimpleForm you create a form, copy its endpoint URL into the action attribute, and each submission arrives as an email, a dashboard entry and, on paid plans, a webhook call.

This is the point where the manual route gets tedious. Writing your own receiver means a hosted function, mail delivery, spam handling and storage, which is a lot of upkeep for one contact form. A hosted endpoint covers those parts, and the SimpleForm documentation shows the exact request format, the response codes and the optional settings.

The endpoint accepts standard URL-encoded posts, multipart posts for file uploads, and JSON, so the plain form above needs no special encoding. You can also leave enctype off entirely for text-only forms.

How do you send visitors to a thank-you page?

You set a redirect URL on the form in the dashboard, and the endpoint answers a successful submission with a 302 to that address. The visitor lands on a page you control, and the form page is no longer in their history as a dead end. The Free plan includes a custom redirect URL.

If you do not set one, the browser simply displays whatever the endpoint returns, which is not a page that matches your branding. Set the redirect before you publish, and make the thank-you page a real static page that says what happens next, for example how quickly you reply.

  1. Create a form in the SimpleForm dashboard and copy its endpoint URL.
  2. Paste the URL into the action attribute and set method="POST".
  3. Give every field a name attribute and mark required fields with required.
  4. Create a static thank-you.html page on your own site.
  5. Set that page as the redirect URL for the form.
  6. Submit a test message and confirm the email, the dashboard entry and the redirect all happen.

For a deeper look at the redirect step and its edge cases, the blog index has a dedicated post on redirecting users after a static form submission.

What do you lose by skipping JavaScript?

You lose inline feedback. Without a script, there is no spinner, no in-page success message and no field-level error text beyond what the browser draws itself. Each submission is a full page navigation, which some designs find abrupt.

The failure behaviour is the part to plan for. Because the browser navigates to the response, an error from the endpoint is shown as a page rather than a message next to the form. These are the status codes the endpoint can return, taken from the SimpleForm docs:

CodeMeaningWhat the visitor sees without JavaScript
200Submission acceptedThe endpoint's response page
302Redirect to your thank-you URLYour thank-you page
400Missing or invalid form dataAn error response
402Plan submission limit exceededAn error response
403Disallowed origin domainAn error response
429Rate limit exceededAn error response

The rate limit is 10 submissions per IP address per hour per endpoint, so a real visitor will almost never reach it. The monthly limit matters more: the Free plan allows 100 submissions per month, and anything over that returns a 402 and is not stored.

My view is that for a plain contact form, the lost polish is a fair trade for the reliability. Add JavaScript later, as an enhancement, once the no-script version is working. A form that submits natively and is then upgraded with a fetch call degrades gracefully, whereas a form that needs the script to function does not.

Is a form with no JavaScript safe from spam?

No, and removing JavaScript does not make spam worse or better by itself. Bots post directly to endpoints and ignore your page entirely. Protection has to live at the endpoint.

Every SimpleForm plan includes a hidden honeypot field and the per-IP rate limit described above. Pro and Agency plans add optional Google reCAPTCHA v3 with your own site key, which does need a script on the page. If you want to stay script-free, rely on the honeypot and rate limit, and restrict the endpoint to your own domain on a plan that supports it.

Will this work for you, or should you build your own?

The reason most people hesitate is the feeling that a hosted endpoint is one more dependency, and that a small function of their own would be cheaper. That is true if you already run a server and are happy to maintain mail delivery and spam handling. If you do not, the Free plan covers 100 submissions per month across 3 forms with 7 days of submission history, with no credit card required, and you can compare the paid tiers on the pricing page if you outgrow it.

Your form is also not locked in. The markup above is standard HTML, so moving to a different receiver later means changing one URL.

What should you do next?

Create a free account, make your first endpoint and paste its URL into the form above. Send yourself a test message; you should see the email, the dashboard entry and your redirect within moments. Create a free SimpleForm endpoint and the form on your page will be working in a few minutes.

Frequently asked questions

Yes, but the form itself cannot send email. The browser posts the fields to the URL in the action attribute, and whatever receives that request sends the email. A hosted form backend such as SimpleForm receives the POST and forwards each submission to your inbox, so you need no script or server of your own.

The most common cause is missing name attributes. The browser only sends fields that have a name, so an input without one is dropped. Also check that the form has method="POST", that the action URL is correct, and that the submit button sits inside the form element rather than outside it.

Redirect the visitor to a thank-you page. Set a redirect URL on the form in your SimpleForm dashboard, and a successful submission is answered with a 302 to that address. Build the page as ordinary static HTML that confirms the message was received and says when the visitor can expect a reply.

No. The required attribute only makes the browser block an empty field for people using your page. A bot can post directly to the endpoint and skip your markup entirely. Real spam protection has to run on the receiving side, for example through a honeypot field and rate limiting at the endpoint.

Submissions over the monthly limit return a 402 response and are neither emailed nor stored. The Free plan includes 100 submissions per month. Your form keeps working for other requests, and the allowance resets on the first day of each month, so a quiet month starts fresh.

Ship a working form in five minutes. Point your form's action at a SimpleForm endpoint and submissions land in your inbox and dashboard straight away. Start free or read the docs.

More from the blog