# Google Form Bulk Submitter: Inspect & Submit

The Google Form Bulk Submitter does two things with any public Google Form: inspect mode returns the question schema with entry IDs, labels, types, options and required flags, and submit mode validates your JSON or CSV rows and posts each one to the form's own formResponse endpoint. Successful submissions cost $0.02 each and each inspected form costs $0.01, with failures free. No login or browser is involved. Run it from Apify Console or the API.

## Key facts

- Price: from $0.02 per response submitted, $20.00 per 1,000
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients
- Version: Updated Nov 2026, build 0.1.9
- Usage: 92.0% successful runs (30 days)
- Actor: subimpact/google-form-bulk-submit

## Who it is for

- Operations teams migrating existing responses into a Google Form
- Developers seeding test data for a form they own
- Event and community organisers loading registrations from a spreadsheet
- QA engineers load-testing a form before a campaign

## Use cases

### Discover entry IDs before submitting

Run inspect mode with formUrl set to your viewform or forms.gle link. The row returns fields[] with entryId, label, typeName, required, options and hasOther, plus fieldCount and whether the form collects email or accepts file uploads. Those labels become the exact keys of your responses objects, which removes the usual guesswork about entry.123456789 ids.

### Load a spreadsheet of registrations

Paste the sheet as responsesCsv: the first row holds question labels, one response per following row, and quoted cells may contain commas or newlines. Checkbox answers go in one quoted cell separated by commas. Set maxSubmissions to cap the batch and delayMs to space the posts. Each row returns status submitted or failed with a readable error.

### Validate values against real options

For dropdown, multiple choice and checkbox questions the actor checks each value against the option list from the form. A value that is not listed is sent through the question's Other box when one exists, otherwise the row fails and the error names the valid options. That keeps a bulk import from silently writing wrong answers.

### Migrate off another form tool

Export the old tool's answers to JSON, map its columns to the Google Form labels, and submit in batches of up to 500 rows per run. The summary row reports total, submitted, failed and skipped counts, so a migration can be re-run for the failed subset only. Rows counted as skipped matched no question at all.

### Seed test data before a launch

Point submit mode at your own form with a few rows and a short delayMs, then confirm the responses appear in the linked sheet. Because failures are free and each row reports attempts, a test batch costs only the responses that land. Raise delayMs if Google answers 429, since fast repeated posts look like abuse.

## Price events

- Response submitted (`submit`): $0.02, lowest tier $0.02. Per response successfully submitted to the form.
- Run started (`actor-start`): $0.00005, lowest tier $0.00005. One charge per run.
- Form inspected (`inspect`): $0.01, lowest tier $0.01. Per form successfully inspected for field schema.

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

The candidate list holds no other Google Forms actor: it lists page speed, indexing, image and lead tools plus generic HTTP request senders. Nothing here inspects form fields and submits responses, so there is no fair comparison to draw.

## Input

