DEV Community: Ritu Fadadu

How to Create an HTML Form Without a Backend Server

Ritu Fadadu — Fri, 18 Sep 2026 07:07:05 +0000

Building an HTML form is easy.

Processing the form is usually where things become complicated.

You can create a contact form with a few lines of HTML:

<form>
  <input type="text" name="name" placeholder="Your name" />

  <input type="email" name="email" placeholder="Your email" />

  <textarea name="message" placeholder="Your message"></textarea>

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

The form looks complete.

But when someone clicks Send, where does the data go?

Normally, you would need to build a backend using Node.js, PHP, Python, Laravel, Express, or another server-side technology.

Then you would need to:

Create an API endpoint
Validate the request
Store the submission
Handle spam
Send email notifications
Handle errors
Deploy and maintain the server

That is a lot of infrastructure just to receive a contact form.

For many static websites, portfolios, landing pages, and small projects, there is a much simpler solution.

You can use a form backend.

What Is a Form Backend?

A form backend is a hosted service that receives submissions from your HTML form.

Instead of sending the form to your own API:

HTML Form
    ↓
Your Backend
    ↓
Database
    ↓
Email

you send it directly to a hosted form endpoint:

HTML Form
    ↓
Form Backend
    ↓
Submission Dashboard
    ↓
Email / Webhooks / Integrations

Your website remains completely static.

You don't need:

Node.js
PHP
Express
A database
A server
A serverless function
An email service

This makes a form backend especially useful for:

Static websites
Developer portfolios
Landing pages
Documentation sites
Marketing websites
GitHub Pages
Cloudflare Pages
Netlify
Vercel
Astro sites
Plain HTML websites

Why Can't HTML Handle Form Submissions by Itself?

HTML can create the user interface for your form, but it does not provide permanent server-side processing.

Consider this:

<form method="POST">
  <input name="email" type="email" />
  <button type="submit">Submit</button>
</form>

The browser knows that it should submit the form.

But it still needs to know where to send the request.

That is what the action attribute is for.

For example:

<form
  action="/api/contact"
  method="POST"
>

Here the browser sends the form submission to:

POST /api/contact

But /api/contact needs to exist somewhere.

If you have a static website, there may be no backend available to process that request.

Instead, we can point the action attribute to a hosted form endpoint.

Creating an HTML Form Without a Backend

Let's create a real contact form.

Start with:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />

  <meta
    name="viewport"
    content="width=device-width, initial-scale=1.0"
  />

  <title>Contact Us</title>
</head>

<body>

  <h1>Contact Us</h1>

  <form method="POST">

    <label for="name">Name</label>

    <input
      id="name"
      type="text"
      name="name"
      required
    />

    <label for="email">Email</label>

    <input
      id="email"
      type="email"
      name="email"
      required
    />

    <label for="message">Message</label>

    <textarea
      id="message"
      name="message"
      required
    ></textarea>

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

  </form>

</body>
</html>

At this point, the form exists, but it doesn't have a destination.

Now we need a form backend.

Using Formboost as the HTML Form Backend

Formboost is a developer-first form backend.

It doesn't build your form for you.

You keep your own HTML, CSS, React components, or frontend design.

Formboost only handles what happens after the user clicks Submit.

The flow looks like this:

Visitor
   ↓
Your HTML Form
   ↓
Formboost Endpoint
   ↓
Spam Processing
   ↓
Submission Storage
   ↓
Dashboard
   ↓
Email / Integrations / Webhooks

After creating a form in Formboost, you receive an endpoint that looks similar to:

https://formboost.app/f/YOUR_ENDPOINT_ID

Now add that endpoint to your HTML form:

<form
  action="https://formboost.app/f/YOUR_ENDPOINT_ID"
  method="POST"
>

  <input
    type="text"
    name="name"
    placeholder="Your name"
    required
  />

  <input
    type="email"
    name="email"
    placeholder="Your email"
    required
  />

  <textarea
    name="message"
    placeholder="Your message"
    required
  ></textarea>

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

