How to Limit Responses in Google Forms (Daily, Total, and Per-Person)

There are plenty of reasons to cap the number of responses a form can collect. You are running an event with 200 seats. You are accepting contest entries and need to stop at 500. You are scheduling daily appointment slots and can only handle 10 per day. Or you are simply trying to prevent one person from submitting the same form 15 times.

Google Forms now has a native total response limit -- added in early 2026 -- which is a welcome improvement. But it only covers one of these scenarios. Daily caps, per-person limits without requiring login, and combining response limits with scheduled close dates all require workarounds or a different tool entirely.

This guide covers every method for limiting responses in Google Forms: the new native setting, the per-person toggle, the formLimiter add-on, and an Apps Script approach for daily resets. We will also cover where each method falls short and what to do when you need something more flexible.

NEW in 2026: Native Total Response Limit

Google quietly rolled out a total response limit feature in early 2026. It lives in the Publish settings and lets you set a hard cap on the number of submissions your form will accept before it automatically closes.

How to Set It Up

1. Open your Google Form and click the Settings tab (gear icon) at the top.
2. Scroll down to the "Publish settings" section or click "Publish settings" in the sidebar if your interface uses the updated layout.
3. Toggle on "Limit number of responses." A numeric input field appears.
4. Enter your maximum number. For example, type 200 if you are capping event registrations at 200 attendees.
5. Save. The setting takes effect immediately. Once the form reaches the specified number of submissions, it automatically stops accepting responses and displays a "This form is no longer accepting responses" message.

How It Works

The counter increments with each successful submission. When the count hits your limit, Google Forms closes the form to new respondents. Existing respondents who have the form open in their browser but have not yet submitted will see an error when they try to submit after the cap has been reached.

There is no partial-close behavior. The form goes from fully open to fully closed the moment the limit is hit. You cannot display a custom "form closed" message -- respondents see Google's default text.

Limitations of the Native Limit

• Total only. There is no option for daily, weekly, or hourly limits. If you need to cap responses at 10 per day, this setting cannot help.
• Cannot combine with a close date. If you set a response limit of 200 and also want the form to close on March 31 regardless of how many responses you have received, you cannot do both natively. The response limit and the scheduled close date are separate features that do not interact -- you can only use one or the other.
• No notifications. Google Forms does not alert you when the limit is approaching or when it has been reached. You have to check manually.
• No waitlist behavior. When the form closes, it just closes. There is no option to collect overflow submissions into a waitlist or display a "registration full, join the waitlist" message.

For simple total caps where you do not need any of the above, the native setting works fine. For anything more complex, keep reading.

Per-Person Limit: "Limit to 1 Response"

Google Forms has had a "Limit to 1 response" setting for years. It restricts each respondent to a single submission, which is useful for preventing duplicate entries in surveys, polls, and applications.

How to Set It Up

1. Open your Google Form and click Settings.
2. Under the "Responses" section, find the toggle labeled "Limit to 1 response."
3. Toggle it on. Google Forms will now require respondents to sign in with their Google account before submitting. If they have already submitted, they will see a message saying they have already responded.

The Google Sign-In Requirement

This is the key limitation. To enforce the one-response-per-person rule, Google Forms requires respondents to sign in with a Google account. There is no alternative. If your audience does not have Google accounts -- or if requiring sign-in creates too much friction -- this setting is not practical.

For internal company forms (where everyone has a Google Workspace account), this works well. For public-facing forms targeting customers, event attendees, or the general public, requiring Google sign-in will reduce your completion rate significantly. Many respondents will abandon the form when they see the login prompt.

It Is Easy to Circumvent

Even with the setting enabled, the limit is tied to the Google account, not the person. Anyone with multiple Google accounts can submit multiple times by switching accounts. There is no device-level, browser-level, or IP-based deduplication. For low-stakes surveys, this is rarely a problem. For contests, giveaways, or anything where people have an incentive to submit multiple times, it is not a reliable safeguard.

Total Response Limits with the formLimiter Add-On

Before Google added the native response limit, the most popular solution was the formLimiter add-on. It is still widely used because it offers features the native limit does not, including email notifications and date-based closing.

If you are exploring other useful Google Forms add-ons, formLimiter is one of the most popular for response management.

