# Build a Product Catalog API Using Google Sheets (No Backend Required)

Managing a product catalog shouldn't require a database engineer. If you're running a small e-commerce store, building a prototype, or managing inventory for a client project, Google Sheets is already a great place to organize your products.

The missing piece? Getting that data into your app, website, or storefront as clean JSON through an API.

Here's how to build a working product catalog API using nothing but a Google Sheet and Jsonsheets.

Step 1: Structure Your Google Sheet

Open Google Sheets and create a spreadsheet with columns that represent your product data. The first row becomes your API field names, so keep them clean and lowercase:

| **id** | **name** | **category** | **price** | **stock** | **image\_url** | **status** |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | Wireless Earbuds | Audio | 49.99 | 150 | [https://example.com/earbuds.jpg](https://example.com/earbuds.jpg) | active |
| 2 | USB-C Hub | Accessories | 34.99 | 85 | [https://example.com/hub.jpg](https://example.com/hub.jpg) | active |
| 3 | Laptop Stand | Accessories | 29.99 | 0 | [https://example.com/stand.jpg](https://example.com/stand.jpg) | out\_of\_stock |
| 4 | Mechanical Keyboard | Peripherals | 89.99 | 42 | [https://example.com/keyboard.jpg](https://example.com/keyboard.jpg) | active |

Tips for structuring your sheet:

* Use consistent naming — lowercase with underscores works best for API fields
    
* Keep one product per row
    
* Use a `status` column to control which products appear in your store
    
* Separate categories, variants, or pricing tiers into different tabs
    

Step 2: Connect Your Sheet to Jsonsheets

1. Sign in at [jsonsheets.com](https://jsonsheets.com/) with your Google account
    
2. Click **Browse Drive** and select your product catalog spreadsheet
    
3. Jsonsheets automatically detects all tabs and generates API endpoints for each one
    

You'll get an API slug — something like `product-catalog` — and each tab becomes its own endpoint.

Step 3: Get Your API Key

Go to the **API Keys** page in your dashboard and create a new key. Every request to your product catalog API needs this key in the header:

```plaintext
Authorization: Bearer js_your_api_key_here
```

Step 4: Fetch Your Product Catalog

Now you can pull your entire product catalog as JSON:

```plaintext
curl -H "Authorization: Bearer js_your_api_key_here" \
  https://jsonsheets.com/api/v1/product-catalog/Sheet1
```

```json
{
  "data": [
    {
      "id": "1",
      "name": "Wireless Earbuds",
      "category": "Audio",
      "price": "49.99",
      "stock": "150",
      "image_url": "https://example.com/earbuds.jpg",
      "status": "active"
    },
    {
      "id": "2",
      "name": "USB-C Hub",
      "category": "Accessories",
      "price": "34.99",
      "stock": "85",
      "image_url": "https://example.com/hub.jpg",
      "status": "active"
    }
  ],
  "count": 4
}
```

Step 5: Filter and Search Products

The real power is in query parameters. You don't need to fetch everything and filter client-side.

**Get only active products:**

```plaintext
GET /api/v1/product-catalog/Sheet1?status=active
```

**Get products in a specific category:**

```plaintext
GET /api/v1/product-catalog/Sheet1?category=Accessories
```

**Limit results for pagination:**

```plaintext
GET /api/v1/product-catalog/Sheet1?limit=10&start=1&end=10
```

**Get a single product by row:**

```plaintext
GET /api/v1/product-catalog/Sheet1/2
```

Step 6: Add New Products via API

Your team can add products through the spreadsheet, but you can also add them programmatically:

```javascript
curl -X POST \
  -H "Authorization: Bearer js_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"name": "Webcam HD", "category": "Peripherals", "price": "59.99", "stock": "30", "status": "active"}' \
  https://jsonsheets.com/api/v1/product-catalog/Sheet1
```

The new row appears instantly in your Google Sheet and is immediately available through the API.

Step 7: Update Inventory and Prices

Need to mark a product as out of stock? Update by condition:

```javascript
curl -X PUT \
  -H "Authorization: Bearer js_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"condition": {"name": "Laptop Stand"}, "set": {"status": "out_of_stock", "stock": "0"}}' \
  https://jsonsheets.com/api/v1/product-catalog/Sheet1
```

Or update a specific row directly:

```javascript
curl -X PUT \
  -H "Authorization: Bearer js_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{"price": "39.99"}' \
  https://jsonsheets.com/api/v1/product-catalog/Sheet1/2
```

Using Multiple Tabs for Organized Catalogs

If your catalog has different product types, use separate tabs in the same spreadsheet:

* **Electronics** tab → `/api/v1/product-catalog/Electronics`
    
* **Clothing** tab → `/api/v1/product-catalog/Clothing`
    
* **Books** tab → `/api/v1/product-catalog/Books`
    

Each tab gets its own endpoint automatically. No extra configuration needed.

Example: Loading Products in a React App

```javascript
const response = await fetch(
  "https://jsonsheets.com/api/v1/product-catalog/Sheet1?status=active",
  {
    headers: { Authorization: "Bearer js_your_api_key_here" }
  }
);
const { data: products } = await response.json();

products.forEach(product => {
  console.log(`${product.name} - $${product.price}`);
});
```

Why This Approach Works

* **Non-technical team members** can update products directly in Google Sheets without touching code
    
* **No database setup** — your spreadsheet is the database
    
* **Instant changes** — edit a cell in Sheets, and the API reflects it on the next request
    
* **Built-in caching** — repeated API calls are fast, reducing load on Google's servers
    
* **API key security** — your product data is never publicly exposed
    

When to Use This (and When Not To)

**This approach works great for:**

* Small to medium product catalogs (under 10,000 items)
    
* MVP and prototype stores
    
* Internal tools and dashboards
    
* Client projects with tight deadlines
    
* Headless commerce setups where the team manages data in Sheets
    

**Consider a traditional database when:**

* You have hundreds of thousands of products
    
* You need complex relational queries (joins, aggregations)
    
* You need sub-millisecond response times under heavy concurrent load
    

Get Started

You can have a working product catalog API in under 2 minutes:

1. Structure your products in Google Sheets
    
2. Connect the sheet at [jsonsheets.com](https://jsonsheets.com/)
    
3. Start fetching products as JSON
    

No server to deploy. No database to manage. No backend code to write.

**Build your product catalog API at** [**jsonsheets.com**](https://jsonsheets.com/)