</form>

That's it.

You now have a working HTML form without building your own backend server.

No SDK is required.

No JavaScript is required.

No npm package is required.

No API route is required.

Why the `name` Attribute Is Important

One small detail is extremely important.

Every field you want to submit should have a name attribute.

For example:

<input
  type="email"
  name="email"
/>

The name becomes the field name sent to the backend.

For example:

<input name="firstName" />
<input name="email" />
<input name="company" />
<textarea name="message"></textarea>

The submission will conceptually look like:

{
  "firstName": "John",
  "email": "john@example.com",
  "company": "Acme",
  "message": "I'd like to know more."
}

An input without a name attribute will not be included in a normal HTML form submission.

Creating a Contact Form Without JavaScript

One advantage of native HTML forms is that JavaScript is optional.

You can simply use:

<form
  action="https://formboost.app/f/YOUR_ENDPOINT_ID"
  method="POST"
>

The browser handles the POST request for you.

This is often the simplest approach for:

Portfolio websites
Contact pages
Landing pages
Small business sites
Static websites

You don't need to write:

fetch()

unless you want a custom JavaScript experience.

Submitting the Form With JavaScript

Sometimes you don't want the page to navigate after submission.

For example, you might want to display:

Thanks! Your message has been sent.

without leaving the page.

In that case, JavaScript can send the submission.

<form id="contact-form">

  <input
    type="text"
    name="name"
    placeholder="Your name"
    required
  />

  <input
    type="email"
    name="email"
    placeholder="Your email"
    required
  />

  <textarea
    name="message"
    placeholder="Your message"
    required
  ></textarea>

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

</form>

<p id="status"></p>

Then:

const form = document.getElementById("contact-form");
const status = document.getElementById("status");

form.addEventListener("submit", async (event) => {
  event.preventDefault();

  const data = Object.fromEntries(
    new FormData(form)
  );

  try {
    const response = await fetch(
      "https://formboost.app/f/YOUR_ENDPOINT_ID",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify(data)
      }
    );

    if (!response.ok) {
      throw new Error("Submission failed");
    }

    status.textContent =
      "Thanks! Your message has been sent.";

    form.reset();

  } catch (error) {

    status.textContent =
      "Something went wrong. Please try again.";

  }
});

Now the visitor stays on the same page.

The architecture is still:

Browser
   ↓
Formboost

There is still no application backend running on your website.

Add a Custom Thank-You Page

Another useful approach is redirecting users after a successful submission.

For example:

<form
  action="https://formboost.app/f/YOUR_ENDPOINT_ID"
  method="POST"
>

  <input
    type="hidden"
    name="_redirect"
    value="https://example.com/thank-you"
  />

  <input
    type="email"
    name="email"
    required
  />

  <button type="submit">
    Submit
  </button>

</form>

After submitting the form, the visitor can be sent to your own thank-you page.

This works well for:

/contact
     ↓
Form submission
     ↓
/thank-you

It is useful for landing pages because you can also track visits to the thank-you page as conversions.

What About Spam?

As soon as a public form goes online, automated bots can eventually find it.

If you build your own backend, spam protection becomes another thing you need to maintain.

A production form backend should handle things such as:

Request validation
Rate limiting
Spam detection
Honeypot detection
Submission filtering

Formboost handles spam screening on the backend so your static website doesn't need to implement its own spam-processing infrastructure.

HTML Form Without PHP

A common solution for HTML forms is PHP:

contact.html
     ↓
contact.php
     ↓
send email

That works if your hosting environment supports PHP.

But many modern websites are deployed to static hosting platforms.

For example:

GitHub Pages
Cloudflare Pages
Static Vercel deployment
S3
CDN hosting

These environments don't run arbitrary PHP scripts.

A hosted form backend removes that requirement.

Your architecture becomes:

contact.html
     ↓
Form backend endpoint

