How to Monitor Product Availability Across 7 Quick Commerce Platforms

Out-of-stock products are one of the biggest pain points in quick commerce. Whether you're a D2C brand trying to ensure your products are always available, a retailer tracking competitor inventory, or a consumer tired of finding items unavailable at checkout — real-time availability monitoring is the answer. With the QuickCommerce API, you can track product availability across all 7 major platforms from a single integration.

In this guide, we'll walk through building a complete product availability monitoring system. You'll learn how to query availability data, set up automated checks, and receive instant notifications when products go out of stock or come back in stock. If you haven't already, sign up for a free account to follow along with the examples.

BlinkItZeptoSwiggyBigBasketDMartJioMartMinutes

Using Groupsearch for Availability Discovery

The groupsearch endpoint is the fastest way to check product availability across all platforms simultaneously. A single API call returns search results from every supported platform, including whether each product is currently in stock. This makes it ideal for broad availability monitoring — you can scan hundreds of products across 7 platforms with minimal API calls.

Each result includes an `available` field that tells you whether the product can be ordered right now. Combined with pricing data, this gives you a complete picture of where a product can be purchased and at what price. Let's see this in action with a popular product.

curl -X GET "https://api.quickcommerceapi.com/api/v1/groupsearch?query=Maggi+2-Minute+Noodles+Masala+70g" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "query": "Maggi 2-Minute Noodles Masala 70g",
  "results": {
    "blinkit": [
      {
        "name": "Maggi 2-Minute Instant Noodles - Masala",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": true,
        "image": "https://cdn.blinkit.com/maggi-masala-70g.jpg",
        "productId": "maggi-2min-masala-70g-blinkit"
      }
    ],
    "zepto": [
      {
        "name": "Maggi 2-Minute Masala Noodles",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": true,
        "image": "https://cdn.zepto.co.in/maggi-masala.jpg",
        "productId": "maggi-noodles-masala-70g-zepto"
      }
    ],
    "swiggy": [
      {
        "name": "Maggi 2-Minute Noodles Masala",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": false,
        "image": "https://cdn.swiggy.com/maggi-noodles.jpg",
        "productId": "maggi-2min-70g-swiggy"
      }
    ],
    "bigbasket": [
      {
        "name": "Maggi 2-Minute Masala Instant Noodles",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": true,
        "image": "https://cdn.bigbasket.com/maggi-masala.jpg",
        "productId": "maggi-masala-noodles-bb"
      }
    ],
    "dmart": [
      {
        "name": "Maggi 2 Minute Noodles Masala",
        "weight": "70 g",
        "price": 12,
        "mrp": 14,
        "available": true,
        "image": "https://cdn.dmart.in/maggi-noodles.jpg",
        "productId": "maggi-2min-masala-dmart"
      }
    ],
    "jiomart": [
      {
        "name": "Maggi 2-Minute Masala Noodles 70g",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": true,
        "image": "https://cdn.jiomart.com/maggi.jpg",
        "productId": "maggi-masala-noodles-jio"
      }
    ],
    "minutes": [
      {
        "name": "Maggi 2 Min Masala Noodles",
        "weight": "70 g",
        "price": 14,
        "mrp": 14,
        "available": false,
        "image": "https://cdn.minutes.co.in/maggi.jpg",
        "productId": "maggi-masala-70-minutes"
      }
    ]
  }
}

Notice how Swiggy Instamart and Minutes show `available: false` — meaning Maggi Masala 70g is currently out of stock on those two platforms. Also note that DMart has the lowest price at Rs 12, compared to Rs 14 on every other platform. This kind of cross-platform insight is exactly what makes availability monitoring so powerful for brands and retailers alike.

Deep-Dive with the Item Endpoint

While groupsearch gives you a broad view, the item endpoint lets you get detailed information about a specific product on a specific platform. This is useful when you already know the product ID and want to check its current status, including more granular inventory details where available. You can find product IDs from the groupsearch results or by browsing platform pages like BlinkIt or Zepto.

curl -X GET "https://api.quickcommerceapi.com/api/v1/item?productId=maggi-2min-masala-70g-blinkit&platform=blinkit" \
  -H "X-API-Key: YOUR_API_KEY"

