How to scrape a website to Google Sheets (free, no code)

You have a web page full of the exact data you need (a product list, a directory, search results, a table) and you want it in Google Sheets: sortable, filterable, shareable with your team. Copying it cell by cell is painful, and most “website to Sheets” tutorials point you at a paid add-on or a fragile =IMPORTHTML() formula that breaks the moment a site uses JavaScript. There is a faster, free way, and it helps to see all the options side by side before you pick one.

This guide compares every real route from a web page to a Google Sheet, then walks through the fastest one: scraping the page with the free Grabby web scraper Chrome extension and dropping the result straight into Sheets, no code and no add-on required.

Every way to get web data into Google Sheets

There is no single “best” method. It depends on the page and how often you need fresh numbers. Here is what each option actually handles:

For a plain static table on a simple page, IMPORTHTML is genuinely the quickest option and worth trying first. The moment the site uses JavaScript, sits behind a login, paginates results or loads more items as you scroll — which covers most stores, directories, maps and dashboards today — it returns a blank cell or a #N/A error, and a scrape-then-import workflow is the reliable fallback.

The Grabby workflow: from any page to a Google Sheet

Here is the whole process, start to finish.

• Install the free extension. Add Grabby from the Chrome Web Store. No account, no API key, and everything in this guide is on the free plan.
• Open the page with your data. A store category, a Google Maps search, a directory, a table of stats — anything with a repeating list. Scroll once so the first screen has loaded.
• Select the list. Click the Grabby icon, choose Scrape List, click Select the list, then click any one item. Grabby highlights the whole repeating set and one click captures it all — no CSS selectors, no XPath — and figures out the columns for you.
• Grab every page, if there is more than one. Choose Pagination for a “Next” button, Auto-scroll for an infinite feed, or Load more for a “show more” button. Set a sensible limit and hit Start.
• Clean it up. Results land in an editable data table. Remove empty or duplicate rows, rename columns, and drop anything you don’t need, so what lands in Sheets is already tidy.

Into Sheets, two ways

• Copy & paste (fastest). In Grabby’s data table, choose Export → Copy, open a new Google Sheet, click cell A1 and paste. The columns land in the right cells, ready to sort and filter.
• CSV import. Choose Export → CSV, then in Google Sheets go to File → Import, upload the file, and pick an import location: Create new spreadsheet, Insert new sheet, Replace current sheet, or Append to current sheet if you’re adding to an existing pull. Good when you want a repeatable, shareable file rather than a clipboard paste.

That’s it: web data in a shareable Google Sheet you can sort, filter and build on. Because Grabby runs locally, nothing is uploaded to a server. The data goes from your browser straight into your own sheet.

Because the sheet is a normal Google Sheet, everything you already know still applies: share it with your team, set view or edit permissions, wrap the range in a Table or named range, or build a chart or pivot table straight off it. There’s nothing scraper-specific about the sheet itself once the data lands. It behaves exactly like a sheet you typed by hand, just without the typing.

Google Sheets web scraping with JavaScript (Apps Script)

If you want to stay inside Google Sheets and you are comfortable with JavaScript, Google Apps Script can fetch a page and write it to a sheet. Apps Script runs on Google’s servers and has UrlFetchApp for HTTP requests and SpreadsheetApp for the sheet, but it has no DOM parser, so you read the HTML as plain text. The example below pulls the first <table> on a page into the active sheet using regular expressions.

In your sheet, open Extensions → Apps Script, paste this in, change the URL, and run importTable:

// Pulls the first <table> from a page into the active sheet.
// Works only on tables that are already in the HTML the server sends.
function importTable() {
  const url = 'https://example.com/page-with-a-table'; // change this
  const response = UrlFetchApp.fetch(url, { muteHttpExceptions: true });
  if (response.getResponseCode() !== 200) {
    throw new Error('Request failed with HTTP ' + response.getResponseCode());
  }
  const html = response.getContentText();

  // 1. Find the first table.
  const tables = html.match(/<table[\s>][\s\S]*?<\/table>/gi) || [];
  if (tables.length === 0) {
    throw new Error('No <table> in the HTML. The page may build it with JavaScript.');
  }

  // 2. Split it into rows, then cells, and strip the tags.
  const rows = (tables[0].match(/<tr[\s>][\s\S]*?<\/tr>/gi) || []).map(function (row) {
    return (row.match(/<t[dh][\s>][\s\S]*?<\/t[dh]>/gi) || []).map(cleanCell);
  });

  // 3. setValues needs a rectangle, so pad short rows.
  const width = Math.max.apply(null, rows.map(function (r) { return r.length; }));
  const data = rows.map(function (r) {
    while (r.length < width) r.push('');
    return r;
  });

  // 4. Write to the sheet.
  const sheet = SpreadsheetApp.getActiveSheet();
  sheet.clearContents();
  sheet.getRange(1, 1, data.length, width).setValues(data);
}

function cleanCell(cellHtml) {
  return cellHtml
    .replace(/<[^>]*>/g, '')
    .replace(/&nbsp;/g, ' ')
    .replace(/&amp;/g, '&')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&quot;/g, '"')
    .replace(/&#39;/g, "'")
    .replace(/\s+/g, ' ')
    .trim();
}

The first run asks you to authorize the script, because UrlFetchApp needs the https://www.googleapis.com/auth/script.external_request permission. Apps Script requests it automatically unless you have set explicit scopes in the manifest, in which case add it there. To refresh the data, run the function again, or add a time-driven trigger in the Apps Script editor.

Where this approach breaks

• No JavaScript rendering. UrlFetchApp returns the HTML the server sends, like IMPORTHTML. A table that a page builds after loading is not in that response, so the script throws the “No table” error above. The workaround is to find the JSON endpoint the page itself calls (in your browser’s developer tools, Network tab) and fetch that with JSON.parse(response.getContentText()), which is cleaner than parsing HTML when it exists.
• Regex parsing is fragile. It does not understand nested tables, comments or unusual markup, and it ignores colspan and rowspan, so merged cells shift your columns. A small change to the site’s HTML can break it silently. Apps Script’s XmlService can parse real XML, but most web pages are not well-formed enough for it, so it fails on ordinary HTML.
• Blocks and logins. The request comes from Google’s servers, not your browser, so sites that block cloud IP addresses, show a CAPTCHA, or need you to be signed in return an error page or nothing useful. Check the site’s terms before scripting against it.
• Pagination is yours to write. One fetch is one URL. For a multi-page table you loop over page URLs yourself.
• Quotas. Per Google’s Apps Script quotas, at the time of writing (October 2026), URL Fetch is limited to 20,000 calls a day on a consumer account and 100,000 on Google Workspace, and one execution can run for at most 6 minutes.

If the page needs JavaScript, a login, or pagination, or you simply do not want to maintain a script, the no-code route above covers those cases: Grabby reads the page as your browser has already rendered it, so the table is there to select, and you paste the result into Sheets.

Keep it fresh: snapshot vs. live formula

It’s worth being clear-eyed about what “live” means here, because the two approaches behave very differently:

• IMPORTHTML/IMPORTXML is genuinely live. Sheets re-fetches the page periodically and the cells update on their own. That’s a real advantage, but only on the narrow set of static, public, JavaScript-free pages the formula can read, and it can silently break the moment the site changes its markup.
• A Grabby export is a snapshot. It’s accurate at the moment you scrape it, and you decide when to refresh by re-running it and pasting over the old range. For price tracking, lead lists, competitor research and most reporting, a controlled snapshot is usually preferable anyway. You don’t want a dashboard number changing mid-meeting.

A practical middle ground: keep each pull on its own dated tab so you have a history to compare, or overwrite a single “current” tab and log the pull date in a cell next to it. Either way, re-running a saved scrape takes a couple of clicks, so “refresh weekly” is realistic without any scheduling tool.

Cleaning tips once the data is in Sheets

