EmailJS Alternative: Forminit vs EmailJS (2026)

• Both handle forms from client-side JavaScript; EmailJS sends emails, while Forminit stores and validates submissions before sending notifications.
• Storage: EmailJS keeps sent-email history for 7 days on Free and 30 days on paid plans; Forminit stores submissions with no time limit by default.
• File uploads: Forminit accepts 25 MB on Free; EmailJS attachments start at 500 KB on the $9/mo Personal plan.
• Webhooks: Forminit from $19/mo; EmailJS does not offer webhooks.
• Free quotas: Forminit 100 stored submissions/mo; EmailJS 200 email requests/mo.

Forminit is an EmailJS alternative for developers who need more than email delivery. EmailJS sends form data to your inbox and keeps a short-lived sent-email log. Forminit is a full form backend: it stores every submission in a searchable inbox, validates data server-side, accepts 25 MB file uploads, and forwards data anywhere via webhooks and a REST API.

Sources: EmailJS’s official pricing page and documentation. Email history retention was re-verified on 31 August 2026; prices and team seats on 6 October 2026.

---

How does Forminit compare to EmailJS?

EmailJS and Forminit both let you handle forms from client-side JavaScript without running a server. The difference is scope: EmailJS is an email delivery service, while Forminit is a form backend that treats email notifications as one output among many.

---

Is Forminit as easy to set up as EmailJS?

Yes, and there are fewer steps. EmailJS setup means creating an account, connecting an email provider (Gmail, Outlook, or SMTP), building an email template, and copying three identifiers into your code. Forminit setup means creating a form and copying one Form ID. Email notifications work out of the box, so there is no template to configure before your first submission arrives.

---

Why switch from EmailJS to Forminit?

1. A real submissions inbox, not an email log

EmailJS keeps a history of sent emails for 7 days on the Free plan and 30 days on the paid plans. If an email is deleted or the history window passes, the data is gone. Forminit stores every submission in a searchable dashboard. You can:

• View all submissions in one place
• Search and filter by any field
• Track status (open, in progress, done, cancelled) and add internal notes
• Export to CSV anytime without relying on email

The history window is also fixed. You cannot extend it to keep a record longer, and you cannot shorten it if your data-handling policy calls for that. Forminit stores submissions with no time limit by default, and Submission Retention on paid plans lets you set a period per form, after which the submission and its uploaded files are permanently deleted.

2. File uploads on every plan

EmailJS supports attachments only on paid plans: 500 KB on Personal, 2 MB on Professional, 30 MB on Business. Forminit accepts file uploads up to 25 MB per submission with 50+ MIME types, including on the Free plan, with proper storage and direct download URLs.

<input type="file" name="fi-file-resume" accept=".pdf,.doc,.docx" />
<input type="file" name="fi-file-documents[]" multiple />

3. Server-side validation

EmailJS forwards whatever the browser sends. Forminit validates data on the server before storing:

Invalid submissions return clear error messages with specific field information, so garbage data never reaches your inbox or your automations.

4. Webhooks

EmailJS has no webhook support. Forminit can forward submissions to any URL, which connects your forms to:

• CRM systems (HubSpot, Salesforce)
• Databases (PostgreSQL, MongoDB)
• Communication tools (Slack, Discord)
• Spreadsheets (Google Sheets, Airtable)
• Your own backend services

For spreadsheets specifically, Forminit also has a native Google Sheets integration that writes each new submission to a sheet as a row, no webhook required.

5. REST API access

EmailJS’s API covers sending emails and reading the last 30 days of history. Forminit’s REST API is built for data access:

curl -X GET 'https://api.forminit.com/v1/forms/YOUR_FORM_ID' \
  -H 'X-API-Key: YOUR_API_KEY'

Query, filter, and paginate through all your form data programmatically.

6. API key security

With EmailJS, your service ID, template ID, and public key all ship to the browser. Forminit exposes only a Form ID client-side, and provides proxy handlers for Next.js and Nuxt.js that keep API keys on the server:

// app/api/forminit/route.ts
import { createForminitProxy } from 'forminit/next';

export const POST = createForminitProxy({
  apiKey: process.env.FORMINIT_API_KEY,
});

7. Marketing attribution

Forminit automatically captures:

