A sneaker bot checkout flow is the sequence of requests and decisions that takes a task from finding a product to submitting payment and receiving an order response. It sounds like one action, but a successful checkout can involve product data, inventory, sessions, queues, challenges, cart state, payment information, and retailer validation.
The Shit Bot is a sneaker bot and Nike SNKRS bot that also runs as a Pokémon Center bot and Pokémon bot.
The important bit is that checkout is a chain. Reaching the product page does not mean the pair is secured. Adding it to cart does not mean the pair is secured either. Even an order confirmation can still be followed by retailer checks and, in some cases, cancellation.
Here’s the simplified flow:
| Stage | What Happens | Does It Mean You Copped? |
|---|---|---|
| Product detection | Bot identifies the product or stock | No |
| Variant selection | Correct size or SKU is targeted | No |
| Session preparation | Cookies, tokens, account and network state continue | No |
| Queue/challenge | Retailer controls or verifies access | No |
| Cart | Inventory is requested or placed in cart | No |
| Checkout | Shipping, billing and payment data are submitted | No |
| Validation | Retailer/payment systems evaluate the order | Not yet |
| Confirmation | Retailer accepts the order request | Usually a W, but cancellation can still happen |
What Happens During a Sneaker Bot Checkout?
A sneaker bot checkout automates some or all of the actions a shopper would normally take from discovering a product to submitting an order.
That can include requesting product information, selecting a size, maintaining a session, entering a queue, passing required verification, carting the item, submitting checkout information, and waiting for the retailer’s response.
How it performs those actions depends on the bot and retailer. As we explained in our browser-based vs request-based sneaker bots guide, a browser-based bot controls a browser while a request-based bot communicates more directly with retailer servers.
Different route, same basic objective: move a valid shopping session through the retailer’s purchase flow.
And that starts before checkout itself.
Step 1: Product Detection
Product detection is the point where a task recognizes that the item it is targeting is available or has changed into a state where the purchase flow can begin.
A bot needs something concrete to target. Depending on the retailer, that might be a product URL, SKU, product identifier, variant, release information, or data returned by the retailer.
This is also why sneaker monitors and bot tasks are related but not identical. A monitor can detect a change quickly, while the checkout task still has to act on that information.
For scheduled releases, much of this can be prepared beforehand. Shock drops are different because the public discovery window is compressed. Our guide to how sneaker shock drops work explains that surprise timing does not determine the checkout mechanic itself. A sudden release can still use FCFS, a queue, a draw, or another allocation system.
Finding the product is only the trigger.
Step 2: How Does the Bot Know Which Size to Buy?
Variant selection maps the task’s target to the actual purchasable option offered by the retailer.
A product page might represent one sneaker, but the retailer still has to distinguish a US 9 from a US 10.5. Each available size may therefore be represented by its own product or variant data.
The task needs to select something that actually exists and is available.
TSB’s current Nike task configuration guide, for example, lets users configure the SKU/product and choose a specific size, multiple sizes, a range, or Random Available depending on the task configuration.
That choice happens before a successful purchase can move forward.
If size 10 disappears while size 11 remains available, a task configured only for size 10 cannot simply assume that another size is acceptable. The checkout flow has to follow the rules configured for that task.
Step 3: Why Do Sessions, Cookies, and Tokens Matter?
A session connects separate retailer requests into one continuing shopping flow.
HTTP requests are separate by default. Retailers therefore use state to recognize that the shopper who accessed a product is also the shopper moving toward cart and checkout.
Cookies can carry stored state. Authentication data can establish account access. Challenge tokens can prove that a required verification step was completed. The retailer may also maintain server-side state that the bot never directly controls.
We broke those layers down in our guide to sneaker bot sessions, cookies, and tokens.
That continuity matters because a sneaker bot checkout flow can have perfectly valid product information and still fail if the session behind it is no longer valid.
Think of the checkout as a conversation. Product detection might be one message, carting another, and payment another. If the retailer stops recognizing that they belong to the same conversation, the next step can fail even when the previous one worked.
Step 4: What Happens If There Is a Queue or CAPTCHA?
Queues and challenges are checkpoints that can sit between product access and checkout.
A queue controls access when a retailer needs to manage demand. Getting through one does not reserve a pair by itself. TSB’s sneaker queue explainer shows why queue position and successful checkout are separate things: stock and order validation still matter after access is granted.
CAPTCHAs work differently.
Modern CAPTCHA systems can evaluate browser, network, session, and behavioral signals before deciding whether extra verification is necessary. Some challenges are visible. Others can happen in the background.
Our guide to CAPTCHAs on sneaker websites breaks that process into request, evaluation, challenge, verification, and validation.
So there is no universal rule saying every task goes product → cart → payment.
One retailer might insert a queue. Another might require verification. A task can encounter several checkpoints before it ever reaches cart.
Step 5: Does Adding a Sneaker to Cart Mean You Got It?
No. Carting means the checkout flow has advanced, not that the retailer has completed the order.
This distinction matters during limited releases because inventory can change between requests. Other shoppers may be trying to purchase the same size while your task is moving through the next steps.
Retailer implementations also differ. A cart can represent a temporary shopping state without creating a guaranteed reservation.
So when a task status says it has carted a pair, that is useful information, but it is not the same thing as an order number.
The task still has to move the required checkout state forward, submit the necessary customer and payment information, receive valid responses, and survive whatever order validation the retailer applies.
Basically, ATC is progress, not a W.
And when stock is moving quickly, the next few requests can be the difference between checkout and an out-of-stock response.
Step 6: What Happens When a Sneaker Bot Reaches Checkout?
Checkout is where the task submits the information the retailer needs to attempt the purchase.
Depending on the store, that can include the selected product, shipping address, billing details, account information, delivery method, payment data, and existing session state.
The exact order varies.
A retailer might validate an address before payment. Another could create checkout state first and validate payment later. Some release systems also work differently from ordinary FCFS ecommerce.
That is one reason we should not treat a sneaker bot checkout flow as one giant request.
A task can successfully pass several checkout stages and then fail on the last one. That is why the actual error stage matters when diagnosing an L.
Our guide to why sneaker bot checkouts fail covers the common setup layers involved, including proxies, accounts, profiles, payment details, retailer responses, and timing.
Step 7: What Is the Retailer Checking Before Accepting the Order?
Retailer validation determines whether a submitted purchase request is accepted, rejected, challenged, or sent through another check.
Payment is only one part of that decision.
The retailer may need to confirm that inventory still exists, the checkout state is valid, the payment can be authorized, required fields match, and any release-specific rules have been satisfied.
Security systems can also evaluate traffic using multiple signals. TSB’s guide to how sneaker websites detect bots covers examples including request behavior, browser characteristics, session signals, IP reputation, JavaScript results, and network characteristics.
That helps explain a classic botting headache: two tasks can look almost identical in the UI but receive different results.
Their histories may not be identical at all.
One might have a healthy session and payment response. Another could be carrying stale state or hit a different retailer decision during the final request.
Step 8: Does Order Confirmation Mean the Checkout Is Finished?
An order confirmation means the retailer accepted the order into its system, but it does not necessarily mean every post-checkout check is finished.
From the bot’s perspective, this is usually the moment everyone wants to see. The retailer has returned a successful response, often with an order number or other confirmation state.
But there is a difference between checkout success and fulfillment.
Retailers can still review orders afterward. Purchase-limit enforcement, payment issues, address problems, inventory errors, and other checks can result in cancellation after the initial confirmation.
Our recent order cancellation guide covers that post-checkout stage in more detail.
So the cleanest way to think about the end of the flow is:
Product found → variant selected → session maintained → access cleared → cart created → checkout submitted → retailer accepts order → order survives post-checkout processing → shipment.
That last distinction saves a lot of confusion when a task shows success, but the retailer later emails an L.
Where Does a Sneaker Bot Checkout Usually Fail?
A failed sneaker bot checkout flow is easier to diagnose when you identify the last stage that definitely worked.
Saying “the bot failed” throws product detection, network access, sessions, carting, payment, and retailer validation into one bucket. Those are different problems.
| Last Successful Stage | Next Failure | What to Investigate First |
|---|---|---|
| Product detected | Cannot load product | Product data, availability, connection |
| Product loaded | Cannot select variant | Size/variant availability or task config |
| Session active | Access rejected | Session, challenge or retailer response |
| Queue entered | Cannot proceed | Queue state or availability |
| Product carted | Checkout fails | Checkout state, profile, connection |
| Checkout submitted | Payment rejected | Billing/payment response |
| Payment processed | Order rejected | Retailer validation or inventory |
| Confirmation received | Order cancelled | Post-checkout checks and retailer rules |
That sequence is more useful than changing everything after one L.
If ten tasks die before product access, payment probably is not your first problem. If they consistently reach checkout and fail at payment, changing the monitor configuration probably will not fix it either.
The stage tells you where to look.
So, What Is a Sneaker Bot Really Doing During Checkout?
A sneaker bot is moving a shopping task through a chain of retailer states faster and more consistently than doing every step manually.
There is no single magical “checkout request.” A real sneaker bot checkout flow can involve product detection, variant data, sessions, cookies, tokens, proxies, queues, challenges, cart state, customer information, payment processing, inventory checks, retailer validation, and post-order review.
And every stage depends on the previous stages being valid enough for the retailer to let the task continue.
That is why speed alone does not explain a checkout.
A task that reaches payment in 2 seconds but carries broken state can still lose to one that takes 5 seconds and completes the whole flow correctly. The W is not reaching checkout first. The W is making it through the entire chain and ending up with an order that sticks.
From Product Page to W: What the Checkout Flow Really Means
Understanding the full checkout flow makes every task status easier to read. And when that flow comes together, the result is what every botter is looking for: a successful checkout. TSB has seen plenty of success over the years, handling the steps between product detection and order confirmation. Knowing what is happening at each stage helps you make more sense of both the Ws and the Ls.
Your TSB key puts that checkout flow into practice. Once you know what is happening behind each task status, you are not just watching TSB work; you actually know what is happening between finding the pair and landing the W.