{
  "platform": "blinkit",
  "productId": "maggi-2min-masala-70g-blinkit",
  "name": "Maggi 2-Minute Instant Noodles - Masala",
  "brand": "Maggi",
  "category": "Instant Noodles",
  "weight": "70 g",
  "price": 14,
  "mrp": 14,
  "discount": 0,
  "available": true,
  "inventoryCount": 142,
  "image": "https://cdn.blinkit.com/maggi-masala-70g.jpg",
  "description": "Maggi 2-Minute Masala Noodles with the authentic taste of Maggi masala spice mix.",
  "lastUpdated": "2026-03-11T10:23:45Z"
}

The item endpoint returns an `inventoryCount` field where available, giving you a sense of how many units are in stock. In this case, BlinkIt has 142 units of Maggi Masala 70g — a healthy stock level. When this number drops below a threshold, you know the product might go out of stock soon.

Building an Availability Monitor

Now let's put this together into a practical monitoring script. The following Python script checks availability for a list of products across all platforms every hour and logs the results to a CSV file. This creates a historical record you can analyze to identify patterns — like which platforms frequently stock out on weekends or which products have unreliable supply chains.

import requests
import csv
import time
from datetime import datetime

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.quickcommerceapi.com/api/v1"

PRODUCTS_TO_MONITOR = [
    "Maggi 2-Minute Noodles Masala 70g",
    "Amul Taaza Toned Fresh Milk 1L",
    "Tata Salt 1kg",
    "Aashirvaad Atta 5kg",
    "Parle-G Gold Biscuits 100g",
    "Haldiram Aloo Bhujia 200g",
    "Britannia Bread White 400g",
    "Mother Dairy Dahi 400g",
]

PLATFORMS = ["blinkit", "zepto", "swiggy", "bigbasket", "dmart", "jiomart", "minutes"]

def check_availability(query: str) -> dict:
    """Check product availability across all platforms."""
    resp = requests.get(
        f"{BASE_URL}/groupsearch",
        params={"query": query},
        headers={"X-API-Key": API_KEY},
    )
    resp.raise_for_status()
    return resp.json()

def log_to_csv(results: list[dict], filename: str = "availability_log.csv"):
    """Append availability results to CSV."""
    file_exists = False
    try:
        with open(filename, "r"):
            file_exists = True
    except FileNotFoundError:
        pass

    with open(filename, "a", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=[
            "timestamp", "product", "platform", "available", "price", "product_id"
        ])
        if not file_exists:
            writer.writeheader()
        writer.writerows(results)

def run_monitor():
    """Run one monitoring cycle for all products."""
    timestamp = datetime.now().isoformat()
    all_results = []

    for product in PRODUCTS_TO_MONITOR:
        print(f"[{timestamp}] Checking: {product}")
        try:
            data = check_availability(product)
            for platform in PLATFORMS:
                items = data.get("results", {}).get(platform, [])
                if items:
                    top = items[0]
                    all_results.append({
                        "timestamp": timestamp,
                        "product": product,
                        "platform": platform,
                        "available": top.get("available", False),
                        "price": top.get("price", "N/A"),
                        "product_id": top.get("productId", ""),
                    })
                else:
                    all_results.append({
                        "timestamp": timestamp,
                        "product": product,
                        "platform": platform,
                        "available": False,
                        "price": "N/A",
                        "product_id": "",
                    })
        except Exception as e:
            print(f"  Error checking {product}: {e}")

    log_to_csv(all_results)
    print(f"Logged {len(all_results)} records to availability_log.csv")

if __name__ == "__main__":
    CHECK_INTERVAL = 3600  # 1 hour in seconds
    print("Starting availability monitor...")
    while True:
        run_monitor()
        print(f"Next check in {CHECK_INTERVAL // 60} minutes.")
        time.sleep(CHECK_INTERVAL)

This script monitors 8 popular Indian grocery products across all 7 platforms, generating 56 data points per check. Running it every hour gives you 1,344 data points per day — enough to build detailed availability heatmaps and identify stocking patterns. You can easily extend it with the products and intervals that matter to your business.

