Amazon Spreadsheet: Free Auto-Filling Template + CSV Method (2026)

Build an Amazon spreadsheet that fills itself: a free Google Sheets template plus a 30-line Python CSV script. Live prices, no SP-API approval needed.

“I can pay to automate it. I just don’t know how. I can create or write a program maybe with AI to pull API and put into Google sheets maybe or a csv.”

That’s a real seller on r/FulfillmentByAmazon , asking for an Amazon spreadsheet that fills itself. The replies he got: a custom FTP pipeline that took two programmers three months to build, a BigQuery setup, and a couple of paid subscriptions.

Nobody in that thread mentioned the simplest version. A self-filling product sheet is just an API feeding a spreadsheet on a schedule, and with the FlyByAPIs Amazon Product Data API that pattern takes about 15 minutes to wire up yourself, free, with one script.

TL;DR: One Apps Script pasted into a blank Google Sheet turns it into a self-refreshing feed of live Amazon prices, ratings, and rankings in about 15 minutes. The data comes from the FlyByAPIs Amazon Product Data API, whose free tier includes 100 requests per month, no credit card and no SP-API approval. A daily trigger keeps the sheet updating on its own.

15 min

Blank sheet to live data

100

Free API requests/month

22

Amazon marketplaces

0

Approval forms to fill

At FlyByAPIs we run the Amazon Product Data API this tutorial is built on, and we check every endpoint daily because Amazon changes its pages constantly. So I can show you exactly what works right now, in two flavors.

Part 1 is a free Google Sheets template: paste one script, run it, and the sheet builds itself and fills with live product data. No code knowledge needed.

Part 2 is a 30-line Python script that writes a clean CSV, for the developers. Pick your side.

Both scripts are ready to copy from the FlyByAPIs code repo on GitHub , or straight from the code blocks below.

Which Amazon data can actually land in a spreadsheet?

Here’s the thing nobody explains upfront. “Amazon data” means two completely different things, and each needs its own tool. Half the frustrated Reddit threads exist because someone tried the wrong tool for their data type.

Your own account data

Your sales, orders, inventory, settlements. Lives behind your login. Comes from Seller Central reports (manual download) or Amazon's SP-API, which needs a developer application that sellers report takes weeks and can get rejected. Tools like Sellerboard and Gorilla ROI sell this as a service.

Public market data

Prices, ratings, review counts, search rankings, Best Seller badges. Anyone's products, including competitors. No approval process: a product data API for Amazon gives you this with a key you create in 2 minutes. This is what this guide automates.

On r/AmazonFBATips , one seller described waiting over a month for SP-API approval and still getting rejected for not having a website with “app features”. For competitor prices in a spreadsheet, that entire process is unnecessary. Public market data never required it.

If you want your own orders exported, I cover that in its own section near the end. Everything from here on is about market data: the stuff you use for tracking Amazon prices , spying on competitors, and deciding what to sell next.

Bottom line:

Own sales data: Seller Central reports or SP-API (slow, approval needed). Competitor and market data: a public API, no approval. This guide builds the second kind, in Google Sheets and in CSV.

The free Amazon spreadsheet template (Google Sheets + one script)

The “template” here is honest: it’s a script that builds the sheet for you. Tabs, headers, formatting, sample queries. You never design anything. And unlike a static download, it comes with the refresh logic already wired in.

You need a Google account and 15 minutes. That’s the whole requirements list.

Step 1: create the sheet and open Apps Script

Go to sheets.new , which creates a blank Google Sheet. Then open Extensions > Apps Script. A code editor appears in a new tab, showing an empty function. Delete that placeholder.

Step 2: paste the template script

Paste this entire script into the editor and hit the save icon:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
const RAPIDAPI_KEY = 'PASTE_YOUR_KEY_HERE';
const API_HOST = 'real-time-amazon-data-the-most-complete.p.rapidapi.com';

// Run once: builds the template (tabs, headers, sample queries)
function setup() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const config = ss.getSheetByName('Config') || ss.insertSheet('Config');
  config.getRange('A1:B1').setValues([['Search term or ASIN', 'Marketplace']])
    .setFontWeight('bold').setBackground('#1E3A5F').setFontColor('#ffffff');
  config.getRange('A2:B4').setValues([
    ['wireless earbuds', 'com'],
    ['yoga mat', 'com'],
    ['B09B8V1LZ3', 'com'],
  ]);
  const out = ss.getSheetByName('Products') || ss.insertSheet('Products');
  out.clear();
  out.getRange(1, 1, 1, 10).setValues([[
    'Date', 'Query', 'ASIN', 'Title', 'Price', 'Original price',
    'Rating', 'Reviews', 'Best Seller', 'URL',
  ]]).setFontWeight('bold').setBackground('#1E3A5F').setFontColor('#ffffff');
  out.setFrozenRows(1);
}