This means you can have a working HTML contact form without PHP.

HTML Form Without Node.js

You could also create an Express endpoint:

app.post("/contact", async (req, res) => {
  // validate data

  // prevent spam

  // save submission

  // send email

  // return response
});

But now you also need to maintain:

Node.js server
Database
Validation
Rate limiting
Spam protection
Email provider
Logging
Monitoring
Deployment

That's completely reasonable when form handling is part of your core application.

But if you're building a portfolio or landing page, maintaining an entire backend just for one contact form is usually unnecessary.

When Should You Build Your Own Backend?

A form backend isn't automatically the right solution for every application.

You should consider building your own backend when form submissions require complex business logic.

For example:

Form
 ↓
Check authenticated user
 ↓
Query account
 ↓
Calculate price
 ↓
Create payment
 ↓
Update database
 ↓
Trigger internal workflow

That belongs in your application backend.

But consider a normal contact form:

Name
Email
Message

Or:

Email
Newsletter signup

Or:

Name
Company
Project details

Building and maintaining a dedicated server for these submissions can be unnecessary overhead.

When a Form Backend Makes Sense

A hosted form backend works especially well when your website is primarily frontend-only.

Typical use cases include:

Contact Forms

Name
Email
Message

Portfolio Forms

Name
Email
Project type
Budget
Message

Landing Pages

Name
Work email
Company

Newsletter Forms

Email

Waitlists

Name
Email
Product interest

Feedback Forms

Email
Rating
Feedback

Support Forms

Email
Subject
Message

All of these can be collected without deploying your own form-processing server.

Static Site Form Backend Architecture

This architecture also keeps responsibilities nicely separated.

Your frontend handles:

HTML
CSS
User interface
Client-side validation

The form backend handles:

Receiving POST requests
Submission processing
Spam detection
Storage
Notifications
Integrations

Your site stays simple:

Static Website
      |
      |
      POST
      |
      ↓
Form Backend

This approach works regardless of whether the frontend was built with:

HTML
React
Next.js
Vue
Astro
Svelte
Hugo
Jekyll

As long as your frontend can make an HTTP POST request, it can use a form backend.

Complete HTML Example

Here is everything together:

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8" />

  <meta
    name="viewport"
    content="width=device-width, initial-scale=1.0"
  />

  <title>Contact Us</title>

</head>

<body>

  <h1>Contact Us</h1>

  <form
    action="https://formboost.app/f/YOUR_ENDPOINT_ID"
    method="POST"
  >

    <div>

      <label for="name">
        Name
      </label>

      <input
        id="name"
        type="text"
        name="name"
        required
      />

    </div>

    <div>

      <label for="email">
        Email
      </label>

      <input
        id="email"
        type="email"
        name="email"
        required
      />

    </div>

    <div>

      <label for="message">
        Message
      </label>

      <textarea
        id="message"
        name="message"
        rows="6"
        required
      ></textarea>

    </div>

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

  </form>

</body>

</html>

Replace:

YOUR_ENDPOINT_ID

with your actual Formboost form endpoint.

You can now deploy this page as a completely static website and still receive real form submissions.

Final Thoughts

You don't always need to build a backend just because your website contains a form.

For simple contact forms, feedback forms, newsletter forms, waitlists, and landing pages, a hosted form backend can remove a surprising amount of infrastructure.

Instead of building:

Frontend
+
API
+
Server
+
Database
+
Email
+
Spam protection

you can keep:

Frontend
+
Form endpoint

For developers, that means less infrastructure to maintain and more time spent building the actual product.

If you already have an HTML form, connecting it to a service such as Formboost generally requires changing only the form's action URL.

Your HTML stays yours.

Your design stays yours.

You simply don't have to build a backend just to receive a form submission.

Best Formspree Alternatives for React, Next.js & HTML in 2026

Ritu Fadadu — Fri, 11 Sep 2026 08:24:31 +0000