• UTM parameters (source, medium, campaign, term, content)
• Ad platform click IDs (gclid, fbclid, msclkid, ttclid, twclid)
• Referrer URL
• Geolocation (country, city, timezone)

No additional code required. EmailJS captures none of this.

---

8. Automated workflows

Build the follow-up once and every submission runs it. Forminit’s Workflow is a visual canvas for what happens after submit. Start from Submission received, chain the actions you need and branch with If / else steps.

• Several actions in one flow. Notify your team, send an autoresponse, post to Slack or Discord, add a row to Google Sheets, call your webhook, change the submission status, or move it to Spam or Trash. Steps before a branch run for every submission; steps on a branch run only for matching ones.
• Routing on real answers. Conditions read form fields, sender details and tracking data such as UTM parameters. Compare text, numbers, dates, email and URL domains, phone country codes or uploaded files, combine conditions with Match all or Match any, and add Else if branches for each route.
• Full visibility when something fails. Each submission shows which actions ran and the error behind any failure. Filter results by status and action in Settings → Logs, then retry just the failed action instead of the whole workflow. Spam you restore to the inbox can be processed with Run workflow.
• Safe changes. Edits stay in a draft until you Publish, and a new webhook must pass a test before it goes live.

                ╭───────────────────────╮
                │  Submission received  │
                ╰───────────┬───────────╯
                ╭───────────▼───────────╮
                │ Send to Google Sheets │
                ╰───────────┬───────────╯
                ╭───────────▼───────────╮
                │       If / else       │
                │     Budget > 5000?    │
                ╰───────────┬───────────╯
              ╭─────────────┴─────────────╮
              │ If                        │ Else
  ╭───────────▼───────────╮   ╭───────────▼───────────╮
  │      Notify sales     │   │     Email general     │
  │        in Slack       │   │       enquiries       │
  ╰───────────────────────╯   ╰───────────────────────╯

Email notifications, conditions and status actions work on every plan, including Free. Autoresponses, webhooks, Slack, Discord and Google Sheets start on Pro.

EmailJS sends one email per call from your code. Choosing a recipient, template or follow-up based on the answers is logic you write and maintain in your frontend, and there is no step that posts the same submission to Slack, a spreadsheet or a webhook afterwards.

How long has Forminit been around?

Forminit has operated continuously since 2015, first as Getform.io and as Forminit since January 2026. It is operated by UXPLUS LTD, a UK-registered company, and has handled form submissions for teams at Burger King, Volkswagen, Toyota, Lidl, Codecademy, Sticker Mule, and the University of Essex.

Your lead flow sits in your critical path. A track record of more than a decade of paying customers means the service receiving your submissions will still be here next year, storing them, not just sending them.

Use case comparison

---

Pricing comparison

EmailJS prices by emails sent per month. Forminit prices by submissions collected per month.

EmailJS plans:

Forminit plans:

Two differences worth noting when comparing costs:

• What a “request” buys. An EmailJS request sends one email and keeps it in history for at most 30 days. A Forminit submission is stored, validated, searchable, and exportable, and triggers notifications, webhooks, and integrations.
• Attachment economics. Sending a 3 MB file through EmailJS requires the $40/mo Business plan. Forminit handles it on the Free plan.

EmailJS offers 20% off with yearly billing. Forminit’s yearly billing gives you 2 months free on Pro ($190/year) and 6 months free on Business ($594/year, or $49.50/month). When you exceed your quota, EmailJS stops processing requests and over-limit submissions are ignored; Forminit pauses your forms until you upgrade.

---

When EmailJS may be the better choice

A fair comparison cuts both ways. EmailJS is the better fit when:

• You only need templated emails sent through your own provider. EmailJS connects directly to Gmail, Outlook, or custom SMTP and sends from your account with its template editor. If delivery is genuinely all you need, that focus is a feature.
• You want more free sends. EmailJS’s free plan allows 200 requests per month against Forminit’s 100 submissions, as long as you can live without attachments, storage, and validation.
• You deliberately don’t want submissions stored. If your data-handling policy is “email it and keep nothing,” an email relay with a 7-day history is closer to that than a form backend designed around storage.

If any of those stop being true (the first file upload, the first lost lead, the first CRM integration), that’s typically when teams migrate.

---

Migrating from EmailJS

Migration is a field-rename plus a one-line code change. There is no email service to connect and no template to build.

Field name mapping

Code changes

