Import Questions from CSV to Google Forms

You have 200 quiz questions sitting in a spreadsheet. You open Google Forms expecting to find an "Import CSV" button. You search the menus. Nothing. You Google it. Confusion.

Here's the reality that Google doesn't make obvious: Google Forms has no native CSV import feature for questions.

This limitation frustrates teachers building exams, HR teams creating surveys, and researchers assembling questionnaires. The "Import Questions" button you might have spotted in Google Forms? It only imports questions from other Google Forms in your account—not from CSV, Excel, or even Google Sheets directly.

The good news: there are three proven workarounds. This guide covers Apps Script automation (free, powerful), third-party add-ons (fast, easy), and manual workarounds (quick, limited). By the end, you'll have working code and clear steps to bulk import questions from CSV to Google Forms.

Why Google Forms Has No CSV Import

Here's the official word on this limitation:

"Currently you can import a CSV or XLS file into Google Sheets, but Forms does not support this. You may be able to find an add-on or 3rd party service that does this. The Import Questions feature in Forms only works to import questions used within other Forms in your account."

— MsJenniferS, Diamond Product Expert, Google Docs Editors Community, December 2023

So what does this mean for you? You can't drag-and-drop a CSV into Google Forms. The native "Import Questions" feature scans your other Google Forms—not external files. This architectural decision leaves users with hundreds of questions stuck between their spreadsheets and their forms.

This limitation shapes which solution makes sense for you:

• Have technical skills? Apps Script gives you complete control and costs nothing.
• Need it done in 5 minutes? Add-ons handle the complexity for you.
• Only have a few questions? Manual workarounds might work. Might.
• Building something for production? You'll probably outgrow all of these approaches eventually.

Solution 1: Google Apps Script (Free, Powerful)

Google Apps Script is JavaScript that runs inside Google's ecosystem. The Forms Service API lets you create forms, add questions, set correct answers, and configure quiz settings programmatically.

This is my recommended approach for most people. It's free, you own the code, and it handles any number of questions. The downside: expect to spend 15-20 minutes on setup, and you'll need to squint at some JavaScript.

Step 1: Prepare Your Spreadsheet

First, format your CSV data in Google Sheets with three columns:

Column format:

• Question: The question text (one question per row)
• Answers: Options separated by newlines (Alt+Enter in Sheets to add line breaks)
• Correct: Correct answer(s) separated by newlines (multiple for checkbox questions)

To import a CSV into Google Sheets: File → Import → Upload your CSV → Select "Replace current sheet."

Step 2: Open Apps Script Editor

1. In your Google Sheet, click Extensions → Apps Script
2. Delete any code in the editor
3. Paste the code below

Step 3: The Complete Working Code

This script reads questions from your spreadsheet and creates a Google Form quiz:

function createQuizFromSheet() {
  const formTitle = "Sample Quiz"; // Change this to your form title
  const sheetName = "Sheet1"; // Change this to your sheet name

  // Get data from spreadsheet
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(sheetName);
  const [, ...values] = sheet
    .getDataRange()
    .getDisplayValues()
    .filter((r) => r.join("") != "");

  // Parse questions: Column A = question, B = answers (newline-separated), C = correct answers
  const questions = values.map(([question, answers, correct]) => {
    const answerList = answers.split("\n").map(e => e.trim()).filter(String);
    const correctList = correct.split("\n").map(e => e.trim()).filter(String);
    return {
      question,
      answers: answerList,
      correct: correctList,
      point: 1,
      type: correctList.length == 1 ? "addMultipleChoiceItem" : "addCheckboxItem"
    };
  });

  // Create the form
  const form = FormApp.create(formTitle)
    .setIsQuiz(true)
    .setTitle(formTitle);

  // Add questions
  questions.forEach(({ question, answers, correct, point, type }) => {
    const item = form[type]();
    const choices = answers.map(answer =>
      item.createChoice(answer, correct.includes(answer))
    );
    item.setTitle(question).setPoints(point).setChoices(choices);
  });

  // Log the form URL
  Logger.log("Form created: " + form.getPublishedUrl());
  Logger.log("Edit URL: " + form.getEditUrl());
}