// Run on a schedule: fetches live Amazon data for every Config row
function refreshData() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const rows = ss.getSheetByName('Config').getDataRange().getValues().slice(1);
  const out = ss.getSheetByName('Products');
  const stamp = new Date();
  rows.forEach(([term, marketplace]) => {
    if (!term) return;
    const isAsin = /^B0[A-Z0-9]{8}$/i.test(String(term).trim());
    const path = isAsin
      ? '/product-details?asin=' + encodeURIComponent(term)
      : '/search?query=' + encodeURIComponent(term);
    const url = 'https://' + API_HOST + path + '&marketplace=' + (marketplace || 'com');
    const resp = UrlFetchApp.fetch(url, {
      headers: { 'x-rapidapi-key': RAPIDAPI_KEY, 'x-rapidapi-host': API_HOST },
      muteHttpExceptions: true,
    });
    const json = JSON.parse(resp.getContentText());
    if (!json.data) return;
    // Keeps the top 10 per search so the sheet stays readable.
    // Delete ".slice(0, 10)" to log every result (up to 48 per search).
    const products = isAsin
      ? [{ ...json.data, best_seller: json.data.is_best_seller,
           url: 'https://www.amazon.' + (marketplace || 'com') + '/dp/' + json.data.asin }]
      : (json.data.products || []).slice(0, 10);
    products.forEach(p => out.appendRow([
      stamp, term, p.asin, p.title, p.price, p.original_price || '',
      p.rating, p.reviews_count, p.best_seller ? 'Yes' : '', p.url,
    ]));
  });
}

Two functions. setup() builds the template once. refreshData() reads your search terms from the Config tab, calls the API, and appends one row per product with a timestamp.

Because it appends instead of overwriting, your sheet accumulates price history automatically. Run it daily for a month and every ASIN you watch has 30 price points, free.

Step 3: get your free API key

The script needs a key to fetch data. Grab one from the Amazon Product Data API on RapidAPI: sign up, subscribe to the free plan, and copy the x-rapidapi-key value shown in the code snippets panel. Replace PASTE_YOUR_KEY_HERE in line 1 with it.

The free tier gives you 100 requests a month. One search request returns up to 48 products; the template keeps the top 10 per query so the sheet stays readable, but delete one .slice(0, 10) and those same 100 requests can log up to 4,800 product rows a month.

Pro tip:

Signing up takes about 2 minutes and no credit card. Compare that with SP-API developer approval, where sellers report waiting a month and getting rejected. Different data, different world.

Step 4: run setup() and authorize

In the Apps Script toolbar, select setup in the function dropdown and press Run. Google will ask you to authorize the script; it’s your own script on your own account, so review and accept. Switch back to the sheet tab: you’ll see a Config tab with sample queries and an empty Products tab with formatted headers.

Edit the Config tab now. Put in your real search terms (one per row) or paste specific ASINs you want to watch. The Marketplace column accepts com, co.uk, de, fr, co.jp, and 17 more.

Step 5: run refreshData()

Back in Apps Script, select refreshData and press Run. Give it 10 to 20 seconds. Your Products tab fills with live data: titles, current prices, ratings, review counts, Best Seller flags, and product URLs, each row stamped with today’s date.

That’s the whole manual flow. Now let’s remove the manual part.

Step 6: make it refresh itself

In the Apps Script editor’s left sidebar, click the clock icon (Triggers), then Add Trigger. Choose refreshData as the function, Time-driven as the event source, and Day timer with a time window you like. Save.

Done. Your spreadsheet now updates itself every day, whether or not you open it. This is the automated feed that Reddit thread was told needs custom pipelines and paid tools.

Get your free API key on RapidAPI →

100 requests/month free · No credit card required

Amazon data to CSV with Python (for developers)

If you’d rather have a file than a Google Sheet, here’s the same result in Python. A CSV opens in Excel, feeds a BI dashboard, or lands in a database loader. And there’s no HTML to parse: the Amazon search API endpoint returns structured JSON and we just flatten it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import csv
import requests