How to Set It Up

1. Install formLimiter. In your Google Form, click the three-dot menu in the top-right corner, then select "Get add-ons." Search for "formLimiter" and install it. Grant the required permissions.
2. Open formLimiter. After installation, click the add-ons puzzle piece icon, then select "formLimiter" > "Set limit."
3. Choose your limit type. formLimiter lets you set a limit based on:
   • Number of form responses (e.g., stop after 200)
   • Date and time (e.g., close on March 31 at 11:59 PM)
   • Spreadsheet cell value (e.g., close when a calculated value in your linked Google Sheet exceeds a threshold)
4. Set the limit value and click "Save and enable."
5. Configure notifications (optional). formLimiter can email you when the form is about to reach its limit or when it closes.

Free vs. Paid

The free tier of formLimiter supports basic response count limits and date-based closing. Paid tiers (starting around $3/month) add features like custom closed messages, spreadsheet-cell-based limits, and the ability to manage limits across multiple forms. For most use cases, the free tier is sufficient.

Why Use formLimiter Over the Native Limit?

• Email notifications when the limit is approaching or reached.
• Date-based closing can be combined with response limits (set whichever triggers first).
• Spreadsheet-cell-based limits for dynamic caps that depend on external data.
• Custom closed messages on the paid tier.

The trade-off is that formLimiter is a third-party add-on. It requires granting permissions to your Google account, and it depends on the developer continuing to maintain it. Add-ons can break after Google Forms updates, and they occasionally have permission or syncing issues.

Daily Limits with Apps Script

There is no native way to set daily response limits in Google Forms. Neither the built-in settings nor formLimiter support a "reset the counter every day" model. If you need to accept exactly 10 responses per day (for daily appointment slots, for example), you need Apps Script.

This approach uses a time-driven trigger that runs once per day to reopen the form and reset the counter.

The Script

Open your Google Form, click the three-dot menu, and select "Script editor." Replace the contents with the following:

const DAILY_LIMIT = 10;

function onFormSubmit(e) {
  const form = FormApp.getActiveForm();
  const todayStart = new Date();
  todayStart.setHours(0, 0, 0, 0);

  const allResponses = form.getResponses();
  let todayCount = 0;

  for (let i = allResponses.length - 1; i >= 0; i--) {
    const timestamp = allResponses[i].getTimestamp();
    if (timestamp >= todayStart) {
      todayCount++;
    } else {
      break; // Responses are chronological, so stop once we pass today
    }
  }

  if (todayCount >= DAILY_LIMIT) {
    form.setAcceptingResponses(false);
    form.setCustomClosedFormMessage(
      "Today's slots are full. The form reopens tomorrow."
    );
  }
}

function reopenForm() {
  const form = FormApp.getActiveForm();
  form.setAcceptingResponses(true);
}

How to Set Up the Triggers

1. In the Script editor, click the clock icon on the left sidebar (Triggers).
2. Create a trigger for onFormSubmit:
   • Choose function: onFormSubmit
   • Event source: "From form"
   • Event type: "On form submit"
   • Click Save.
3. Create a trigger for reopenForm:
   • Choose function: reopenForm
   • Event source: "Time-driven"
   • Type: "Day timer"
   • Time of day: "Midnight to 1am" (or whenever you want the daily reset)
   • Click Save.

How It Works

Every time someone submits the form, onFormSubmit counts how many responses were submitted today. If the count hits the daily limit, it closes the form and displays a custom message. At midnight (or your chosen reset time), reopenForm runs and reopens the form for the next day.

Limitations

• Counting is not instant. The onFormSubmit trigger fires after the response is saved, so there is a small window where concurrent submissions could exceed the limit. If two people submit at the exact same moment when the count is at 9 (with a limit of 10), both might go through, giving you 11 responses for the day.
• Apps Script quotas. Google limits free Apps Script to 90 minutes of execution time per day and 20 triggers. For most forms, this is more than enough. For high-volume forms receiving thousands of daily submissions, you could hit quota limits.
• Maintenance burden. You are now maintaining custom code tied to a specific Google Form. If you duplicate the form, the script does not come with it. If you need to change the limit, you have to edit the script directly.
• No per-person daily limits. This script limits total daily responses, not per-person. Combining it with the "Limit to 1 response" setting only prevents the same Google account from submitting twice ever, not twice per day.

