Razorpay Sales Analyzer

Introduction to E-commerce Sales Analysis and Revenue Tracking

For modern digital entrepreneurs, SaaS businesses, and online retail stores, maintaining a clear and accurate overview of financial metrics is essential for long-term growth and operational stability. Payment gateways like Razorpay handle millions of transaction requests daily, providing a seamless bridge between buyer checkouts and merchant banking systems. However, simply collecting payments is only the first phase. Once sales occur, business managers, financial analysts, and tax accountants must audit these records. This requires tracking daily revenue performance, identifying peak sales trends, and extracting detailed product-wise breakdowns. When merchants export transaction reports from payment dashboards, they are faced with raw Excel spreadsheets, CSV logs, or compressed ZIP archives containing thousands of transaction rows. Processing these files manually is highly tedious, repetitive, and susceptible to copy-paste calculation errors.

An automated sales analyzer provides a direct solution by parsing raw files instantly. A critical feature of this tool is the capability to handle multi-file inputs, including nested ZIP archives, Excel workbooks (.xlsx), and CSV files. Furthermore, because the entire analysis is performed client-side using JavaScript libraries, no financial spreadsheets, customer emails, or transaction figures are uploaded to external server databases. This privacy-first structure is a significant advantage for businesses operating under strict compliance guidelines like GDPR or PCI-DSS, ensuring complete security while delivering unified, interactive sales graphs, product summaries, and detailed search lists in milliseconds.

In addition, analyzing product-specific sales quantities is crucial for optimizing supply chain operations, inventory restocks, and marketing campaigns. When multiple separate products are purchased under a single checkout session, payment portals frequently pack the list of items into a single, comma-separated field in the transaction notes. Standard spreadsheet software often treats the entire string as a single item, leaving managers blind to actual demand. Standardizing these exports via automated parsing splits the elements and attributes appropriate revenue share to each product, keeping business decisions aligned with consumer demand.

The Evolution of Razorpay and Online Payments in India

To understand the context of Razorpay's data exports and page query features, it is helpful to look at the history of the payment gateway market. Founded in 2014 by Harshil Mathur and Shashank Kumar, Razorpay was established at a time when integrating online payments in India was a complex, multi-week process requiring extensive paperwork, physical server configurations, and unstable merchant APIs. By introducing a developer-centric platform with clean API documentations, easy onboarding, and instant sandbox environments, Razorpay transformed how startups and digital businesses collected money online.

Following the demonetization drive in 2016 and the explosive growth of the Unified Payments Interface (UPI) developed by the National Payments Corporation of India (NPCI), online transactions in India grew exponentially. To manage this massive transaction volume, payment processors evolved from single-payment forms to complex subscription models, payment links, and customizable checkout buttons. During these checkout processes, customers can add multiple separate items to a cart. Because classical relational databases require complex table associations to store multi-item checkouts, payment interfaces often pack the list of items into a single text metadata field. This legacy convenience is why developers today must deal with parsing comma-separated lists when downloading transaction logs, and why prefilled checkout links are highly sought after to streamline customer acquisition.

Advanced Mathematical Modeling: Cohort Analysis and LTV Tracking

Beyond simple sales counting, businesses use transaction logs to perform sophisticated financial forecasting and cohort analysis. Cohort analysis involves grouping customers based on their purchase date and tracking their behavior over time. By calculating the repurchase rate and Customer Lifetime Value (LTV), merchants can determine if their customer acquisition cost (CAC) is sustainable in the long run.

For example, if a cohort of customers acquired in January generates ₹100,000 in initial sales, and then generates ₹30,000 in recurring purchases in February, the one-month retention rate is 30%. Tracking these changes over a 12-month window allows you to project future cash flows. When you run bulk files through our analyzer, you can extract transaction dates and calculate these patterns. Standardizing the inputs enables your business to build predictive customer models and adjust product offerings to maximize retention.

Regulatory Compliance: Taxation, GST, and Accounting Reconciliation

In addition to business intelligence, transaction records are required for tax compliance and monthly accounting reconciliation. In India, businesses must reconcile payment gateway reports with their bank statements and issue GST-compliant tax invoices. The Goods and Services Tax (GST) requires businesses to classify sales into specific tax slabs (e.g., 5%, 12%, 18%, or 28%) based on the Harmonized System of Nomenclature (HSN) code of the product sold.

When you download a raw report, you must isolate the transaction amount (representing the gross value paid by the customer) from the gateway fees and service taxes charged by Razorpay. This process is called reconciliation. By grouping sales by product name and date using our sales analyzer, accountants can quickly verify that the tax collected matches the product-wise sales quantities reported in the company ledger. This prevents audit mismatches and ensures perfect compliance with regulatory guidelines.

The Technical Architecture of Clientside ZIP and Excel File Processing