API_KEY = "PASTE_YOUR_KEY_HERE"
HOST = "real-time-amazon-data-the-most-complete.p.rapidapi.com"

QUERIES = ["wireless earbuds", "yoga mat"]
MARKETPLACE = "com"

FIELDS = ["query", "asin", "title", "price", "original_price",
          "rating", "reviews_count", "best_seller", "position", "url"]

def search(query: str) -> list[dict]:
    resp = requests.get(
        f"https://{HOST}/search",
        headers={"x-rapidapi-key": API_KEY, "x-rapidapi-host": HOST},
        params={"query": query, "marketplace": MARKETPLACE},
        timeout=30,
    )
    resp.raise_for_status()
    return resp.json()["data"]["products"]

with open("amazon_products.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=FIELDS, extrasaction="ignore")
    writer.writeheader()
    for q in QUERIES:
        for product in search(q):
            writer.writerow({"query": q, **product})
    print("Done: amazon_products.csv")

Run it with python3 script.py after a pip install requests. Thirty seconds later you have amazon_products.csv with every product from every query, ready for Excel or pandas.

Notice what’s not in this script: no Selenium, no CAPTCHA handling, no proxy rotation. If you’ve ever tried scraping Amazon directly, you know those three things eat entire weekends. I wrote a separate guide on web scraping Amazon with Selenium if you want to see what the DIY route actually involves; it’s 10x the code for the same rows.

One detail that matters more than people expect: every request to this Amazon data API is routed through an IP inside the target marketplace’s own country. Request marketplace=de and Amazon sees a German visitor. Without that, cross-country price checks quietly return wrong numbers, because Amazon adjusts prices and availability by visitor location.

1

Don't hardcode your key into a shared sheet

Anyone with edit access to the spreadsheet can open Apps Script and read it. Share view-only copies, or keep the data sheet separate from the script sheet.

2

Don't set the trigger to every hour "just in case"

24 refreshes a day of 3 queries burns 2,160 requests a month. Amazon prices don't move that fast for most categories. Daily is the sweet spot; the free tier covers 3 queries a day.

3

Don't mix marketplaces in one price column carelessly

The price field keeps the local currency symbol (€49.99 vs $49.99). If you aggregate across marketplaces, split currency into its own column first using the price_symbol field.

What sellers actually build on top of this sheet

A sheet full of product rows is the starting point, not the goal. Here’s what customers tell us they build on top of it.

Price tracking. The template’s append-based history means column A already holds your timeline. Strip the currency symbol with a VALUE formula, chart price by date filtered to one ASIN, and you have a poor man’s Keepa for exactly the products you care about. When you outgrow the sheet, the same API powers a proper Amazon price tracker in Python with Telegram alerts.

Competitor watchlists. Paste your competitors’ ASINs into Config and let the daily trigger do its thing. You’ll see price drops, review velocity, and Best Seller badge changes without visiting a single product page. Sellers using Amazon competitor monitoring via API usually watch 10 to 50 ASINs this way.

Numbers check:

3 search terms refreshed daily is about 90 requests a month, inside the free tier's 100. At the template's 10 rows per search, that's roughly 900 fresh rows of history every month without spending a cent.

Product research. Search a niche keyword weekly and watch which products climb the results. The position and bought_last_month fields from the Amazon product research API turn “I have a feeling this niche is heating up” into actual numbers.

The same spreadsheet pattern works beyond Amazon, by the way. We run parallel APIs for Google search rankings , local business data from Google Maps , company and funding data from Crunchbase , and job listings across boards . Same Apps Script skeleton, different endpoint.

And if you sell across borders, the translation API batch-translates listing titles right inside the same sheet.

Key takeaway:

The script is about 50 lines, but what it replaces is real: Keepa-style subscriptions for market data, manual price-check sessions, and the SP-API application you don't need. One sheet, refreshed daily, covers most solo-seller monitoring.

How to get a spreadsheet of your Amazon purchases

Different question, and a lot of people land here asking it, so let’s answer it properly. Your own order history doesn’t come from any API: Amazon hands it to you directly.

For personal accounts, go to Amazon’s Request My Data page under Account settings, select “Your Orders”, and submit. Amazon emails you a download link with CSV files, often within a day or two, though its official window stretches to 30 days. Open them in Excel or upload to Google Sheets and you have every purchase, date, and amount.

Amazon Business accounts have it easier: a built-in reports section generates order spreadsheets on demand, with custom date ranges. And sellers get their sales, inventory, and settlement reports in Seller Central under Reports. None of this needs code, and none of it covers competitor data, which is why the template above exists.

Which method should you pick?

Quick comparison of every route to an Amazon data spreadsheet, including the ones this guide skipped on purpose:

MethodData typeSetup timeCostAuto-refresh
Sheets + Apps Script template (this guide)Market data15 minFree to startYes, daily trigger
Python + API to CSV (this guide)Market data10 minFree to startYes, cron
Seller Central report downloadsYour own sales5 min each timeFreeNo, manual
SP-API custom integrationYour own salesWeeks (approval)Free + dev timeYes
Seller tools (Sellerboard, Gorilla ROI)Your own sales30 minMonthly feeYes

Pick the Sheets template

You don't code, you want competitor prices and rankings updating daily, and you live in Google Sheets anyway. 15 minutes, free tier, done.

Pick the Python script

You want CSV files in a pipeline, a database, or a dashboard. Cron the script and treat the API as your structured Amazon backend.

Pick Seller Central reports

You need YOUR sales and inventory numbers, occasionally, and a manual download once a week doesn't hurt. Free and official.

Pick both, honestly

Most sellers end up here: Seller Central reports for their own numbers, plus the API-fed sheet for market intel. The two data types complement each other.

That Reddit seller was ready to pay a developer to wire an API into Google Sheets. For the market-data half of the job, you just did it during a coffee break: one pasted script, a free key, a daily trigger. And his own-sales half was a Seller Central report download all along.

Copy the script from this page or clone it from GitHub , get the free API key, and check what else the FlyByAPIs Amazon Product Data API exposes when you’re ready for more than search results: product details, offers, sellers, best-seller lists, deals.

Try the Amazon API free on RapidAPI →

100 requests/month free · No credit card required

P.S. If your Config tab grows past 3 queries a day, you’ll hit the free tier’s ceiling mid-month. That’s usually the moment the sheet has proven it earns its keep.

Oriol.

FAQ

Frequently Asked Questions

Q Is there a free Amazon spreadsheet template?

Yes. The template in this guide is free: one Apps Script you paste into a blank Google Sheet. Running setup() builds the tabs and headers for you, and the data comes from the FlyByAPIs Amazon API free tier, which includes 100 requests per month with no credit card.

Q Can I get a spreadsheet of my Amazon orders?

Yes, but not from this template. For personal purchases, go to Amazon's Request My Data page (Account > Your Account Data) and ask for your orders; Amazon emails you CSV files you can open in Excel or Google Sheets. Sellers get sales and inventory reports directly in Seller Central under Reports.

Q What is a spreadsheet in Amazon Seller Central?

Amazon uses the word for its bulk listing inventory files: Excel templates you download from Seller Central, fill with product data, and upload to create or update listings at scale. They are for pushing data INTO Amazon, the opposite direction of the template in this guide.

Q Do I need Amazon SP-API approval to pull product data?

No. SP-API approval is only required for your own seller account data, and developer applications can take weeks and get rejected. Public market data such as prices, ratings, and search results comes from the FlyByAPIs Amazon API with a RapidAPI key you get in about 2 minutes.

Q How often can the sheet refresh on the free plan?

The free tier includes 100 requests per month. One search request returns up to 48 products, so refreshing 3 search terms daily fits inside the limit. If you track more terms or want hourly snapshots, the paid tiers on RapidAPI remove the ceiling.

Q Can I pull prices from Amazon Germany or Japan into the same sheet?

Yes. Set the marketplace column to de, co.jp, or any of the 22 supported marketplaces. Each request is routed through an IP inside that marketplace's own country, so the prices and availability in your sheet match what a local shopper actually sees.

Q How do I get the data into Excel instead of Google Sheets?

Two options. The Python script in this guide writes a plain CSV file that Excel opens directly. Or build the Google Sheet first and use File > Download > Microsoft Excel whenever you need an .xlsx copy.
Share this article
Oriol Marti
Oriol Marti
Founder & CEO

Computer engineer and entrepreneur based in Andorra. Founder and CEO of FlyByAPIs, building reliable web data APIs for developers worldwide.

Free tier available

Ready to stop maintaining scrapers?

Production-ready APIs for web data extraction. Whatever you're building, up and running in minutes.

Start for free on RapidAPI