How to Create a Google Form With ChatGPT Using TinyFish

ChatGPT can write the questions for a Google Form, but that usually leaves you with the manual part: opening Google Forms, adding every field, choosing question types, entering answer options, and configuring the settings yourself.

With TinyFish, the task can continue into the browser. You describe the form you want in ChatGPT, sign in to Google through a secure TinyFish browser profile, and TinyFish works through the Google Forms interface to build it.

In this tutorial, we’ll create a workshop registration form with short-answer, multiple-choice, and checkbox questions, then review the finished form before publishing it.

What you need before you start

Before creating the form, make sure you have:

• A ChatGPT account with access to plugins
• The TinyFish plugin connected in ChatGPT
• A Google account that can create Google Forms

You’ll also need to sign in to Google the first time TinyFish tries to access Google Forms. ChatGPT handles the instructions and form structure. TinyFish provides the web agent⁠ capabilities needed to carry those instructions into Google Forms.

Install TinyFish in ChatGPT

Open the plugin directory in ChatGPT and search for TinyFish. Connect it to your account, then start a new conversation and select TinyFish for the task.

Once connected, TinyFish will be available when you need ChatGPT to work inside a live website. In this tutorial, we’ll use it to open Google Forms, build the form, and apply the settings from our prompts.

If you’re new to plugins, our guide to the best ChatGPT plugins explains how they work and where TinyFish fits.

How to create a Google Form with ChatGPT

We’ll build the form in stages so you can see exactly what ChatGPT asks TinyFish to do and review the result as it develops.

The example will be a registration form called Developer Workshop Registration.

1. Ask ChatGPT to create a new Google Form

Start with a simple instruction:

Create a new Google Form for a developer workshop registration. Open Google Forms and start a blank form. Do not publish or share it yet.

TinyFish will attempt to open Google Forms.

If this is your first authenticated Google Forms task, TinyFish may stop and ask you to sign in before it can continue.

2. Sign in to Google when prompted

Google Forms requires an authenticated Google account. If TinyFish reaches Google Forms without an active Google session, it will pause the task and show the Google sign-in page.

Sign in to the Google account that should own the form. Once the session is authenticated, TinyFish can continue working in Google Forms and resume the form-building task.

If you have already signed in to Google through a saved TinyFish browser profile, TinyFish can reuse that authenticated session and continue without asking you to log in again.

3. Add the title and description

Now give ChatGPT the exact title and description you want. Title the form “Developer Workshop Registration.”

Add this description:

Register for the upcoming developer workshop. We will use your responses to plan seating and session content.

TinyFish enters the title and description into the Google Forms editor.

Providing the copy exactly is useful when you already know how the form should be worded. For more exploratory tasks, you can also ask ChatGPT to draft the description first and then use the approved version in the form.

4. Add a required short-answer question

Next, add the first attendee field.

1. Add a short-answer question called “Full name.”
2. Make it required.

TinyFish adds the question, changes the field to short answer if needed, and enables the required setting.

This is a useful pattern for fields such as names, company names, job titles, or other short text responses.

5. Add a multiple-choice question

Now add a question where respondents should choose one option.

Add a required multiple-choice question called:

Which session do you want to attend?

Use these options:

• API design
• Web agents
• Testing and observability

The important part of this prompt is that it specifies both the field type and the exact options. TinyFish can then create the question without having to infer whether respondents should select one answer or several.

6. Add a checkbox question

For the next question, respondents should be able to choose more than one answer.

Ask TinyFish to add a required checkbox question called:

Which topics should the workshop cover?

Add these options:

- Authentication
- Structured extraction
- Form workflows
- Error recovery

Checkboxes are useful when several answers can apply to the same respondent.

Being explicit about this matters. A multiple-choice question would limit the respondent to one option, while checkboxes allow several.

7. Configure the form settings

Once the questions are in place, you can ask TinyFish to configure form-level settings separately.

For example:

• Configure the form to collect email addresses.
• Keep quiz mode disabled.
• Allow respondents to edit their responses after submission.

Set the confirmation message to:

- Your registration has been recorded.
- Do not publish the form yet.

Keeping this separate from the question-building prompts makes it easier to review each part of the setup and catch anything that needs changing. After TinyFish finishes, open the form settings yourself and confirm that each requested option matches the prompt.

Want to create your own Google Form from ChatGPT?
Open the TinyFish plugin in ChatGPT, describe the form you want to create, and let TinyFish build the draft in Google Forms for you to review.

8. Ask ChatGPT to review the completed form

Before publishing, ask ChatGPT to verify the current structure:

• Review the Google Form you just created.
• Confirm the question order, field type, answer options, required status, and form-level settings.
• Do not publish or share the form.
• Tell me if anything does not match the instructions I gave you.

It should also collect email addresses, keep quiz mode disabled, allow response editing, and display the requested confirmation message.