Source: Adapted from tanaikech's GitHub Gist

Step 4: Run the Script

1. Click the Run button (play icon)
2. First run: Google asks for permissions—click "Review permissions" → "Allow"
3. Check View → Logs to see your new form's URL
4. Open the URL to verify your questions imported correctly

What the Code Does

The script works in a few stages. First, SpreadsheetApp.getActiveSpreadsheet() grabs your data (that [, ...values] bit skips the header row—it's a JavaScript destructuring trick). Then each row becomes an object with the question text, options, and correct answers.

FormApp.create() builds the actual form. The setIsQuiz(true) part enables quiz mode so you can assign points.

For the questions themselves, the script picks between addMultipleChoiceItem() and addCheckboxItem() based on how many correct answers you specified. One correct answer means multiple choice. More than one means checkboxes.

Supported Question Types

The Forms Service API supports these question types:

Extended Script for Multiple Question Types

For forms with different question types, use this CSV format:

question,type,options,required,points,correct
"What is 2+2?",multiple_choice,"3,4,5,6",true,1,"4"
"Select all primes",checkbox,"2,3,4,5",true,2,"2,3,5"
"Your name",text,,true,0,
"Describe your experience",paragraph,,false,0,

And extend the script:

function createFormFromCSV() {
  const formTitle = "Mixed Question Form";
  const sheetName = "Sheet1";

  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(sheetName);
  const data = sheet.getDataRange().getValues();
  const headers = data.shift(); // Remove header row

  const form = FormApp.create(formTitle).setIsQuiz(true);

  data.forEach(row => {
    const [question, type, options, required, points, correct] = row;
    let item;

    switch(type) {
      case 'multiple_choice':
        item = form.addMultipleChoiceItem();
        const mcChoices = options.split(',').map(opt =>
          item.createChoice(opt.trim(), opt.trim() === correct.trim())
        );
        item.setChoices(mcChoices);
        break;

      case 'checkbox':
        item = form.addCheckboxItem();
        const correctAnswers = correct.split(',').map(c => c.trim());
        const cbChoices = options.split(',').map(opt =>
          item.createChoice(opt.trim(), correctAnswers.includes(opt.trim()))
        );
        item.setChoices(cbChoices);
        break;

      case 'text':
        item = form.addTextItem();
        break;

      case 'paragraph':
        item = form.addParagraphTextItem();
        break;

      case 'dropdown':
        item = form.addListItem();
        item.setChoiceValues(options.split(',').map(o => o.trim()));
        break;

      case 'scale':
        item = form.addScaleItem();
        item.setBounds(1, 5);
        break;
    }

    if (item) {
      item.setTitle(question);
      if (required === true || required === 'true') {
        item.setRequired(true);
      }
      if (points > 0 && item.setPoints) {
        item.setPoints(parseInt(points));
      }
    }
  });

  Logger.log("Form URL: " + form.getPublishedUrl());
}

Important: 2026 API Changes

According to Google Developers documentation:

"Forms created with the API after March 31, 2026 will have an unpublished state by default."

If you're running this script after March 2026, add this line to publish your form:

form.setPublished(true);

Solution 2: Third-Party Add-ons (Fast, Easy)

Not into code? Add-ons give you a visual interface for importing questions. They work, though most hit you with usage limits unless you pay.

Form Builder by Jivrus Technologies

The most popular option here. Over 10 million installs with a 4.6/5 rating from 6,185 reviews on the Google Workspace Marketplace. That's a lot of teachers and HR folks who needed this functionality.

Features:

• Import from Sheets, Docs, Slides, PDFs, and images
• AI-powered question detection (works with ChatGPT, Gemini, Claude, Mistral)
• Preview questions before committing
• Shuffle and randomize both questions and answers
• Quiz point values and correct answer marking

How to use:

1. Install from the Workspace Marketplace
2. Open your Google Form
3. Click the puzzle icon → Form Builder → Import from Sheets
4. Select your spreadsheet and sheet
5. Map columns to question fields
6. Preview and import

Pricing: Free tier exists but it's pretty limited. You'll probably bump into the quota within a few sessions if you're doing anything substantial. Paid plans available for heavier usage.

Form Builder for Google Sheets

This one has 1 million+ installs and a 4.4/5 rating. Available on the Workspace Marketplace. The main difference: it launches from Sheets rather than Forms.

Features:

• Launches from Sheets instead of Forms
• Automatic data mapping
• Batch change question types
• Preview before importing

Best for: People who live in Sheets anyway. If you're already staring at your spreadsheet, this saves you the context switch.

AI Form Builder by Jotform

Jotform's solution opens as a sidebar inside Google Forms and uses AI to recognize question patterns in your documents.

Features:

• Import from Docs, Sheets, Slides, and Drive
• AI reads content and identifies questions automatically
• Export to Google Forms or Jotform

Best for: People with messy documents. If your questions are buried in a Word doc that someone emailed you, the AI parsing might save you some formatting headaches.

Add-on Comparison

Solution 3: Manual Workarounds

For small imports or one-off situations, you can get away with manual approaches. I wouldn't recommend these for anything over 20 questions, but they exist.

Copy-Paste from Google Docs

Google Forms has an undocumented feature that attempts to parse formatted text:

1. Format questions in Google Docs as a numbered list with lettered options:

   1. What is 2+2?
   a) 3
   b) 4
   c) 5
   