If you're building a React app, Next.js website, landing page, portfolio, or static HTML site, you may not want to build and maintain a complete backend just to receive form submissions.

That's where services like Formspree come in.

Formspree is a popular form backend that lets developers connect a frontend form to a hosted endpoint instead of building their own server-side form handling.

But it isn't the only option.

Depending on your project, you may be looking for a Formspree alternative because of pricing, submission limits, integrations, spam protection, developer experience, or simply because another service better fits your stack.

In this guide, we'll look at several Formspree alternatives and the things developers should consider before choosing one.

What Is Formspree?

Formspree is a hosted form backend.

The basic idea is simple: instead of writing your own backend endpoint to receive a form submission, you point your HTML or frontend form toward a hosted endpoint.

A simplified form can look like this:

<form action="YOUR_FORM_ENDPOINT" method="POST">
  <input type="text" name="name" placeholder="Your name" required>

  <input type="email" name="email" placeholder="Your email" required>

  <textarea name="message" placeholder="Your message" required></textarea>

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

The backend receives the submission and handles the processing according to the service's features and configuration.

This approach is useful for developers who want to avoid maintaining a custom backend just for contact forms, feedback forms, lead forms, newsletter signups, and similar use cases.

Why Look for a Formspree Alternative?

Formspree works well for many projects, but developers can have different requirements.

Some common reasons to compare alternatives include:

Free submission limits
Pricing
Spam protection
Webhooks
API access
File uploads
Integrations
Submission storage
Developer experience
React support
Next.js support
HTML/static-site support
Migration flexibility

The important thing is not to choose an alternative simply because it has a longer feature list.

Choose the service that fits the requirements of your particular project.

What Should You Look For in a Form Backend?

Before comparing services, define what your application actually needs.

1. Submission limits

How many submissions will your forms receive every month?

A personal portfolio may receive only a few submissions.

A business landing page or lead-generation campaign could receive considerably more.

Compare free and paid limits based on your expected usage.

2. Spam protection

Public forms eventually attract spam.

Look for features such as:

Honeypots
CAPTCHA or CAPTCHA alternatives
Automated spam detection
Rate limiting
Other abuse-prevention mechanisms

The right approach depends on the type of form you're building.

3. Integrations and webhooks

If your form is part of a larger workflow, you may want submissions to trigger another service.

For example:

Form submission
      ↓
Form backend
      ↓
Webhook
      ↓
Your application / automation / notification system

This can be useful for workflows such as:

Sending leads to Slack
Saving submissions to Google Sheets
Triggering an n8n workflow
Starting a Zapier automation
Sending data to your own backend
Creating CRM records
Triggering email sequences

If you need this type of workflow, check whether webhooks or API access are included in the plan you actually intend to use.

4. Framework support

A good form backend should fit naturally into your frontend stack.

For this comparison, that means considering:

React
Next.js
Vue
Astro
HTML
Static websites
Other frontend frameworks

Ideally, you should be able to use either a standard HTML form action or send data programmatically using fetch, Axios, or another HTTP client.

5. Migration

If you're already using Formspree, ask:

How difficult would it be to move my existing forms?

A simple endpoint-based service can make migration much easier because the frontend form can often continue using the same basic HTML structure.

In many cases, migrating can be as simple as changing:

<form action="OLD_ENDPOINT" method="POST">

to:

<form action="NEW_ENDPOINT" method="POST">

You may still need to migrate webhooks, redirects, spam settings, email notifications, integrations, and stored submissions.

Always check the exact migration requirements of the provider you're considering.

Best Formspree Alternatives

Here are several services worth considering.

1. Formboost

Formboost is a developer-first form backend designed for developers who want to receive, store, and process form submissions without building and maintaining their own backend.

It works with:

React
Next.js
Vue
Astro
Plain HTML
Static websites
Other frontend frameworks capable of making HTTP requests

Every form gets a unique endpoint.

For a normal HTML website, you can connect a form directly:

<form
  action="https://formboost.app/f/YOUR_ENDPOINT_ID"
  method="POST"
>
  <input type="text" name="name" required>

  <input type="email" name="email" required>

  <textarea name="message"></textarea>

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

For React, Next.js, Vue, or another JavaScript application, you can POST JSON directly to the same endpoint.

await fetch("https://formboost.app/f/YOUR_ENDPOINT_ID", {
  method: "POST",
  headers: {
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    name: "Alex",
    email: "alex@example.com",
    message: "Hello from my website"
  })
});

Formboost handles the backend side of the submission.

Current features include:

Hosted form endpoints
React, Next.js, Vue, Astro and HTML support
JSON and form-encoded submissions
Submission dashboard
Search and filtering
CSV export
Email notifications
Spam protection
AI-assisted spam detection on eligible plans
Honeypot spam protection
REST API
Webhooks
Custom webhook headers
Slack integration
Discord integration
Telegram integration
Google Sheets workflows
Zapier workflows
n8n workflows
Custom redirect URLs
Per-form configuration
Submission history

File uploads are planned but are not currently available, so projects requiring file attachments should take that into account when comparing providers.

Why consider Formboost?

One reason to consider Formboost is its developer-first approach.

You don't need a Formboost SDK just to receive a submission.

A regular HTML form can POST directly to the endpoint, while React, Next.js, and other frontend applications can send JSON using standard HTTP requests.

The Free plan currently includes:

10 forms
500 submissions per month
No credit card required
No expiry on the free plan

That makes it particularly useful for portfolios, landing pages, developer projects, contact forms, early-stage products, and smaller production sites that don't justify maintaining a dedicated form-processing backend.

Formboost also focuses on connecting submissions to the rest of your stack through APIs, webhooks, email notifications, chat integrations, and automation tools.

If you're specifically looking for a Formspree alternative, you can see the dedicated comparison here:

Formboost — Formspree Alternative

Best for

Formboost is particularly suited to developers who want:

A simple hosted form backend
A generous free submission allowance
React or Next.js support
Plain HTML form support
API access
Webhooks
Automation integrations
Spam protection
A dashboard for managing submissions
No custom server just for handling forms

It is especially relevant for contact forms, portfolio forms, landing pages, newsletter forms, waitlists, feedback forms, lead-generation forms, and static websites.

2. Web3Forms

Web3Forms is another popular option for developers who want to receive website form submissions without building their own backend.

It is particularly relevant for:

Static websites
HTML forms
JavaScript applications
Landing pages
Contact forms

Its straightforward form submission approach makes it attractive for smaller projects where the primary requirement is receiving form submissions without operating backend infrastructure.

When comparing Web3Forms with Formspree or Formboost, consider:

Monthly submission allowance
Email notifications
Spam protection
File uploads
Webhook capabilities
Integration options
Dashboard requirements
API capabilities
Paid pricing

Web3Forms can be a good choice when simplicity is your main requirement.

3. Basin

Basin is another established hosted form backend aimed at developers.

It lets websites receive and process form submissions without requiring developers to build the entire server-side processing layer themselves.

Basin provides functionality around:

Hosted form endpoints
Submission management
Spam filtering
File uploads
Integrations
Webhooks
Form workflows

It can be worth considering if you want a more traditional form-backend experience with a dashboard and broader form-management functionality.

When comparing Basin with the other options, look closely at:

Monthly submission limits
Paid pricing
File storage
Spam protection
Integrations
Data retention
Collaboration
Webhook/API requirements

4. Formcarry

Formcarry provides hosted form endpoints for websites and frontend applications.

The general integration pattern is similar to other form backend services: point your form toward a hosted endpoint and let the service process the submission.

It can be used for use cases such as:

Contact forms
Landing pages
Portfolio websites
Lead forms
Static websites

Formcarry currently offers both free and paid plans, with paid tiers adding higher limits and additional capabilities.