From a software architecture perspective, processing compressed archives and binary spreadsheets entirely inside a web browser requires advanced JavaScript APIs. Our Razorpay Sales Analyzer combines two powerful open-source libraries: JSZip for handling archive extraction and SheetJS (XLSX) for parsing binary spreadsheet data structures. When a user drops a ZIP file onto the target landing zone, the browser reads the file as an ArrayBuffer using the HTML5 File API.

The system executes the following processing pipeline:

1. Archive Loading: The JSZip.loadAsync() method unpacks the binary zip file. The script searches the internal directory tree for spreadsheets ending in .xlsx or .csv.
2. Spreadsheet Parsing: Once located, the spreadsheet file content is read as a Uint8Array. The XLSX.read() method parses the binary sheet format into a structured workbook object.
3. JSON Conversion: The first worksheet in the workbook is extracted and converted into a standard array of JavaScript JSON objects using the XLSX.utils.sheet_to_json() method.
4. Revenue Sharing Calculation: For checkouts containing multiple products, the total order revenue must be split equally among the items. The script extracts the comma-separated product names from the metadata, counts the elements, and divides the credit amount: Product Revenue Share = Total Order Amount ÷ Number of Items.
5. Daily Aggregation: Transactions are grouped by date to calculate daily sums and transaction counts, which are sorted chronologically.

This automated flow eliminates manual data cleaning steps, allowing merchants to analyze months of sales data in a single drop action. By resolving complex file reading client-side, the system minimizes hosting costs and protects the host platform from handling sensitive data logs.

A JavaScript Script to Parse ZIP Archives and Aggregate Sales

For developers designing custom admin tools or automation routines, understanding how to read and aggregate data from ZIP files programmatically is highly beneficial. The following JavaScript code demonstrates a clean, reusable function that processes a zipped file containing an Excel spreadsheet, parses the rows, filters for valid payment entries, and returns a detailed sales summary:

async function processSalesZip(fileObject) {
  try {
    // 1. Load the ZIP file asynchronously
    const zip = new JSZip();
    const contents = await zip.loadAsync(fileObject);
    
    // 2. Find the first spreadsheet in the archive
    const sheetKey = Object.keys(contents.files).find(name => 
      !contents.files[name].dir && (name.endsWith('.xlsx') || name.endsWith('.csv'))
    );
    
    if (!sheetKey) {
      throw new Error("No spreadsheet found in the ZIP archive.");
    }
    
    // 3. Extract the sheet content as a binary buffer
    const binaryBuffer = await contents.files[sheetKey].async("uint8array");
    
    // 4. Parse using SheetJS
    const workbook = XLSX.read(binaryBuffer, { type: 'array' });
    const firstSheetName = workbook.SheetNames[0];
    const worksheet = workbook.Sheets[firstSheetName];
    const rawRows = XLSX.utils.sheet_to_json(worksheet);
    
    // 5. Aggregate metrics
    let totalRevenue = 0;
    let paymentCount = 0;
    const productCounts = {};
    
    rawRows.forEach(row => {
      const type = (row.type || row.Type || '').toLowerCase();
      // Filter out settlements and bank transfers
      if (type === 'payment') {
        paymentCount++;
        const credit = parseFloat(row.credit || row.Credit || 0);
        totalRevenue += credit;
        
        let products = [];
        if (row.notes) {
          try {
            const parsedNotes = typeof row.notes === 'string' ? JSON.parse(row.notes) : row.notes;
            if (parsedNotes.product_name) {
              products = parsedNotes.product_name.split(',').map(p => p.trim()).filter(p => p);
            }
          } catch (e) {
            products = [row.description || 'Order'];
          }
        }
        
        const splitRevenue = products.length > 0 ? (credit / products.length) : credit;
        const finalProducts = products.length > 0 ? products : ['Misc'];
        
        finalProducts.forEach(prod => {
          if (!productCounts[prod]) {
            productCounts[prod] = { units: 0, revenue: 0 };
          }
          productCounts[prod].units += 1;
          productCounts[prod].revenue += splitRevenue;
        });
      }
    });
    
    return {
      revenue: totalRevenue,
      transactions: paymentCount,
      uniqueProducts: Object.keys(productCounts).length,
      productDetails: productCounts
    };
  } catch (error) {
    console.error("Failed to parse ZIP sales archive:", error.message);
    throw error;
  }
}

In the script code above, standard error-handling structures isolate processing failures. If a user drops a damaged archive or a sheet with missing columns, the try...catch block catches the exception, logs the details, and allows the interface to alert the user without crashing the event loop, ensuring stable dashboard operations.

Comparison of Payment Gateway Report Structures

To help choose the right reporting pipelines for your store, the table below compares standard data models used in payment processing and billing operations:

As indicated in the table, different versions of Razorpay dashboard exports use slightly altered headers depending on whether you download a raw transactions list or a payment page specific report. A robust parsing engine must check for these variants, mapping both lowercase and capitalized keys (e.g., credit versus Credit) to avoid missing revenue data columns.