Availability Snapshot: Maggi Noodles Across 7 Platforms

Here's a real-world snapshot of Maggi Masala Noodles availability captured using the monitoring script above. This data was collected for a location in Mumbai on a Tuesday afternoon.

Setting Up Slack and Email Notifications

Monitoring is only useful if you act on the data. The next step is to set up real-time notifications so you're alerted the moment a product goes out of stock or comes back in stock. Here's how to send notifications to a Slack channel using an incoming webhook — you can adapt this pattern for email, Discord, Telegram, or any other notification service.

import requests
import json

SLACK_WEBHOOK_URL = "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXX"

def send_slack_alert(product: str, platform: str, status: str, price: str = None):
    """Send a Slack notification for availability changes."""
    emoji = ":white_check_mark:" if status == "in_stock" else ":red_circle:"
    status_text = "Back in Stock" if status == "in_stock" else "Out of Stock"

    message = {
        "blocks": [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": f"{emoji} {status_text}: {product}",
                }
            },
            {
                "type": "section",
                "fields": [
                    {"type": "mrkdwn", "text": f"*Platform:*\n{platform}"},
                    {"type": "mrkdwn", "text": f"*Price:*\nRs {price}" if price else "*Price:*\nN/A"},
                    {"type": "mrkdwn", "text": f"*Status:*\n{status_text}"},
                    {"type": "mrkdwn", "text": f"*Time:*\n<!date^{int(time.time())}^{{date_short}} {{time}}|now>"},
                ]
            }
        ]
    }

    resp = requests.post(SLACK_WEBHOOK_URL, json=message)
    if resp.status_code == 200:
        print(f"Slack alert sent: {product} is {status_text} on {platform}")
    else:
        print(f"Failed to send Slack alert: {resp.status_code}")

# Example usage — integrate this into your monitor loop:
# Previous state tracking
previous_availability = {}

def check_and_notify(product, platform, is_available, price):
    key = f"{product}:{platform}"
    was_available = previous_availability.get(key)

    if was_available is not None and was_available != is_available:
        status = "in_stock" if is_available else "out_of_stock"
        send_slack_alert(product, platform, status, price)

    previous_availability[key] = is_available

The key pattern here is tracking previous availability state so you only send notifications on transitions — when a product changes from available to unavailable or vice versa. Without this, you'd get a notification every hour for every out-of-stock product, which quickly becomes noise. For email notifications, you can use a similar approach with services like SendGrid, Amazon SES, or even Python's built-in `smtplib`.

Use Cases for Availability Monitoring

D2C Brands and Manufacturers

If you sell products on quick commerce platforms, availability monitoring is critical. Stockouts directly impact your revenue and search ranking on these platforms. By monitoring your products across all 7 platforms, you can identify which distributors or dark stores are running low and proactively push replenishment. Brands like Maggi, Amul, and Haldiram's can use this data to ensure their bestsellers are never out of stock.

Retailers and Competitive Intelligence

Retailers can track competitor product availability to identify gaps in the market. If a popular product is consistently out of stock on one platform, it might be an opportunity to capture that demand elsewhere. Combine availability data with pricing trend analysis for a comprehensive competitive intelligence system.

Consumers and Smart Shopping

End consumers can use availability data to find products that are frequently out of stock on their preferred platform. By monitoring across all platforms, you can set up alerts to be notified the moment a sold-out product comes back in stock — on any platform. This is especially useful for high-demand items during sales events or seasonal peaks.

Setup Guide: Your First Availability Monitor

Optimizing API Usage for Monitoring

Each groupsearch call counts as one credit and returns results from all 7 platforms. This means monitoring 10 products costs just 10 credits per cycle — far more efficient than calling each platform individually. At the Starter plan's 10,000 credits per month, you could monitor 10 products every hour around the clock with room to spare. For larger product catalogs, check out our Growth and Enterprise plans.

For platforms that require a pincode — DMart, JioMart, and Minutes — remember to include the `x-geolocation-pincode` header in your requests. Without it, you may get inaccurate availability data or empty results for these platforms. Check the API documentation for the full list of platform-specific requirements.