Skip to content
See pricingGet started free

Stop matching UTRs by hand. Loop Trade approves every deposit.

Loop Trade reads your payment gateways, matches each deposit by UTR and amount, and approves it in seconds. Your team only sees the exceptions.

Matching engine
0 cleared

Gateway feed

  • Google Pay

    New
    UTR402188731592₹24,500

Pending requests

    A payment lands in the gateway feed.

    2.5s

    Match loop

    30s

    Capture

    24×7

    Uptime

    A demo run of the matching engine. Amounts and references are sample data.

    Checks every payment method your desk takes money on

    • Google PayUPI
    • Bank portalUPI
    • Bank portalIMPS
    • Bank portalNEFT
    • Trader platformTwo-way sync

    Checking payments by hand fails at the worst possible moment.

    Deposits land in one system. The approval queue lives in another. Keeping the two in agreement takes a person, two screens, and all day.

    • Someone has to watch the gateways

      Payments arrive in Google Pay and your bank portals. The queue waiting to be approved is somewhere else entirely.

    • Any hour can be a peak hour

      Deposits spike when the market is busy. A short shift turns an ordinary day into a backlog.

    • Matching by eye is fragile

      Twelve-digit UTRs, near-identical amounts, the same sender paying twice. A transposed digit is invisible on a tired screen.

    • Reused references slip through

      Someone submits the same UTR again with a different amount. This is a common abuse, and it is very hard to catch by hand.

    • Nobody sees the whole picture

      How much came in today, how much is still pending, which gateway is underperforming. The answers arrive hours late, assembled by hand.

    • Rejections stall

      An unmatched request waits until someone remembers to decline it. Until then, both the client and your desk keep waiting.

    Five stages, always running.

    Nothing in the normal flow needs a person. Each stage runs on its own, so a slow gateway page never delays an approval.

    1. 1Capture

      Loop Trade continuously reads the transaction lists from each configured gateway: Google Pay and your bank portals.

      • Extracts UTR, amount, sender name and sender detail from every row
      • Runs many gateways in parallel across a small pool of browser tabs
      • Keeps one persistent, logged-in session per site
      • Keeps each payment method separate, so a UPI payment is never matched against a bank transfer
    2. 2Match

      A dedicated matching engine compares incoming payments against the pending deposit queue, keyed on UTR and amount together.

      • Runs on its own tight loop, independent of the browsers
      • Never matches on amount alone
      • Deduplicates on capture and again on match
      • Keeps synthetic resubmission references out of real payment counts
    3. 3Decide

      A verified match is approved immediately. A request that never receives a matching payment is auto-rejected when its timeout expires.

      • Auto-approve the instant a verified match exists
      • Auto-reject after a configurable timeout
      • Verify the result on the platform before writing it to the database
      • Hold anything unclear for a human instead of guessing
    4. 4Sync

      Approvals and rejections are mirrored onto the trading platform, and decisions your team makes there are read back into the dashboard.

      • The platform status always wins, the dashboard follows it
      • Team decisions made on the platform are imported automatically
      • New entries found on the platform are created in the dashboard
      • No divergence, and no question of which system is right
    5. 5Report

      Every event streams into a live dashboard: payments received, requests processed, automation rate, gateway performance and profit or loss.

      • Live streaming dashboard, sub-second on events
      • Daily ledger grouped by day and by gateway
      • Profit and loss across today, this week, this month and all time
      • Complete audit log with the actor and timestamp on every change

    The whole operation on one screen.

    Today's numbers by default, streaming in as events happen. No refresh, no spreadsheet, no waiting for a shift report.

    Requests today

    1,284

    +6.2% over yesterday

    Approved

    1,171

    91.2% auto

    Pending

    42

    held for review

    Rejected

    71

    no payment found

    Live activity
    • Approved

      Approved automatically

      Google Pay · UTR 4021 8873 1592

      ₹24,500

      Rohit S.

    • Approved

      Approved automatically

      Bank (IMPS) · UTR 7710 4438 2201

      ₹8,000

      Ananya M.

    • Held

      Held for review

      Same UTR seen with a different amount

      ₹1,25,000

      Imran K.

    • Approved

      Approved automatically

      Bank (UPI) · UTR 9128 0043 7712

      ₹4,999

      Priya N.

    • Rejected

      Auto-rejected on timeout

      No matching payment within 5 minutes

      ₹60,000

      Sana R.

    Illustrative preview of the live dashboard.

    Everything the desk was doing by hand.

    Capture, matching, approval, sync and reporting, in one engine that runs whether or not anyone is watching.

    Two keys, one decision

    A payment is matched only when the UTR and the amount agree. Amount alone is never sufficient evidence.

    UTR

    4021 8873 1592

    Amount

    ₹24,500

    Both agree, so the match is confirmed

    ~2.5s matching loop

    The matching engine runs on its own tight loop, deliberately separated from the browsers.

    2.5s

    Parallel capture

    Many gateways read at once across a small pool of tabs, each with its own persistent session.

    Approve and reject

    Verified matches approve instantly. Unmatched requests time out on their own, so nothing stalls.

    Verify before persist

    The platform is checked before the database is written, so a record never says approved when it is not.

    Deposits and withdrawals

    The same engine drives withdrawal processing, with the same rules and the same audit trail.

    Two-way platform sync

    Decisions made here are mirrored there, decisions made there are read back here. The trading platform stays the source of truth.

    DashboardTrading platform

    Human in the loop

    Reused, mismatched and suspicious entries arrive pre-loaded with history for a reviewer.

    12 Aug₹18,000Approved23 Aug₹42,000HeldBoth pools₹30,000Flagged

    Two keys, not one.

    A payment is matched only when the reference and the amount both agree. Trusting one of them alone is how the wrong payment gets credited.

    Matching rule

    Unsafe

    Two clients paid the same amount. On the amount alone both look like a match, so the wrong one can be credited.

    Pending request

    ₹24,500UTR 4021 8873 1592

    two payments, one amount

    Held for a reviewer

    Neither row clears both keys on its own, so the engine will not settle it. A person decides which payment stands.

    • Pools stay separate. UPI is never cross-matched against IMPS or NEFT, even at an identical amount.
    • Nothing is guessed. Unclear or reused entries go to your team, with the full history.
    • A held row keeps its history, so the reviewer can see what was reused or mismatched before deciding.

    The exceptions that deserve a human.

    Automation should not mean blindness. Five cases always go to a person, and each one arrives with the full context ready.

    What the engine does

    Held for review, then auto-rejected if it times out.

    History attached to the row

    • 12 Aug₹18,000Approved against a Google Pay creditApproved
    • 23 Aug₹42,000Same reference, a much larger sumHeld

    The numbers the desk cares about.

    These are measured from the system as it runs. Check them against your own data during the demo.

    • Zero-touch resolution

      90%+

      Deposit requests resolved with no human involvement at all.

    • Matching loop

      2.5s

      Continuous comparison of payments against the pending queue.

    • Gateway capture

      30s

      Per gateway, read in parallel rather than one after another.

    • Unattended

      24×7

      Self-healing and supervised, with no per-transaction fee.

    Built to run for months without supervision.

    Reliability is not a feature list. It is what lets a 24/7 operation run without someone on standby.

    How we keep it running
    • Supervised processes

      Every component restarts automatically on failure, with backoff so a bad state cannot become a restart loop.

    • Self-healing watchdog

      Every minute it checks the screen, the browser, the web app and every worker. Anything that has stopped, it restarts.

    • Memory watchdogs

      Node and browser memory are watched and cycled before they become a problem, not after.

    • Circuit breakers

      Repeated gateway failures trigger a cooldown instead of a spin loop that burns the machine.

    • Persistent sessions

      Logins survive restarts. The browser is kept alive and reconnected to, never relaunched from cold.

    • Scheduled self-restart

      A daily restart at a quiet hour, with old logs and notifications pruned automatically.

    The full checklist, including data handling and audit, is on the security and reliability page. security and reliability page.

    What the manual queue costs you.

    Set your own numbers. The estimate assumes one person checks every request, which is exactly what Loop Trade removes.

    800

    Drag either handle to match your desk

    505,000
    2 min
    0.56

    Resolved with no human touch

    720

    requests per day, at a 90 percent zero-touch rate

    Held for a human instead

    80

    the genuine exceptions, reviewed with history attached

    Manual checking removed

    24 hper day

    about 720 hours a month

    Still manual

    2.7 h

    per day

    An estimate based on your own inputs, not a measured result. The demo is where we check it against real numbers.

    Questions the desk usually asks.

    If yours is not here, the demo is the fastest way to get a straight answer.

    What does Loop Trade actually connect to?
    Google Pay and your bank portals over UPI, IMPS and NEFT, plus your trading platform for two-way sync. Any gateway you can open in a logged-in browser session can be configured as a source.
    Does it approve payments without a human?
    Yes, for roughly nine in ten requests, and only when a payment matching both the UTR and the amount is sitting in a gateway. Anything unclear is held for a person instead of guessed at.
    What happens to a request that never matches?
    It stays pending until its configured timeout expires, then it is rejected automatically with the reason you set. The timer is anchored to a stored timestamp, so a restart does not reset it.
    How does it handle a reused or duplicate UTR?
    The entry is flagged and the full history is attached: when the reference was used before, for how much, by whom, and how it was resolved. A reviewer decides in seconds rather than investigating in minutes.
    Where does my data live?
    In a setup made for you alone. The application, the database and the browser sessions all run there, and a deploy never disturbs a live session because browser profiles are kept outside the application directory.
    What happens when a gateway page changes?
    Capture is isolated from matching, so a broken page stops new payments from arriving but never corrupts a match already in progress. Repeated failures trip a circuit breaker and raise an alert instead of retrying forever.
    Will it fight with decisions my team makes on the platform?
    No. The trading platform is treated as the source of truth in both directions. A decision made there is read back into the dashboard, and a decision made in the dashboard is mirrored onto the platform.
    How is it priced?
    Per deployment, scoped to your gateway count and daily volume. There are no per-transaction fees. Tell us your setup in the demo and we will quote it directly.

    Watch it clear your queue.

    Bring a day of real deposit activity to the demo. We will run it through the engine and show you exactly what it resolves on its own.