EmailJS:

emailjs.sendForm('service_id', 'template_id', form, 'public_key');

Forminit:

const forminit = new Forminit();
forminit.submit('YOUR_FORM_ID', new FormData(form));

Email notifications, storage, and validation are active immediately; there is nothing else to wire up.

---

Quick Start

1. Create a Form

Sign up at forminit.com and create a form to get your Form ID.

2. Install the SDK

npm install forminit

3. Implement

HTML / JavaScript:

<form id="contact-form">
  <input type="text" name="fi-sender-firstName" placeholder="First name" required />
  <input type="text" name="fi-sender-lastName" placeholder="Last name" required />
  <input type="email" name="fi-sender-email" placeholder="Email" required />
  <textarea name="fi-text-message" placeholder="Message" required></textarea>
  <button type="submit">Send</button>
</form>

<script src="https://forminit.com/sdk/v1/forminit.js"></script>
<script>
  const forminit = new Forminit();
  
  document.getElementById('contact-form').addEventListener('submit', async (e) => {
    e.preventDefault();
    
    const { data, error } = await forminit.submit('YOUR_FORM_ID', new FormData(e.target));
    
    if (error) {
      console.error(error.message);
      return;
    }
    
    console.log('Submitted:', data.hashId);
    e.target.reset();
  });
</script>

Next.js:

// app/api/forminit/route.ts
import { createForminitProxy } from 'forminit/next';

export const POST = createForminitProxy({
  apiKey: process.env.FORMINIT_API_KEY,
});

// components/ContactForm.tsx
'use client';

import { Forminit } from 'forminit';

const forminit = new Forminit({ proxyUrl: '/api/forminit' });

export function ContactForm() {
  async function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
    e.preventDefault();
    
    const { data, error } = await forminit.submit('YOUR_FORM_ID', new FormData(e.currentTarget));
    
    if (error) {
      console.error(error.message);
      return;
    }
    
    console.log('Submitted:', data.hashId);
    e.currentTarget.reset();
  }

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" name="fi-sender-firstName" placeholder="First name" required />
      <input type="text" name="fi-sender-lastName" placeholder="Last name" required />
      <input type="email" name="fi-sender-email" placeholder="Email" required />
      <textarea name="fi-text-message" placeholder="Message" required />
      <button type="submit">Send</button>
    </form>
  );
}

---

FAQ

Is Forminit harder to set up than EmailJS?

No. Both work from client-side JavaScript. EmailJS requires connecting an email service, creating a template, and wiring a service ID, template ID, and public key into your code. Forminit needs one Form ID: point the SDK at it and submissions are stored, validated, and emailed to you automatically.

Does EmailJS store form submissions?

Not as a submissions database. EmailJS keeps a sent-email history for 7 days on the Free plan and 30 days on the paid plans. Forminit stores every submission in a searchable inbox with status tracking, internal notes, filtering, and CSV export.

Can I send file attachments with EmailJS?

Only on paid plans, and the limits are tight: 500 KB on Personal ($9/mo), 2 MB on Professional ($15/mo), and 30 MB on Business ($40/mo). The free plan has no attachment support. Forminit accepts file uploads up to 25 MB per submission, including on the Free plan.

What happens when I go over my monthly quota?

EmailJS stops processing requests once your monthly quota is reached; over-limit submissions are ignored. Forminit pauses your forms when you hit your plan limit, and upgrading resumes collection immediately.

What spam protection options are available?

Forminit’s spam protection is built in and works out of the box. You can additionally enable Cloudflare Turnstile, reCAPTCHA, hCaptcha, or a honeypot field. EmailJS offers CAPTCHA verification that you configure yourself.

Is Forminit GDPR compliant?

Yes. Forminit is UK-registered, ICO-listed, and complies with the UK GDPR and the EU GDPR framework. All form data is encrypted and stored on AWS servers in Ireland (EU), a DPA is included, and all subprocessors are EU-based.

---

Related Documentation

• Form Blocks Reference — Available field types
• File Uploads — File upload handling
• Next.js Integration — Next.js setup
• Nuxt.js Integration — Nuxt.js setup
• Node.js Integration — Server-side usage
• Submission Retention — Choose how long each form keeps submissions
• Workflow: Automate what happens after each submission
• List Submissions API — Retrieve submissions
• Submit Form API — API reference