• Keep the header row. Grabby’s column names become your sheet headers, so rename them in the data table first and Sheets is labelled correctly from the first paste.
• Numbers and prices as text. If a price or count column imports as text (left-aligned, ignored by SUM), select it and use Format → Number, or add a helper column with =VALUE().
• Dates as text. Wrap them in =DATEVALUE(), or use Data → Split text to columns if a date and time are stuck together.
• Stray whitespace. A quick =TRIM() column catches the invisible spaces that sneak in from scraped text and quietly break exact-match lookups.
• Refresh later. To update the sheet, re-run the scrape and paste over the range, or keep each pull on its own tab for a history you can compare.

What people use this for

• Price and competitor tracking. Pull a category or pricing page into a sheet, then re-run it weekly and drop the new numbers into the next column so you can watch how prices move over time.
• Lead lists and directories. Turn a business directory, association listing, or Google Maps search into a contact sheet you can hand straight to sales or outreach.
• Content and SEO audits. Collect titles, headers, word counts or metadata across a set of pages into one sheet instead of opening each URL by hand.
• Listings research. Real estate, job boards, or marketplaces: pull listings into Sheets so you can filter and sort by price, location, or date rather than scrolling a site.
• Quick research and journalism. Get a table of figures into a sheet you can chart, cross-reference, or share with an editor, without waiting on a developer to build something custom.

Troubleshooting: why IMPORTHTML or IMPORTXML come back blank

If you’ve tried the formula route first and gotten a blank cell or a #N/A error, it’s almost always one of these, and the fix is usually to scrape the page instead rather than debug the formula:

• The content is added by JavaScript after the page loads. IMPORTHTML only sees the raw HTML the server sends first, not what scripts render afterward, which is how most stores, dashboards and search results build their pages.
• The page needs a login. Sheets fetches the URL anonymously, so anything behind authentication comes back empty.
• You pointed it at the wrong table index. A page can have several <table> elements, and IMPORTHTML numbers them in source order, which doesn’t always match what you see visually.
• You hit the refresh rate limit. Sheets throttles how often import formulas re-fetch a given URL, so hammering refresh can return a stale or empty result for a while.

Frequently asked questions

Is it really free? Yes. Grabby is free while in early access, and Google Sheets is free too, so nothing here needs a paid add-on.

Do I need a Sheets add-on? No. Copy-paste or a CSV import is all it takes, with nothing to install inside Sheets.

Why not just use IMPORTHTML or IMPORTXML? They only read simple static tables and lists on public pages, and break on JavaScript, logins, pagination and infinite scroll, which is most modern sites. Grabby reads the page you see, so it works where the formulas can’t.

Will the sheet auto-update? A pasted or imported sheet is a snapshot. IMPORTHTML/IMPORTXML are the only truly live option, and only on the pages they support. Otherwise, re-run the scrape and paste again to refresh.

Does it work on pages behind a login? Yes. Grabby reads what you see in your own browser session, logged in or not.

What about Apps Script? It works, but you’re writing and maintaining code, and it still only sees raw server HTML by default, not JavaScript-rendered content.

Can I scrape a website into Google Sheets with JavaScript? Yes, with Google Apps Script. UrlFetchApp.fetch(url) downloads the page, you parse the HTML as text (there is no DOM parser) or parse a JSON endpoint with JSON.parse, and sheet.getRange(...).setValues(...) writes it into the sheet. It only sees the HTML the server sends, not content built by JavaScript, and it is subject to Apps Script quotas. See the example script in this guide.

How do I fix numbers or dates that import as text? Use Sheets’ Format → Number, or =VALUE() / =DATEVALUE() helper columns.

Can I pull a paginated or infinite-scroll list into one sheet? Yes. Set Pagination, Auto-scroll, or Load more before you start, and every page lands in one table.

Scrape a specific site into Sheets

The same flow works everywhere. For worked examples and the underlying export options, see our guides to scraping any website to Excel and scraping a table from any website, then copy the result straight into Google Sheets, or use File → Import with the CSV export.