# How to Submit a Custom HTML Form to Google Forms

How to send the answers from your own HTML form to a Google Form, with plain HTML or with fetch.

Published 2026-11-17.

**Short answer:** get a pre-filled link for your Google Form. It holds the form's ID and an `entry.` number for each question. Set your form's `action` to `https://docs.google.com/forms/d/e/FORM_ID/formResponse` and name each input after its entry number. Google records the answers as a normal response. Google doesn't document this use of the address, and your page can't tell whether a submission was recorded.

Google Forms is free and can send every response to a spreadsheet, but an embedded Google Form keeps Google's layout and branding. You can keep Google Forms for storage and build the form yourself. When someone submits a Google Form, the browser posts the answers to an address that ends in `/formResponse`, and your own HTML form can post to the same address.

The settings below come from Google's help pages, which we checked on November 17, 2026. The `/formResponse` address isn't part of any documented Google API, so test your form after every change on either side.

## Check the Google Form's settings

A submission from your page doesn't include a Google sign-in, so the Google Form has to accept responses from anyone. Check these first:

* **The form is published and accepting responses.** Google's help page says you "can't accept responses in unpublished forms."
* **Anyone with the link can respond.** A form restricted to a domain, group or trusted audience asks people to sign in.
* **Nothing requires sign-in.** Set **Collect email addresses** to **Do not collect**, and turn off **Limit to 1 response** and **Allow response editing**. To get the visitor's email address, add a short answer question for it.
* **There are no file upload questions.** Respondents need a Google account to upload files.
* **All questions are in one section.** A form with several sections tracks which pages the respondent visited, and a submission without that history can lose the answers from later sections.

## Find the form ID and entry numbers

### Add a question for each field

Use **Short answer** for names, email addresses, phone numbers and dates, **Paragraph** for longer messages, and **Multiple choice**, **Dropdown** or **Checkboxes** for choices. Mark a question as required only if the matching field on your page is required too.

### Open the pre-fill form

In the form editor, click **More** at the top right and choose **Pre-fill form**.

### Fill in every question and copy the link

Type a different answer in each question, such as `Name`, `Email` and `Message`, so you can tell them apart in the link. Click **Get link**, then copy it.

The link looks like this:

```text
https://docs.google.com/forms/d/e/1FAIpQLSf3EXAMPLEfORMid/viewform?usp=pp_url&entry.1934870301=Name&entry.582210946=Email&entry.1203456789=Message
```

* **The form ID** is the part between `/d/e/` and `/viewform`. The ID in the editor's address bar is a different one, so take it from this link.
* **Each `entry.NUMBER=VALUE` pair** is one question. Match each pair to its question by the answer you typed.

## Point your form at formResponse

Replace `/viewform` with `/formResponse`, and use each entry number as an input's `name`:

```html title="contact.html"
<form action="https://docs.google.com/forms/d/e/FORM_ID/formResponse" method="POST">
  <label for="name">Name</label>
  <input id="name" name="entry.1934870301" required>

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

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

  <button type="submit">Send</button>
</form>
<p id="status" role="status"></p>
```

This works without JavaScript. After submit, the visitor lands on Google's confirmation page, which shows "Your response has been recorded" or the confirmation message set in the form's settings. Google Forms has no option to send visitors back to your site.

Add `required` to every field whose question is required in the Google Form. Google rejects a response that leaves a required question empty, and with `fetch` your page can't see the rejection.

## Keep visitors on your page with fetch

To stay on your page and show your own message, send the form with `fetch`. The response from Google has no CORS headers, so a normal `fetch` call rejects with a network error. The browser still sends the request, which means the response may be recorded while your code reports a failure.

`mode: 'no-cors'` avoids the error:

```js title="contact.js"
const form = document.querySelector('form')
const status = document.querySelector('#status')

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

  try {
    await fetch(form.action, {
      method: 'POST',
      mode: 'no-cors',
      body: new URLSearchParams(new FormData(form)),
    })
    status.textContent = 'Thanks. Your message was sent.'
    form.reset()
  } catch {
    status.textContent = 'Your message could not be sent. Check your connection and try again.'
  }
})
```

