How to limit responses per option in Google Forms

What Google Forms can do natively (as of July 2026)

In January 2026, Google Forms finally gained a long-requested feature: a form can close itself. After you publish a form, the Responses tab offers a setting next to the "Accepting responses" toggle for a close date or a response limit. You have to pick one or the other, though: either a total response count or a specific date and time, not both. The feature is off by default.

Do not confuse this with "Limit to 1 response". That setting caps submissions per signed-in Google account, not the total, and has nothing to do with option capacity.

• You cannot set a limit on an individual answer option, such as 20 seats for Monday and 15 for Tuesday.
• Respondents never see how many spots are left; there is no counter anywhere.
• A full option does not disappear or get marked as taken on its own.
• There is no waitlist; whoever does not fit is simply out of luck.

Method 1: the built-in response limit (whole form only)

If the whole form shares one capacity, say 30 seats for a single field trip, the built-in limit is enough, and it is the most reliable of these methods because Google itself closes the form.

1. Publish the form.
2. Open the Responses tab and, next to the "Accepting responses" toggle, choose the setting for a close date or response limit.
3. Select closing after a number of responses and enter your capacity.
4. Save. The form stops accepting responses the moment the limit is reached.

The catch: the limit counts every submission regardless of which option was chosen. The moment your form has several sessions or groups with their own capacity, a total cap is useless: one session overflows while another stays half empty.

Method 2: add-ons that remove full options

Per-option limits are the territory of add-ons from the Google Workspace Marketplace. The best known are Choice Eliminator and Form Choice Limiter, and they work the same way: they watch incoming responses and, after each submission, edit the form to remove or strike through any option that has reached its limit.

1. In the form editor, open the add-ons menu and install Choice Eliminator or Form Choice Limiter from the Marketplace.
2. Grant the add-on access to the form; it runs under your account via Apps Script.
3. Pick the choice question and set a limit for each option.
4. Test the form before sharing it: behavior differs by question type, and dropdowns tend to work more reliably than checkboxes.

• The add-on reacts only after a response is submitted. Anyone who already has the form open sees the stale options and can still submit a full one.
• Two nearly simultaneous submissions both get through, and the limit overflows. The extra responses are yours to sort out with an apology email.
• Respondents see no counter of remaining spots; a full option just disappears without explanation.
• Higher limits, more questions, or more dependable behavior usually sit behind a paid tier.

For a form that fills over days, this is workable. For a signup that fills in one evening it is not something to rely on: the rush that makes you need limits is exactly when the race conditions pile up.

Method 3: your own Apps Script

You can write what the add-ons do yourself: a script bound to the form submit trigger counts the answers and removes full options from the question. You gain control and pay nothing, but the same window between submission and form edit stays open.

const LIMITS = { 'Monday 9:00': 20, 'Tuesday 9:00': 15 };
const QUESTION = 'Pick a session';

function onFormSubmit() {
  const form = FormApp.getActiveForm();
  const counts = {};
  form.getResponses().forEach((response) => {
    response.getItemResponses().forEach((item) => {
      if (item.getItem().getTitle() !== QUESTION) return;
      const choice = item.getResponse();
      counts[choice] = (counts[choice] || 0) + 1;
    });
  });
  const question = form
    .getItems(FormApp.ItemType.MULTIPLE_CHOICE)
    .map((i) => i.asMultipleChoiceItem())
    .find((i) => i.getTitle() === QUESTION);
  if (!question) return;
  const open = Object.keys(LIMITS).filter((v) => (counts[v] || 0) < LIMITS[v]);
  if (open.length > 0) {
    question.setChoiceValues(open);
  } else {
    form.setAcceptingResponses(false);
  }
}

Save the script inside the form (Extensions, then Apps Script) and add an installable trigger for the form submit event under Triggers. Note the final branch: a choice question cannot be left with an empty option list, so when every option fills up the script closes the whole form instead.

Method 4: manual closing with Google Sheets

The simplest route with nothing to install: link the form to Google Sheets, count responses per option with COUNTIF, and delete full options by hand in the form editor.

This works for forms that fill slowly and that you keep an eye on. Once responses arrive faster than you refresh the sheet, you are back to overbooked sessions, now with extra manual work on top.

Which method to pick

• One shared capacity for the whole form: the built-in response limit. Install nothing else.
• Several options with their own limits and a relaxed signup pace: an add-on like Choice Eliminator, knowing the limits are soft.
• You are comfortable with code and want the behavior under your control: your own Apps Script. The race window does not go away, though.
• The signup fills within hours and overbooking is not an option: you need a tool that enforces capacity in a database, not by editing the form after each submission.

If you need real per-option limits

Every method above shares the same ceiling: Google Forms has no concept of capacity, so limits are always enforced after the fact by editing the form. If limited seats are the core of your signup form, it is simpler to use a tool built around them.

In databooq, every option carries its own seat limit enforced in the database: two people can race for the last seat, and only one gets it. Respondents see a live counter of open seats, a full session flips to FULL in every open tab at once, and latecomers join a waitlist that emails them when a seat frees up. It is free while in beta.