2. Copy the text
3. Create a new Google Form
4. Paste into the first question field
5. Forms attempts to parse the structure

Honestly? This works about half the time. Forms gets confused by formatting more often than you'd expect. I've seen it merge two questions together, ignore options, and create multiple choice when it should be checkboxes. Only use this for dead-simple questions where you can afford to fix mistakes manually.

Duplicate and Edit Existing Forms

If you have a similar form already:

1. Open the existing form
2. Click the three-dot menu → Make a copy
3. Edit individual questions

Best for: Variations of existing quizzes or surveys where most questions stay the same.

Tips That'll Save You Debugging Time

Format Your CSV Correctly

This sounds obvious but it trips people up constantly. Use consistent delimiters—commas for options, newlines for multi-select answers. Escape quotes within questions with double quotes: "What is a ""string""?". And avoid special characters if you can (smart quotes from Word are notorious troublemakers).

The biggest tip: test with 5-10 questions before importing hundreds. Nothing worse than running a script on 200 questions and finding out your CSV was malformed at row 12.

Actually Check Your Work

After importing, preview the form as a respondent. Click through every question. Make sure the correct answers are actually marked (quiz mode has bitten me here—it looks right in the editor but the points weren't assigned). Verify required fields are set. Takes five minutes and catches embarrassing mistakes.

Common Issues

If questions are missing, check for empty rows in your CSV. Wrong question type usually means your type column doesn't match the supported values exactly (it's case-sensitive). Answers not showing? Probably empty strings sneaking in. Points not assigned typically means quiz mode got disabled somewhere along the way.

When Google Forms Isn't Enough

Google Forms handles simple surveys and quizzes fine. Where it falls apart: building a product where your users need to upload CSV data. Forms wasn't designed for that use case, and you'll fight the architecture the whole way.

If you're building data collection into an application (not just using Forms yourself), ImportCSV provides embeddable CSV import with validation and error handling. Different tool for a different problem.

Summary

Google Forms has no native CSV import. That's just how it is. Your options:

Apps Script is what I'd recommend for most people. It's free, you control it completely, and 15-20 minutes of setup pays off if you're importing more than a handful of questions. Copy the code above, format your spreadsheet to match, run it.

Add-ons work if you don't want to touch code. Form Builder has 10M+ installs, which means it's battle-tested. Just watch those usage limits on the free tier.

Manual workarounds are last resort territory. Fine for 10 questions. Painful for 100.

Pick based on how many questions you have and whether you'll need to do this again. One-time import of 15 questions? Manual might be fine. Regular quiz building for a semester's worth of classes? Spend the 20 minutes learning Apps Script. You'll thank yourself by week three.