A few details in this script:

* `new URLSearchParams(new FormData(form))` sends the fields in the same format as the plain HTML form.
* With `no-cors`, the response is opaque. Your script can't read its status or body.
* The promise only rejects when the request can't be sent at all, for example when the visitor is offline. A response that Google rejected looks the same to your script as one it recorded, so the success message appears either way.
* The form keeps its `action` and `method`, so it still submits if the script fails to load.

## Send choices, checkboxes and dates

Short answer and paragraph questions accept any text. The other question types are stricter.

* **Multiple choice and dropdown.** The `value` has to match the option text exactly, including capital letters and punctuation. Copy the values from the Google Form instead of retyping them.
* **Checkboxes.** Give every checkbox in the group the same entry name. Each checked box is sent as its own pair, and Google records all of them.
* **The Other option.** Choose **Other** in the pre-fill form and type a word. The link then has two pairs for that question: the entry number with the value `__other_option__`, and `entry.NUMBER.other_option_response` with the text. Your form has to send both.
* **Dates and times.** Use a short answer question for them in the Google Form. An `<input type="date">` sends a value like `2026-11-17`, which a short answer question stores as text.

```html
<fieldset>
  <legend>Topic</legend>
  <label><input type="radio" name="entry.1450021234" value="Sales" required> Sales</label>
  <label><input type="radio" name="entry.1450021234" value="Support"> Support</label>
</fieldset>

<fieldset>
  <legend>Interested in</legend>
  <label><input type="checkbox" name="entry.877013462" value="Web design"> Web design</label>
  <label><input type="checkbox" name="entry.877013462" value="Hosting"> Hosting</label>
</fieldset>

<label for="date">Preferred date</label>
<input id="date" type="date" name="entry.96432105">
```

To record which page a submission came from, add a short answer question named something like "Page" and send it from a hidden input:

```html
<input type="hidden" name="entry.310984527" value="/pricing">
```

## If responses don't appear

Your page can't see Google's errors. When a test submission doesn't appear in the **Responses** tab, check these causes:

| Cause                                                  | Fix                                                                                                                  |
| ------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| The form isn't published, or isn't accepting responses | Click **Published** at the top right of the editor and turn on **Accepting responses**                               |
| A setting requires sign-in                             | Turn off email collection, **Limit to 1 response** and **Allow response editing**, and remove any domain restriction |
| A required question was empty                          | Add `required` to the matching field on your page                                                                    |
| An answer failed a response validation rule            | Apply the same rule on your page with `type`, `pattern` or `maxlength`, or remove the rule                           |
| A choice doesn't match                                 | Copy the option text from the Google Form into each `value`                                                          |
| An entry number changed                                | Get a new pre-filled link and compare the numbers with your inputs                                                   |
| The form has several sections                          | Move all questions into one section                                                                                  |
| The action ends in `/viewform`                         | Change it to `/formResponse`                                                                                         |

Editing a question's wording keeps its entry number. Deleting a question and adding it again gives it a new one, so get a new pre-filled link after every change to the Google Form.

## Limits of this approach

Check these limits before you rely on the setup for leads or orders:

* **Confirmation.** With `fetch`, your page can't tell a recorded response from a rejected one. Without `fetch`, visitors leave your site for Google's confirmation page.
* **Support.** Google documents pre-filled links, but not posting to `/formResponse` from another site. The [Forms API](https://developers.google.com/workspace/forms/api/reference/rest/v1/forms.responses) can read and list responses, but it has no method to create one.
* **Spam.** Google Forms has no CAPTCHA or honeypot setting, and the form ID and entry numbers are in your page's source. Anyone can post responses to the form directly.
* **File uploads.** File upload questions require a Google sign-in, so a custom form can't send files.
* **Notifications.** Google Forms can email you when a response arrives, but the email doesn't contain the answers. An add-on or an Apps Script trigger can send them.

For an event sign-up or a feedback survey, where a spreadsheet is all you need and an occasional lost response does little harm, these limits may not matter.



## When to use a form backend instead

A form backend accepts posts from your own HTML form, like Google Forms does here, but it is built to be called from other sites. We build [Nisuform](https://nisuform.com), which works like this:

* Inputs keep readable names like `name` and `email` instead of entry numbers.
* `fetch` gets a JSON response, so your page knows whether the submission was saved, and errors include a message you can show.
* Every submission is stored in an inbox and emailed to you with the answers.
* Bots are filtered with a honeypot, a fill-time check and rate limits, and you can accept submissions only from your own domains.
* On Pro, each submission can also be added as a row in [Google Sheets](/docs/integrations/google-sheets), so the spreadsheet stays.

The free plan covers 100 submissions a month across 3 forms. File uploads, redirects to your own thank-you page and the Google Sheets integration are on Pro at $10 a month. Google Forms is free.

To move the form, create one at [app.nisuform.com](https://app.nisuform.com), copy its endpoint from the **Setup** tab, change the `action` and rename the inputs:

```html title="Before"
<form action="https://docs.google.com/forms/d/e/FORM_ID/formResponse" method="POST">
  <input id="email" type="email" name="entry.582210946" required>
```

```html title="After"
<form action="https://api.nisuform.com/s/YOUR_FORM_KEY" method="POST">
  <input id="email" type="email" name="email" required>
```

The [guide to forms without a backend](/blog/html-forms-without-backend) covers the honeypot field and a `fetch` script that reads the JSON response. For other services, see [the best form backends compared](/blog/best-form-backend).

## Checklist

1. The Google Form is published, accepting responses and open to anyone with the link.
2. Email collection, **Limit to 1 response** and **Allow response editing** are off.
3. The Google Form has one section and no file upload questions.
4. The `action` uses the ID from the pre-filled link and ends in `/formResponse`.
5. Every input's `name` matches an entry number from a current pre-filled link.
6. Choice values match the option text exactly, and checkboxes in a group share one name.
7. Fields for required questions have `required` on your page.
8. A test submission from your live site appears in the Google Form's **Responses** tab.

## Sources

* Google Docs Editors Help: [Send a form with pre-filled answers](https://support.google.com/docs/answer/160000), [Publish and share your form with responders](https://support.google.com/docs/answer/2839588) and [View and manage form responses](https://support.google.com/docs/answer/139706), checked November 17, 2026
* [Google Forms API: forms.responses](https://developers.google.com/workspace/forms/api/reference/rest/v1/forms.responses)
* MDN: [Request.mode](https://developer.mozilla.org/en-US/docs/Web/API/Request/mode)
* [Nisuform plans](/docs/account/billing) and [limits](/docs/reference/limits)

## Frequently asked questions

### Can I use my own HTML form with Google Forms?

Yes. Set the form's action to your Google Form's address with /viewform replaced by /formResponse, and name each input after the entry number of the matching question, like entry.1934870301. Google records the answers as a normal response. Google doesn't document this use of the address, so it can change without notice.

### How do I find the entry IDs of a Google Form?

Open the form in the editor, click More at the top right and choose Pre-fill form. Type an answer in every question, click Get link and copy it. The link contains an entry.NUMBER=VALUE pair for each question. Match each pair to its question by the value you typed.

### Why does my custom form say it was sent, but no response appears in Google Forms?

Google rejected the submission and the page couldn't tell. The usual causes are a required question that was left empty, a choice value that doesn't match the option text exactly, a setting that requires sign-in, a form that isn't published or accepting responses, or an entry number that changed after the Google Form was edited.

### Why do I get a CORS error when I submit to Google Forms with fetch?

Google's response has no CORS headers, so the browser won't let your script read it. The request is still sent, so the response may be recorded even though fetch reports an error. Add mode: 'no-cors' to the fetch options. fetch then resolves with an opaque response, which has no status or body you can read.

### Can a Google Form redirect to my own thank-you page?

No. Google Forms has no redirect setting, and a plain HTML form that posts to it ends on Google's confirmation page. Submit with fetch instead, and when it resolves, show your own message or move the visitor to your thank-you page with window.location.

### Can a custom HTML form upload files to Google Forms?

No. File upload questions require respondents to sign in with a Google account, and a submission from your own page doesn't include a sign-in. To collect files from a custom form, you need a service that accepts uploads, such as a form backend.
