How to Submit Form Data to Google Sheets Without Any Backend Code

You have a static site, a landing page, or a simple form — and you need the data in Google Sheets. You don't want to spin up an Express server, deploy Firebase functions, or manage a database. You just want form data in a spreadsheet.

This is one of the most common problems for web developers and no-code builders alike. In this guide, we'll cover every way to solve it — from the simplest one-minute setup to the DIY approach with Google Apps Script.

Why Skip the Backend?

Writing a backend server to handle form submissions means:

• Hosting costs. You need a server running 24/7. Even a cheap VPS is $5-10/month. Serverless functions still have costs at scale.
• Complexity. Authentication, CORS headers, error handling, rate limiting, data validation — there's more code to write than you'd think.
• Maintenance. Servers crash, dependencies have security patches, APIs change. Every backend is a thing you have to keep running.
• Time. Setting up a backend for form handling takes hours. Most of that time is boilerplate you'll never think about again.

For form submissions that go into a Google Sheet, a backend server is almost always overkill. There are simpler ways.

The Simplest Method: Sheet Monkey

Sheet Monkey gives you a URL that you set as your form's action. When someone submits the form, the data goes directly into your Google Sheet. No backend, no middleware, no polling.

Working example (5 lines of HTML)

<form action="https://api.sheetmonkey.io/form/YOUR_ID" method="POST">
  <input type="text" name="Name" placeholder="Name" required />
  <input type="email" name="Email" placeholder="Email" required />
  <textarea name="Message" placeholder="Message"></textarea>
  <button type="submit">Send</button>
</form>

That's a fully working form that sends data to Google Sheets. No JavaScript, no backend, no build process.

How it works under the hood