When comparing it with Formspree, Formboost, or Basin, consider:

Number of forms
Monthly submission limit
File uploads
Spam filtering
Integrations
Webhooks
Storage
Pricing as your traffic grows

5. Getform

Getform is another hosted form backend option.

It is designed for developers who want to collect form submissions without creating their own form-processing infrastructure.

Like other endpoint-based form services, it can work well for:

Static websites
Frontend applications
Landing pages
Contact forms
Lead-generation forms

When comparing Getform with Formspree, consider:

Pricing
Submission limits
Integrations
Spam protection
File handling
API support
Webhook support
Submission retention

Formboost vs Formspree

Both products solve the same fundamental problem:

Receiving form submissions without building your own form-processing backend.

However, their plans, limits, integrations, and feature availability differ.

Here's a practical comparison:

Feature	Formboost	Formspree
HTML forms	Yes	Yes
React	Yes	Yes
Next.js	Yes	Yes
Vue / other frontend frameworks	Yes	Yes
Hosted form endpoint	Yes	Yes
Free plan	Yes	Yes
Free monthly submissions	500/month	50/month
Free-plan forms	Up to 10	Multiple forms supported
Email notifications	Yes	Yes
Submission dashboard	Yes	Yes
Spam protection	Yes	Yes
Honeypot support	Yes	Yes
AI-assisted spam filtering	Yes	Spam filtering available
Webhooks	Yes	Yes
REST API	Yes	Yes, depending on plan/features
File uploads	Planned / not currently available	Yes on eligible paid plans
Slack integration	Yes	Integration options available
Discord integration	Yes	Via supported workflows/integrations
Telegram integration	Yes	Via supported workflows/integrations
Google Sheets workflows	Yes	Integration options available
Zapier workflows	Yes	Integration options available
n8n workflows	Yes	Possible through webhooks
Custom redirects	Yes	Yes
JSON submissions	Yes	Yes
Form-encoded submissions	Yes	Yes

The important part is not simply choosing the product with the most checkmarks.

Think about what your application actually requires.

For example, if your form must accept file uploads today, Formspree may currently be a better fit because Formboost's file-upload functionality is still planned.

On the other hand, if you're building contact forms or lead forms without attachments and want a higher free submission allowance, Formboost's 500 monthly submissions can make it worth considering.

A simple portfolio contact form also has very different requirements from a production lead-generation workflow connected to a CRM and multiple automation services.

Using Formboost With React

A React form does not require a custom API route just to submit data.

For example:

import { useState } from "react";

export default function ContactForm() {
  const [status, setStatus] = useState("");

  async function handleSubmit(event) {
    event.preventDefault();

    setStatus("Sending...");

    const formData = new FormData(event.currentTarget);

    const data = Object.fromEntries(formData.entries());

    try {
      const response = await fetch(
        "https://formboost.app/f/YOUR_ENDPOINT_ID",
        {
          method: "POST",
          headers: {
            "Content-Type": "application/json"
          },
          body: JSON.stringify(data)
        }
      );

      if (!response.ok) {
        throw new Error("Submission failed");
      }

      setStatus("Message sent!");
      event.currentTarget.reset();
    } catch {
      setStatus("Something went wrong.");
    }
  }

  return (
    <form onSubmit={handleSubmit}>
      <input name="name" placeholder="Name" required />

      <input
        name="email"
        type="email"
        placeholder="Email"
        required
      />

      <textarea
        name="message"
        placeholder="Message"
        required
      />

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

      {status && <p>{status}</p>}
    </form>
  );
}

This keeps your frontend code simple while the hosted form backend handles submission processing and storage.

Using Formboost With Next.js

You can also submit directly from a Next.js client component.

"use client";

import { useState } from "react";

