📊 Razorpay Product Sales Counter

Introduction to Transaction Data Auditing and Sales Counting

In the modern e-commerce landscape, payment gateways play a critical role in bridging the gap between digital storefronts and merchant banking systems. Among these, Razorpay has emerged as a dominant payment processing platform, especially in emerging markets, allowing millions of online businesses to accept payments via credit cards, UPI, net banking, and digital wallets. However, as transactions grow, developers and online sellers are faced with the challenge of analyzing raw transaction logs. Exporting payment histories or receiving real-time webhook payloads frequently results in unstructured or complex data structures, specifically when multiple products are bundled or purchased under a single invoice. Often, these products are stored as a single, comma-separated string under a unified database property (such as product_name).

When multiple products are packed into a single string (for example, "Product A, Product B, Product C"), standard business intelligence dashboards and spreadsheet software like Microsoft Excel or Google Sheets treat the entire string as a single unique product entity. This leads to major analytical errors, as the system fails to count "Product A" individually when it is bought as part of a bundle. To get accurate statistics on product performance, businesses need to parse the export row by row, split these comma-separated strings into individual arrays, and accumulate counts for each item. Utilizing an automated clientside tool like our Razorpay Product Sales Counter allows sellers to perform this parsing locally in the browser event thread, safeguarding private financial transactions and customer directories from external servers while generating accurate unit-level metrics in milliseconds.

Analyzing product sales counts is particularly important for optimizing supply chain operations, inventory restocks, and marketing campaigns. If a business runs bundles containing multiple products, they need to know the raw volume of each specific item shipped. A high-level overview that does not break down the contents of commas-separated lists leaves managers blind to actual demand. Standardizing these exports via immediate parsing exposes true inventory depletion rates, keeping warehousing aligned with buyer habits.

The Evolution of Razorpay and Online Payments in India

To understand the context of Razorpay's data exports, 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.

The Mathematical and Algorithmic Logic of JSON Line Parsing

To process bulk transaction logs, data systems use specific parsing algorithms. The input format typically processed by our sales counter is known as JSON Lines (JSONL), where each line of text represents a standalone, valid JSON object. This structure is highly popular in logging pipelines because it allows databases to append new transaction records sequentially without needing to rewrite a huge global array structure.

The core algorithm of our counter follows a structured sequence of operations:

1. Line Splitting: The raw input string is split by newline characters (\n) to isolate each individual transaction record.
2. JSON Parsing: Each non-empty line is parsed using the standard JSON.parse() method. If a line is malformed, it is skipped with a console warning to ensure the entire execution doesn't crash.
3. String Splicing: The script extracts the product_name property. If the property exists, it is split into an array of substrings using the comma (,) delimiter.
4. Deduplication and Normalization: Each product name is trimmed of leading or trailing whitespace to ensure spelling variations like "Product A " and "Product A" merge into a single entity.
5. Hash Map Accumulation: A Dictionary (or Hash Map) is updated where the keys are the normalized product names, and the values are their total sales occurrences.
6. Descending Sorting: The map is converted to an array of key-value pairs and sorted descending by sales count.

Let's look at an example. If the input contains three lines of JSON objects: {"product_name":"A, B"}, {"product_name":"A"}, and {"product_name":"A, B"}, the parser splits and normalizes the values into the array ['A', 'B', 'A', 'A', 'B']. The resulting hash map shows: {'A': 3, 'B': 2}. This transparent division represents the core model of our sales counter, delivering instant product metrics.

From the perspective of computational complexity, the parsing algorithm runs in O(N × M) time, where N is the number of transaction lines and M is the average number of comma-separated items per line. Because both operations are linear and simple string matches, modern JavaScript engines like V8 compile and execute this processing in fractions of a millisecond. This makes browser-based clientside parsing highly practical even for logs containing thousands of rows.

A JavaScript Script to Parse and Count Product Sales Programmatically

For software developers designing backend processing routines, webhook handlers, or automated reports, parsing transaction payloads programmatically is a critical requirement. The following JavaScript program demonstrates a clean, reusable Node.js script that reads a multi-line JSON stream, splits comma-separated items, and outputs an organized breakdown of sales metrics complete with basic error logs for invalid lines:

function parseRazorpaySales(jsonLinesText) {
  const lines = jsonLinesText.split(/\r?\n/);
  const salesMap = {};
  let processedOrders = 0;
  let skippedLines = 0;
  
  lines.forEach((line, index) => {
    const trimmedLine = line.trim();
    if (!trimmedLine) return; // Skip empty lines
    
    try {
      // Parse the JSON string
      const order = JSON.parse(trimmedLine);
      
      if (order && typeof order.product_name === 'string') {
        processedOrders++;
        
        // Split comma-separated names and trim whitespaces
        const products = order.product_name.split(',')
          .map(p => p.trim())
          .filter(p => p.length > 0);
          
        // Accumulate in hash map
        products.forEach(product => {
          salesMap[product] = (salesMap[product] || 0) + 1;
        });
      } else {
        skippedLines++;
      }
    } catch (err) {
      console.warn(`Skipping malformed line ${index + 1}: ${err.message}`);
      skippedLines++;
    }
  });
  
  // Convert map to sorted array
  const sortedSales = Object.entries(salesMap)
    .sort((a, b) => b[1] - a[1])
    .map(([name, count]) => ({ productName: name, unitsSold: count }));
    
  return {
    ordersProcessed: processedOrders,
    linesSkipped: skippedLines,
    uniqueProducts: sortedSales.length,
    salesBreakdown: sortedSales
  };
}

// Example evaluation with simulated data
const sampleInput = `{"product_name":"Detergent, Fabric Softener, Sponge"}
{"product_name":"Detergent"}
{"product_name":"Sponge, Fabric Softener"}
{"product_name":"Detergent, Sponge"}`;

const report = parseRazorpaySales(sampleInput);
console.log("Orders Processed successfully:", report.ordersProcessed);
console.log("Unique Products Found:", report.uniqueProducts);
console.log("Sales Report:", report.salesBreakdown);
// Output:
// Orders Processed successfully: 4
// Unique Products Found: 3
// Sales Report: [
//   { productName: 'Detergent', unitsSold: 3 },
//   { productName: 'Sponge', unitsSold: 3 },
//   { productName: 'Fabric Softener', unitsSold: 2 }
// ]

In this script, the parseRazorpaySales function handles exceptions using a try...catch statement. This is critical in production environments, as raw exports often contain metadata lines, total summary statistics, or corrupted rows that fail standard JSON parsing rules. Skipping these gracefully ensures that the entire batch processes successfully.

Additionally, we must emphasize DOM security. In our online tool, the product names are escaped using HTML entity replacement before they are rendered to the screen. If we directly inserted the product names as HTML, a malicious transaction containing script tags could execute arbitrary code in the user's browser, leading to a Cross-Site Scripting (XSS) vulnerability. Sanitizing inputs ensures secure data operations.

Data Formats and Payment Gateways Analysis

To help choose the right transaction format for your business, the table below compares standard data models used in payment processing and billing operations:

As indicated in the table, JSON Lines (JSONL) strikes an optimal balance between scalability and parsing simplicity. Unlike standard JSON arrays which require the parser to load the entire document into memory before analyzing the first record, JSONL files can be processed line-by-line. This is particularly valuable for large e-commerce platforms handling millions of orders, where processing large files in memory would otherwise trigger out-of-memory errors on server instances.