The summary is useful, but it should not replace checking the form itself. Always inspect the actual Google Forms editor before publishing.

Preview and test the form

Once the structure looks correct, open the form in Preview mode and review it as a respondent would. Because the form has not been published yet, you won’t submit a response at this stage.

Check that:

• Required fields are marked correctly
• Multiple-choice questions allow only one answer
• Checkbox questions allow several answers
• The wording is clear outside the editor

Testing the respondent experience catches problems that are easy to miss while working in the form builder.

If something needs changing, return to ChatGPT and describe the edit.

For example:

Edit the Google Form you just created.

Change the session question to:

- Which workshop session would you most like to attend?
- Keep the same answer options and required settings.
- Do not change anything else.
- TinyFish can return to the existing form and apply the requested change through the browser interface.

Publish the Google Form

Once you have reviewed and tested the form, you can publish it.

You can either complete this step directly in Google Forms or ask TinyFish to handle the browser interaction after you have approved the final draft.

For example:

• The form is approved.
• Publish it without changing any questions or settings, then return the respondent link.

For an important form, it is worth opening the returned link yourself and checking it one final time before distributing it. Submit one test response before sharing the form more widely. Confirm that the required fields behave correctly, the response submits successfully, and the custom confirmation message appears as expected.

The goal is not to remove human review from the workflow. It is to remove the repetitive browser setup between deciding what the form should contain and having a finished form ready to use.

Writing better prompts for Google Forms

You do not need a long prompt to create a useful form, but the instructions should make the important decisions clear.

Tell ChatGPT what the form is for

Instead of:

• Create a form with five questions.

Give it context:

• Create a registration form for a developer workshop. We need attendee details and session preferences so we can plan seating and content.

The purpose helps ChatGPT understand how the fields fit together.

Specify field types when they matter

• If a respondent should choose only one option, ask for multiple choice.
• If several answers can apply, ask for checkboxes.
• If you need a longer written response, specify a paragraph field rather than leaving the format ambiguous.

Include exact answer options

If the wording matters, give ChatGPT the final options instead of asking it to invent them.

For example:

• Use these options:
• API design
• Web agents
• Testing and observability

This is especially useful when form responses will later be analyzed or sent into another system.

State which fields are required

• Do not leave important validation choices implicit.
• Instead of asking TinyFish to “add a name field,” say:
• Add a short-answer question called “Full name” and make it required.

Separate building from publishing

When creating a new form, ask TinyFish not to publish or share it until you have reviewed the result.

That gives you a clear checkpoint between browser execution and an external action.

A complete Google Form prompt

Once you understand the workflow, you can combine the same instructions into a single prompt.

Create a new Google Form in my connected Google account.
Use the title “Developer Workshop Registration.”
Use the description:
“Register for the upcoming developer workshop. We will use your responses to plan seating and session content.”
Add these questions in the listed order.
1. “Full name”
Use a short-answer field.
Make it required.
2. “Which session do you want to attend?”
Use a multiple-choice field.
Add these options:
API design
Web agents
Testing and observability
Make it required.
3. “Which topics should the workshop cover?”
Use checkboxes so respondents can select multiple answers.
Add these options:
Authentication
Structured extraction
Form workflows
Error recovery
Make it required.
Configure the form to collect email addresses.
Keep quiz mode disabled.
Allow respondents to edit their responses after submission.
Set the confirmation message to:
“Your registration has been recorded.”
Do not publish or share the form yet.
When the draft is complete, summarize every question, field type, option, required setting, and form-level setting.

A single prompt is convenient when you already know exactly what you want. For a first run, though, building the form in smaller stages makes it easier to see what TinyFish is doing and review each change before moving on.

ChatGPT drafts the task. TinyFish carries it into the browser.

Creating the questions is only one part of making a Google Form. ChatGPT can help structure the form, decide which information to collect, rewrite questions, and turn a rough requirement into clear instructions.

TinyFish handles the part that happens on the website: opening Google Forms through an authenticated browser session, entering the content, selecting field types, changing settings, and applying edits. That removes the usual handoff where ChatGPT gives you a form specification and you then recreate the entire thing manually in another tab.

The same pattern applies to other AI agent use cases⁠ where the task requires navigating live websites, entering information, or completing a multi-step workflow. TinyFish gives the conversation a way to continue into the web instead of stopping at instructions.

Create the form without rebuilding it by hand

ChatGPT can help you shape the form, but the bigger gain is carrying that work through to a finished draft.

With TinyFish, the workflow does not stop at a list of suggested questions. It can move into Google Forms, add the fields, apply the settings, and leave you with a form that is ready to review in your own account.

You still decide what gets published. Review the draft, make any final adjustments, then share it when you are ready. The useful part is simple: you get the same Google Form, without rebuilding the structure manually.