export default function ContactForm() {
  const [status, setStatus] = useState("");

  async function handleSubmit(event) {
    event.preventDefault();

    const formData = new FormData(event.currentTarget);

    const payload = Object.fromEntries(formData.entries());

    setStatus("Sending...");

    const response = await fetch(
      "https://formboost.app/f/YOUR_ENDPOINT_ID",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json"
        },
        body: JSON.stringify(payload)
      }
    );

    if (response.ok) {
      setStatus("Submitted successfully.");
      event.currentTarget.reset();
    } else {
      setStatus("Submission failed.");
    }
  }

  return (
    <form onSubmit={handleSubmit}>
      <input name="name" required />

      <input
        name="email"
        type="email"
        required
      />

      <textarea name="message" />

      <button type="submit">Submit</button>

      <p>{status}</p>
    </form>
  );
}

For many contact forms and landing pages, this means you don't need to create and maintain a dedicated Next.js API route simply to forward form submissions.

Using Formboost With Plain HTML

For a static website, the setup is even simpler:

<form
  action="https://formboost.app/f/YOUR_ENDPOINT_ID"
  method="POST"
>
  <label>
    Name
    <input type="text" name="name" required>
  </label>

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

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

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

No JavaScript is required for the basic submission flow.

This approach works particularly well for:

Static HTML websites
Portfolio sites
Landing pages
Documentation sites
JAMstack sites

How to Choose the Right Formspree Alternative

Here's a simple way to narrow down your options.

Choose based on your framework

If you're building a React application, look for a service that integrates cleanly with React and allows standard HTTP requests without requiring unnecessary SDKs.

If you're building with Next.js, decide whether you really need an API route or whether submitting directly to the form backend is sufficient.

If you're building a static HTML website, a simple hosted endpoint may be all you need.

Choose based on volume

Estimate your monthly submissions before choosing a plan.

For example:

Personal portfolio: low volume
Small business site: low to moderate volume
SaaS landing page: moderate volume
Marketing site: moderate volume
Lead-generation campaign: potentially high volume

Don't choose a plan based only on the monthly price.

Compare the included submission volume and the features you actually need.

Choose based on automation

If every submission needs to trigger another action, look at:

Webhooks
APIs
Slack integrations
Email notifications
Google Sheets
Zapier
n8n
Other automation platforms

This can make a significant difference as your application grows.

For example:

Website form
     ↓
Form backend
     ↓
Webhook
     ↓
n8n
     ↓
CRM + Slack + Email

A workflow like this can eliminate a lot of custom backend code.

Choose based on file requirements

This is one area developers sometimes overlook.

If users need to upload:

CVs
Screenshots
PDFs
Images
Documents

make sure your selected provider supports file uploads on the plan you're considering.

For example, Formboost does not currently support file uploads, so a provider such as Formspree may make more sense if attachments are essential to your form today.

Choose based on developer experience

Consider how much custom code is required.

A good developer-focused service should ideally allow something as simple as:

<form action="YOUR_ENDPOINT" method="POST">

or:

fetch("YOUR_ENDPOINT", {
  method: "POST",
  body: JSON.stringify(data)
});

The less custom infrastructure you need to operate, the more time you can spend on the actual application.

How Hard Is It to Move Away From Formspree?

One advantage of hosted form backends is that the basic frontend integration pattern can be relatively simple.

Instead of building a new backend from scratch, you may only need to change the endpoint and adjust the configuration required by the new provider.

For example:

<form
  action="YOUR_NEW_FORM_ENDPOINT"
  method="POST"
>

However, the exact migration process depends on which Formspree features you're currently using.

Before migrating, make a checklist of:

Form endpoint
Form fields
Validation
Email notifications
Spam protection
File uploads
Redirects
Webhooks
API integrations
Stored submissions
Automation workflows
Team access
Data retention requirements

Then test the new setup before switching production traffic.

A sensible migration process is:

Create new endpoint
        ↓
Configure notifications
        ↓
Configure spam protection
        ↓
Recreate integrations
        ↓
Send test submissions
        ↓
Verify dashboard + notifications
        ↓
Update production form endpoint
        ↓
Monitor initial submissions