- `mode` (string, optional): inspect = read the form and return its field schema (labels, types, entry IDs, options). submit = validate and POST your bulk responses to the form.
- `formUrl` (string, required): Public Google Form link. Supported: https://docs.google.com/forms/d/e/1FAIpQLS.../viewform, https://docs.google.com/forms/d/{id}/viewform, or a https://forms.gle/XXXX short link. Accepts docs.google.com/forms/... and forms.gle/... links
- `responses` (array, optional): Submit mode. Array of objects, one per response. Each key is a question label from the form (exact match preferred, case-insensitive and partial matches are accepted) or an entry ID such as "entry.123456789". Values are strings; use an a...
- `responsesCsv` (string, optional): Submit mode alternative to the JSON array. First row = question labels, one response per following row. Quoted fields may contain commas and newlines. Ignored when "responses" is set.
- `email` (string, optional): Only used when the form collects an email address in its built-in emailAddress field. A per-row "email" column overrides this value.
- `maxSubmissions` (integer, optional): Maximum number of response rows to submit in one run. Extra rows are ignored. 1,000 rows cannot finish inside the default one-hour run timeout, so the ceiling is 500.
- `delayMs` (integer, optional): Pause between submissions and between retry attempts. Lower values risk rate limiting by Google.
- `proxyCountry` (string, optional): Country for Apify proxy sessions. Applied as the countryCode of the resolved Apify proxy (residential, or datacenter fallbacks).
- `proxyUrls` (array, optional): Optional. Your own proxy URLs (e.g. http://user:pass@host:port). When set, these are used instead of Apify Proxy.

### Example input

```json
{
  "mode": "inspect",
  "formUrl": "https://docs.google.com/forms/d/e/1FAIpQLSeNmLLIzBuJBDgwJYe4591u6pIYu1N1bJU9raVTQJpVVMQZsw/viewform",
  "maxSubmissions": 100,
  "delayMs": 3000
}
```

## Output fields

- `kind` (string/null): inspect / submission / summary
- `mode` (string/null): inspect / summary marker on non-submission rows
- `formId` (string/null): Google Form ID taken from the form URL
- `formTitle` (string/null): Title of the Google Form
- `formUrl` (string/null): Resolved viewform URL (inspect rows)
- `action` (string/null): formResponse URL used for submissions
- `fbzxPresent` (boolean/null): Whether the anti-CSRF token was found
- `emailAddressPresent` (boolean/null): Whether the form has a built-in emailAddress field
- `fileUpload` (boolean/null): True when the form contains a file-upload question
- `fieldCount` (integer/null): Number of discovered questions (inspect rows)
- `fields` (array/object/null): Discovered field schema (inspect) or submitted label/value pairs (submission)
- `index` (integer/null): Zero-based index of the response row
- `status` (string/null): submitted / failed / skipped
- `error` (string/null): Validation or submission error, null when successful
- `warnings` (array/null): Non-fatal notes about label matching or skipped values
- `attempts` (integer/null): Number of HTTP attempts made for this row
- `total` (integer/null): Number of response rows processed (summary row)
- `submitted` (integer/null): Number of responses successfully submitted (summary row)
- `failed` (integer/null): Number of failed responses (summary row)
- `skipped` (integer/null): Number of skipped responses (summary row)
- `timestamp` (string/null): ISO timestamp of the row

## How to run it

1. Set mode to inspect and paste your form link into formUrl, for example https://docs.google.com/forms/d/e/1FAIpQLS.../viewform. forms.gle short links are followed.
2. Run once and read the inspect row: fields[] lists each label, entryId, type and the allowed options.
3. Switch mode to submit and add a responses array keyed by those labels, or paste a responsesCsv block whose header row holds the labels.
4. Set maxSubmissions, for example 100, and delayMs, for example 3000, then run the actor.
5. Read the per-row submission results and the closing summary row in the dataset, then export as JSON, CSV or Excel.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~google-form-bulk-submit/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"inspect","formUrl":"https://docs.google.com/forms/d/e/1FAIpQLSeNmLLIzBuJBDgwJYe4591u6pIYu1N1bJU9raVTQJpVVMQZsw/viewform","maxSubmissions":100,"delayMs":3000}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/google-form-bulk-submit").call(run_input={
      "mode": "inspect",
      "formUrl": "https://docs.google.com/forms/d/e/1FAIpQLSeNmLLIzBuJBDgwJYe4591u6pIYu1N1bJU9raVTQJpVVMQZsw/viewform",
      "maxSubmissions": 100,
      "delayMs": 3000
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/google-form-bulk-submit').call({
  "mode": "inspect",
  "formUrl": "https://docs.google.com/forms/d/e/1FAIpQLSeNmLLIzBuJBDgwJYe4591u6pIYu1N1bJU9raVTQJpVVMQZsw/viewform",
  "maxSubmissions": 100,
  "delayMs": 3000
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/google-form-bulk-submit
Input JSON: paste the example input below.

## Limits

- Public forms only, since forms behind a Google sign-in cannot be read or submitted.
- File-upload questions are skipped and the rest of the row is still submitted.
- Multi-page forms with conditional branching are posted as one request, not walked page by page.
- At most 500 responses per run, and delayMs below 500 ms is not accepted.

## FAQ

### What does a bulk submission cost?

Each successfully submitted response costs $0.02, and each form inspected costs $0.01. Failed and rejected rows are free, so a run only pays for responses that actually landed. Apify platform usage is billed separately by Apify, on top of these event prices.

### Does it work with forms that require a Google sign-in?

No. Only public forms can be read or submitted. Forms behind a sign-in wall, and file-upload questions, are out of scope by design: the actor reports fileUpload true and submits the remaining answers in the row rather than trying to bypass the restriction.

### How many responses can one run handle?

maxSubmissions defaults to 100 and is capped at 500, because 1,000 rows cannot finish inside the default one-hour run timeout. Extra rows are ignored. For larger imports, split the data across runs and track progress with the summary row.

### How do I know which key to use for each question?

Run inspect mode first. It returns every question's label and entryId. You can key your responses by the label as written, which is matched exactly, then case-insensitively, then partially, or by entry.<id> if you prefer the raw Google identifier.

### What happens when a row has an invalid answer?

It fails on its own with an error naming the problem, for example that a value is not in the question's option list, and the run continues with the next row. Warnings record non-fatal notes such as partial label matches, and attempts shows how many HTTP tries the row needed.

### Can it use my own proxies?

Yes. Set proxyUrls to your own proxy URLs and they replace Apify Proxy entirely. Otherwise the actor uses Apify Proxy with proxyCountry applied, for example US, GB, DE, SG or MY, trying residential sessions before datacenter pools.

### Is it acceptable to submit to any form I find?

No. Use it only on forms you own or have explicit permission to automate, such as your own data collection, a migration or a test seeding job. The actor does not solve CAPTCHAs, does not log in and does not attempt to defeat access controls a form owner has set.

## Links

- Page: https://subimpact.net/apis/google-form-bulk-submit/
- Category: https://subimpact.net/apis/category/ai-developer/
- Run on Apify: https://apify.com/subimpact/google-form-bulk-submit
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