The Gap: Combining Limits with Scheduled Close Dates

One of the most common requirements for event registration and application forms is: "Accept up to 200 responses, but also close the form on March 31 regardless." In other words, whichever comes first -- the response cap or the deadline -- should close the form.

Google Forms cannot do this natively. The built-in response limit and any date-based closing are independent features. You can set one or the other, but they do not interact.

formLimiter solves this partially. You can set both a response count limit and a date limit, and whichever triggers first will close the form. But this requires a third-party add-on with its own limitations.

If you also need a daily cap within a date range (e.g., accept 10 responses per day from March 1 through March 31, up to 200 total), there is no clean solution in Google Forms. You would need a custom Apps Script that handles both the daily reset and the total cap and the date range, which is fragile and difficult to maintain.

Comparison: All Response Limit Methods

A Different Approach: Form Builders with Built-In Submission Management

If you are finding yourself layering Apps Script on top of add-ons on top of Google Forms to manage response limits, it is worth asking whether Google Forms is the right tool for the job.

Dedicated form builders like Buildorado approach submission management differently. Instead of per-form response caps, Buildorado manages submissions at the plan level -- each tier includes a generous monthly submission allowance across all your forms. The free tier includes 100 submissions per month, and paid plans scale significantly higher.

Where Buildorado genuinely excels in this context is post-submission workflow automation. Instead of closing a form after a fixed count, you can build conditional logic that handles overflow scenarios intelligently:

• Conditional routing. Use branch nodes to route submissions based on any field value. If an event form detects a specific ticket type is sold out (by checking against an external data source via HTTP request), it can display a different message or route the respondent to a waitlist workflow.
• Email notifications. Automatically notify your team when submission volume hits a threshold, without relying on add-on notification features.
• Integration actions. Push submission data to Google Sheets, your CRM, or any API in real time -- giving you a live count you can act on.

The trade-off is that Buildorado does not currently offer per-form response caps or daily limits as a form-level setting. Those are features on the roadmap. But the workflow automation engine gives you the building blocks to handle most response management scenarios programmatically, without the fragility of Scripts or add-on dependencies.

For teams that need response limits primarily for event registration, Buildorado's conditional logic and multi-step form capabilities let you build smart registration flows that check availability and route accordingly -- a more flexible approach than a hard form close.

Use Cases

Event Registration with Capacity Caps

You are hosting a workshop with 50 seats. In Google Forms, use the native total response limit set to 50, and optionally add formLimiter for a date-based close as a fallback. If you also need to collect payments for the event, consider a dedicated form builder with native payment integration so you do not end up with unpaid registrations.

Contest Entry Limits

You are running a giveaway and want to cap entries at 1,000 with one entry per person. In Google Forms, combine the native response limit (for the total cap) with "Limit to 1 response" (for per-person). The downside is that all entrants must sign in with Google, which adds friction and may reduce participation.

Daily Appointment Slots

A clinic offers 15 appointment slots per day. In Google Forms, this requires the Apps Script approach described above, with all its limitations around concurrency and maintenance. This is one of the clearest cases where Google Forms is being pushed beyond its design -- a scheduling tool or a dedicated form builder with workflow automation would handle this more reliably.

Survey Sampling

You are conducting market research and want exactly 500 responses from a specific demographic. Use the native total limit set to 500 and add conditional logic at the start of the form to screen respondents. Google Forms' section-based branching can route ineligible respondents to a thank-you section, though it uses section routing rather than field-level conditions.

Set Up Response Limits in Under a Minute

Google Forms' new native response limit is a step forward, but it covers only the simplest scenario: a total cap with no daily resets, no per-person enforcement without login, and no combination with scheduled dates. For anything beyond a basic total limit, you are looking at add-ons, custom scripts, or a different platform.

If you need forms with powerful post-submission logic -- conditional routing, automated notifications, and integration actions -- try Buildorado free. The workflow automation engine gives you building blocks for handling submission management that go beyond what Google Forms and its add-on ecosystem can offer. See how it works.