Automating a protected ticket booking flow up to payment

A client needed several accounts to reach checkout on a ticketing site the moment an event opened, with seats kept in pairs and sections tried in priority order. The site uses a slider human-verification challenge that most people pay a solving service to pass. I handled it in-house and built the automation to stop at a filled payment form, so a person confirmed every purchase.

Role

Sole engineer: reverse engineering and automation

Stack

Python, Selenium (undetected-chromedriver, selenium-wire), Telethon

Type

Protected sources

Status

Private client engagement (2024). Client and site details are confidential.

account 1account 2account 3account 4account 5booking flowdate · section prioritypaired seatsverification steppayment form filledstops herea person confirmsparallel sessions · Telegram status updates · human hand-off at payment
  1. Problem

    Automate a protected ticket booking flow up to the payment step.

  2. Constraints

    A multi-step, stateful flow with protections and timing constraints.

  3. Approach

    Model the flow as a state machine, with operator handoff where a person must act.

  4. Result

    A working flow up to payment, handed over with operator instructions.

What the client needed

Tickets for popular events on this site sold out within minutes of opening. The client had several accounts and wanted each one to get to checkout with the best available seats, in pairs, as soon as the event link went live. Doing that by hand across several accounts at once wasn’t realistic.

We agreed early on that the automation would stop at the payment page. A person would review the seats and the total and confirm payment. That kept a human in control of every purchase, and it shaped how “success” is defined below.

What made it hard

  • A verification challenge before seat selection: a slider puzzle of the kind usually handed to a paid solving service, at a cost per attempt and with an outside dependency that can fail at the worst moment.
  • Choosing seats under time pressure. Sections have a priority order. Seats must stay in pairs. If a section runs out, the automation has to move to the next one without starting over.
  • Several accounts at once, each needing its own isolated browser session.

The flow, as a state machine

Per-account flow (the verification step is deliberately opaque)
[read config every 60s] -> event link posted to the account's channel?
     no  -> wait for the next pass
     yes -> start a worker (up to 5 accounts in parallel)

INIT -> LOGIN -> SELECT_DATE (preferred date | backup date)
  -> SELECT_SECTION (priority 1..20, skip "unavailable")  --none left--> EXIT
  -> [ verification challenge: handled in-house ]
  -> SELECT_SEATS (pairs within a row, or any N if singles allowed)
        |-- fewer than N held --> close seat map,
        |                         drop this and higher priorities,
        |                         back to SELECT_SECTION
        '-- N held --> CONFIRM_SEATS -> CHECKOUT (read total)
  -> PREFILL_PAYMENT (stop: no final submit)
  -> record account+event -> notify the operator -> person pays

Decisions

Understand the challenge instead of renting a solver. I spent the time to understand how the slider check worked in this specific flow, which made a paid solving service unnecessary. That removed a per-attempt cost and a third-party failure point. I won’t describe the method: it belongs to the client engagement, and publishing it would only help someone abuse the same site.

Section priority with memory. The client listed up to 20 sections in order of preference. When a section can’t supply enough seats, the automation closes the seat map, removes that section and every higher-priority one from the account’s list, and moves on. It never retries a section it already found short.

Pairs within a row. Available seats are read from the seat map grid. Each row is scanned left to right and split into adjacent pairs; a party of four gets two pairs from the same row. Candidate sets are ranked by how many consecutive seat numbers they contain, and then shuffled, which spreads parallel accounts across different seats instead of having all five reach for the same ones.

Synthetic values · real field names Seat selection, worked example
Row A, available columns: 1 2 3 . 5 6        party size N = 4
pairs found (scan skips ahead by 2):  (1,2)  (5,6)      seat 3 left over
2 pairs x 2 seats = 4  ->  candidate {A1, A2, A5, A6}

N = 2  ->  candidates {A1, A2} and {A5, A6}, tried in shuffled order

Isolation per account. Each account runs in its own thread with its own browser and cookies, and optionally its own upstream proxy. A crash in one account’s thread is logged and doesn’t affect the others.

Event links from a channel. Instead of polling the site for an event to open, the automation watches a private Telegram channel per account. When the operator posts the link, that account starts on the next pass. It then sends “please complete the transaction for this account” three times, five minutes apart, so the person paying doesn’t miss it.

Delivery and operator handoff

The workflow takes each account through seat selection to checkout, with a clear handoff for the operator to review and confirm payment:

Evidence at each stage
Stage What the automation observes
Seat clicked The page’s own seat-select function ran without an error
Seats held by the server The checkout page loaded with a total for those seats
Payment details entered The payment form is filled and the consent box ticked
Booking completed Operator reviews the seats and confirms payment.

The delivered workflow handles login, date and section priorities, verification, paired seat selection, and payment-form preparation across up to five accounts in parallel. Final payment stays with the operator, as agreed in the project scope.

Proof

Private client engagement

  • Delivered working flow with operator instructions.
  • Site and client are confidential.

Good to know

  • Stops before payment by design; a person completes payment.
  • Verification steps are handled with existing tools or by a person.
Next step

Have a workflow that was built to resist automation?

Describe the flow and where a person should stay in control. I'll tell you whether it can be automated within the site's rules and the law.