1. The browser sends a POST request to Sheet Monkey's endpoint.
2. Sheet Monkey authenticates with Google on your behalf (credentials are stored securely in Sheet Monkey's cloud, not on your site).
3. Sheet Monkey writes the data to your Google Sheet using the Sheets API.
4. The user sees a success message or is redirected to your thank-you page.

The entire round-trip takes less than a second.

Features you get for free

Even on Sheet Monkey's free tier (100 submissions/month), you get:

• Automatic timestamps on every submission
• File uploads — just add <input type="file" name="Resume"> and files are stored with links in your sheet
• Email notifications — get an email when someone submits
• Autoresponder emails — send confirmation emails to submitters automatically
• Custom redirects — redirect to a thank-you page after submission
• Write-only security — your endpoint can only write to your sheet, never read from it

AJAX submission (no page redirect)

If you want the form to submit without leaving the page:

const form = document.querySelector('form');

form.addEventListener('submit', async (e) => {
  e.preventDefault();

  const response = await fetch(form.action, {
    method: 'POST',
    body: new FormData(form),
  });

  if (response.ok) {
    form.reset();
    // Show success message
  }
});

No CORS issues. Sheet Monkey handles cross-origin requests properly.

Alternative: Google Apps Script (Free But Complex)

Google Apps Script lets you deploy a web app that receives form data and writes it to a Google Sheet. It's free but requires coding and has limitations.

Full walkthrough

Step 1: Create a Google Sheet with column headers (e.g., Name, Email, Message).

Step 2: Open Extensions > Apps Script and paste:

function doPost(e) {
  var sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
  var headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
  var row = [];

  for (var i = 0; i < headers.length; i++) {
    if (headers[i] === 'Timestamp') {
      row.push(new Date());
    } else {
      row.push(e.parameter[headers[i]] || '');
    }
  }

  sheet.appendRow(row);

  return ContentService
    .createTextOutput(JSON.stringify({ result: 'success' }))
    .setMimeType(ContentService.MimeType.JSON);
}

Step 3: Deploy as a web app (Deploy > New Deployment > Web app). Set access to "Anyone".

Step 4: Use the web app URL as your form action.

The downsides

• CORS issues. JavaScript fetch calls to Apps Script hit CORS errors. You must use traditional form POST (which causes a page redirect) or use a workaround like no-cors mode (which prevents reading the response).
• Debugging. Errors don't appear in your browser console. You have to check the Apps Script execution log, which often gives unhelpful messages.
• Maintenance. Google periodically updates the Apps Script runtime. Your script can break without warning.
• Rate limits. Google imposes quotas on Apps Script executions. During traffic spikes, submissions can be silently dropped.
• No features. No file uploads, no notifications, no autoresponders, no redirects. Just raw data into a sheet.

Alternative: Fetch API + Third-Party Service

You can also use JavaScript to POST data to form backend services that aren't Google Sheets-native:

Formspree approach

fetch('https://formspree.io/f/YOUR_ID', {
  method: 'POST',
  body: new FormData(form),
  headers: { 'Accept': 'application/json' }
});

Formspree sends data to your email but doesn't connect to Google Sheets natively. You'd need Zapier ($20+/month) to bridge the gap. See our Formspree comparison.

Web3Forms approach

fetch('https://api.web3forms.com/submit', {
  method: 'POST',
  body: new FormData(form)
});

Web3Forms is free (250 submissions/month) and sends to email. Like Formspree, no native Google Sheets connection.

The common problem

All of these services store your data on their servers or send it to your email. None of them write directly to Google Sheets. To get data into a sheet, you need to add Zapier or a similar tool — which adds cost, complexity, and latency.

Sheet Monkey is the only service that writes directly to Google Sheets without middleware.

Comparison: Which Method Is Best?

Framework-Specific Guides

Sheet Monkey works with any frontend framework. Here's the pattern for each:

React

function ContactForm() {
  const handleSubmit = async (e) => {
    e.preventDefault();
    const data = new FormData(e.target);
    await fetch('https://api.sheetmonkey.io/form/YOUR_ID', {
      method: 'POST',
      body: data,
    });
    e.target.reset();
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" name="Name" required />
      <input type="email" name="Email" required />
      <button type="submit">Send</button>
    </form>
  );
}

See the full guide: React forms to Google Sheets.

Vue

<template>
  <form @submit.prevent="handleSubmit">
    <input v-model="name" type="text" name="Name" required />
    <input v-model="email" type="email" name="Email" required />
    <button type="submit">Send</button>
  </form>
</template>

<script>
export default {
  data() {
    return { name: '', email: '' };
  },
  methods: {
    async handleSubmit(e) {
      await fetch('https://api.sheetmonkey.io/form/YOUR_ID', {
        method: 'POST',
        body: new FormData(e.target),
      });
      this.name = '';
      this.email = '';
    },
  },
};
</script>

See the full guide: Vue forms to Google Sheets.

Next.js

Sheet Monkey works with Next.js static exports and server-rendered pages. Just use a standard form action or the fetch approach above. No API routes needed.

Platform-Specific Guides

Sheet Monkey works with every major website platform:

• Webflow — Set the form action in the designer
• Carrd — Custom form type with action URL
• Squarespace — Code block with custom form
• WordPress — CF7 plugin or custom form action
• GitHub Pages — Standard HTML form

Advanced Features for Backend-Less Forms

File uploads without a server

With Sheet Monkey, file uploads work with just an HTML input:

<input type="file" name="Document" />

The file is stored securely and a link appears in your Google Sheet. No server-side file handling code needed. See our file uploads guide.

Autoresponder emails without a server

Send confirmation emails to form submitters automatically. Configure the template in your Sheet Monkey dashboard using Handlebars syntax:

Hi {{Name}}, thanks for reaching out! We'll get back to you within 24 hours.

No email server, no SendGrid, no Mailchimp. See our autoresponder guide.

UTM tracking without analytics tools

Capture ad campaign data (utm_source, utm_medium, utm_campaign) in hidden form fields and send them to your Google Sheet alongside the submission data:

<input type="hidden" name="utm_source" id="utm_source" />
<script>
  const params = new URLSearchParams(window.location.search);
  document.getElementById('utm_source').value = params.get('utm_source') || '';
</script>

Analyze conversion data directly in Google Sheets with COUNTIF and QUERY formulas. See our UTM tracking guide.

Get Started

No backend required. Submit your first form to Google Sheets free with Sheet Monkey — 100 submissions/month, setup in under a minute.