Don't replace your production endpoint before testing the complete workflow.

Which Formspree Alternative Should You Choose?

There isn't one answer for every developer.

If you want a simple hosted form backend, compare the services based on the features you actually need.

If you're building a React project, prioritize developer experience and easy API integration.

If you're building a Next.js application, consider whether you really need to maintain a server-side form route.

If you're building a static HTML website, simplicity may be more important than having a large feature set.

If your application relies heavily on file uploads, make file support an important part of the comparison.

If automation matters, compare webhook, API, Zapier, n8n, Slack, Google Sheets, and other integration capabilities.

And if you're already using Formspree, migration difficulty should be part of the decision.

Final Thoughts

Formspree helped make hosted form backends popular because the basic idea is simple:

Developers shouldn't necessarily have to build and maintain an entire backend just to receive a contact-form submission.

Today, there are several alternatives worth considering, including:

Formboost
Web3Forms
Basin
Formcarry
Getform

The best option depends on your:

Framework
Submission volume
Spam requirements
Integration needs
File-upload requirements
Budget
API/webhook requirements
Development workflow

If you're specifically looking for a Formspree alternative for React, Next.js, HTML, or other frontend frameworks, Formboost is one option worth evaluating alongside the other services in this category.

You can start with a free account and connect your first form without building a backend.

Learn more:

Formboost — Formspree Alternative

How to Add a Contact Form to a Static HTML Website Without a Backend

Ritu Fadadu — Tue, 01 Sep 2026 12:30:24 +0000

Building a static website with HTML is simple. But adding a contact form can be a little tricky because you need somewhere to send and process the form submissions.

The good news: you don't always need to build your own backend.

Simple HTML Form

Send

The important parts are:

action — where the form data is sent
method="POST" — sends the form data
name — identifies each submitted field

Instead of creating an Express, PHP, or other backend just for your form, you can use a hosted form endpoint.

For example, formboost lets you connect your existing HTML form and receive submissions without building a backend.

This works well for:

Portfolio websites
Landing pages
Contact forms
Feedback forms
Waitlists
Small business websites

If you already have an HTML form, you may only need to change the action and add the correct name attributes.

Keep your website static. Let the form service handle the submissions.

Try Formboost: https://formboost.app

DEV Community: Ritu Fadadu

How to Create an HTML Form Without a Backend Server

What Is a Form Backend?

Why Can't HTML Handle Form Submissions by Itself?

Creating an HTML Form Without a Backend

Using Formboost as the HTML Form Backend

Why the name Attribute Is Important

Creating a Contact Form Without JavaScript

Submitting the Form With JavaScript

Add a Custom Thank-You Page

What About Spam?

HTML Form Without PHP

HTML Form Without Node.js

When Should You Build Your Own Backend?

When a Form Backend Makes Sense

Contact Forms

Portfolio Forms

Landing Pages

Newsletter Forms

Waitlists

Feedback Forms

Support Forms

Static Site Form Backend Architecture

Complete HTML Example

Final Thoughts

Best Formspree Alternatives for React, Next.js & HTML in 2026

What Is Formspree?

Why Look for a Formspree Alternative?

What Should You Look For in a Form Backend?

1. Submission limits

2. Spam protection

3. Integrations and webhooks

4. Framework support

5. Migration

Best Formspree Alternatives

1. Formboost

Why consider Formboost?

Best for

2. Web3Forms

3. Basin

4. Formcarry

5. Getform

Formboost vs Formspree

Using Formboost With React

Using Formboost With Next.js

Using Formboost With Plain HTML

How to Choose the Right Formspree Alternative

Choose based on your framework

Choose based on volume

Choose based on automation

Choose based on file requirements

Choose based on developer experience

How Hard Is It to Move Away From Formspree?

Which Formspree Alternative Should You Choose?

Final Thoughts

How to Add a Contact Form to a Static HTML Website Without a Backend

Why the `name` Attribute Is Important