How to Build and Use Labubu Bot to Buy Drops Faster

Collectible Labubu figures from Pop Mart have become highly sought after not only by art fans but also by resellers. Limited drops sell out in seconds, making manual orders virtually impossible. In an environment of intense competition, many users turn to automation – using a Labubu bot that can complete purchases much faster than a human. Below, we explain the role of such bots, what tasks they perform, and key considerations of how to get a bot to buy Labubu.

What Is a Labubu Bot and Why It’s Used to Buy Rare Drops

A Labubu bot is a specialized script or application that automatically monitors the availability of figures, adds them to the cart, and completes the purchase. Its primary purpose is to speed up the buying process and eliminate issues caused by human factors, such as delays, errors, or payment timeouts.

Key features of such bots include:

• monitoring product availability on target store pages;
• instant cart addition when the item appears in stock;
• automated checkout, including address and payment entry;
• bypassing anti-bot systems by using proxies and IP rotation.

The scale of demand for these figures has reached a point where even English-language Reddit communities exist, with threads and groups for sharing successful purchase experiences and drop notifications.

A Labubu purchase bot is used by both arbitrage professionals and resellers, as well as by collectors who do not want to miss rare releases.

How to Use a Bot for Labubu Key Features and Limitations

Using it requires an understanding of both its functionality and the restrictions imposed by online stores. The primary purpose of this tool is to accelerate the order process and bypass manual steps, but its effectiveness depends directly on correct configuration and attention to technical details.

Before getting started, it is important to define key parameters: the target store for the purchase, site requirements, and the timing of scheduled drops. Typically, the bot operates according to a standard workflow – monitoring product availability and proceeding to instant checkout when the item appears.

Online retailers actively combat automation by employing captchas, behavioral analysis, IP filtering, and browser fingerprinting. Therefore, technical masking is essential in advance. For a Labubu bot to run reliably and avoid being blocked, it must be adapted to the platform’s protection mechanisms and configured accordingly.

Key Aspects of Configuration

Addressing these factors significantly improves bot performance and the likelihood of achieving the desired outcome. The following measures are recommended:

• choose high-quality proxy servers – preferably dynamic residential or mobile proxies. Their main advantages are high trust scores, rotation, and the availability of large IP pools, which ensure balanced request distribution;
• integrate anti-captcha services, such as 2Captcha or CapMonster;
• set delays between actions to mimic real user behavior;
• limit the number of simultaneous threads.

Beyond technical settings, it is also important to consider behavioral restrictions. Online stores may cancel orders – even after payment – if unusual activity is detected. Keep in mind that the Labubu bot alone does not guarantee success, especially when drops last only a few seconds or access is geographically restricted. It is advisable to test the bot in advance on less popular items and monitor drop schedules via channels like Telegram or Discord. Utilize up-to-date scripts and regularly adapt them in response to website changes.

The Best Labubu Bot: How to Choose the Right Solution

The best is not always the fastest one, but rather the tool best adapted to the specific store. Choosing the right solution depends on the purchase scenario and the user's technical skills. Custom-made scripts require in-depth technical knowledge but offer greater flexibility. Turnkey solutions are easier to use but may not always fit the requirements of a particular marketplace.

Competent use of any bot increases the likelihood of timely order placement, but it requires accuracy, attention to detail, and an understanding of potential consequences – both technical and related to store policies.

Examples of Ready-Made Solutions for Labubu Purchases

Most of these tools are paid, support Pop Mart drops, and require careful configuration. They are a practical choice for users who do not wish to develop their own scripts but want to automate the process without in-depth technical preparation.

Current solutions for purchasing Labubu figures include:

1. NSB Labubu Bot – an extension of the popular NikeShoeBot, adapted for Pop Mart drops. Supports automated checkout and proxy integration.
2. Stellar AIO – a bot with universal architecture and a Pop Mart module. Ideal for users seeking quick setup and multi-platform compatibility.
3. The Shit Bot (TSB) – utilized to automate the purchase of limited-edition collectibles, including Pop Mart. Offers basic region support and captcha bypass.
4. Cybersole – recognized as one of the most stable bots with extensive regional support for Pop Mart. Features auto-fill, proxy rotation, and advanced analytics.
5. Popmart Accounts – not a bot in the traditional sense, but a service for preparing verified Pop Mart accounts. Often utilized alongside bots to avoid limits and bans.
6. Kodai – an advanced solution focused on speed and script flexibility, supporting a range of platforms and offering fine-tuned Pop Mart automation.

How to Create a Labubu Bot Using Python

This guide explains how to build an asynchronous Python bot that monitors Pop Mart for new releases, searches for Labubu figures, adds them to the cart, and sends notifications about each action to Discord.

Step 1: Environment Setup

At this stage, you will install Python and the required libraries for browser automation and Discord messaging.

Python Installation:

1. Download from https://www.python.org/downloads/.
2. During installation, make sure to select “Add to PATH” so Python can be utilized from the command line.

Project Initialization:

mkdir labubu_bot
cd labubu_bot
python -m venv venv
source venv/bin/activate  # For Linux/macOS. If Windows - insert: venv\Scripts\activate

This creates an isolated environment for convenient dependency management.

Dependency Installation:

pip install playwright aiohttp
python -m playwright install

Playwright is utilized for browser control, while aiohttp handles Discord messaging.

Step 2: Project Directory Structure

Here is a recommended way to organize your project files. It is best to keep the suggested filenames and place the code for each step in the appropriate part of this tree. Such structure helps maintain readability, reusability, and ease of maintenance as your project grows:

labubu_bot/
  ├── bot.py        # Sends messages to Discord
  ├── scraper.py    # Scrapes new releases from Pop Mart
  ├── config.json   # Webhook and proxy configuration
  └── main.py       # Main monitoring loop

Step 3: Creating config.json

Sensitive data should be stored in a separate configuration file, rather than hard-coded in your scripts. The config file example:

{
  "discord_webhook": "https://discord.com/api/webhooks/YOUR_ID/YOUR_TOKEN",
  "proxy": {
    "server": "http://proxy.example.com:port",
    "username": "user",
    "password": "pass"
  },
  "active_hours": [10, 11, 12, 13, 14]
}

Note: active_hours is a list of hours (system time) when the bot will be active.

How to Get Your Own Discord Webhook

To do this:

1. Log in to Discord.
2. Open your server.
3. Right-click the desired channel.
4. Select “Edit Channel”.
5. Navigate to the “Integrations” tab, then “Webhooks”.
6. Click “Create Webhook”, assign a name, and copy the URL.
7. Paste this URL into the discord_webhook field.

Step 4: Creating scraper.py

The following block is responsible solely for scraping (collecting product data). Here, proxy rotation and User-Agent randomization are used to minimize the risk of blocking. By default, the bot tracks all products whose names contain the word “Labubu.” If you want to monitor only specific models or releases, modify the code to specify a list of exact product names (for example: Labubu Strawberry, Labubu Wizard, etc.).

Note: The example below uses a small set of basic User-Agent strings. Such values can be easily flagged as automated by anti-bot systems. It is recommended to expand the list with more unique variants or utilize browsers that support fingerprint emulation (such as Playwright with custom settings or tools like puppeteer-extra-stealth).

For actions requiring authentication (e.g., adding items to the cart), a separate stable session will be utilized (see below).

import json
from playwright.async_api import async_playwright
import asyncio
import random

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/114.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 Version/15.1 Safari/605.1.15",
    "Mozilla/5.0 (X11; Linux x86_64) Gecko/20100101 Firefox/113.0"
]

async def scrape_labubu(proxy):
    results = []
    try:
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=True,
                proxy={"server": proxy["server"]} if proxy else None)

            context = await browser.new_context(
                proxy=proxy if proxy else None,
                user_agent=random.choice(USER_AGENTS)
            )
            page = await context.new_page()
            await page.goto("https://www.popmart.com/us/new-arrivals", timeout=30000)

            cards = await page.query_selector_all("div.index_productCardCalendarContainer__B96oH")
            for card in cards:
                try:
                    await asyncio.sleep(random.uniform(1, 3))  # random delay
                    title_el = await card.query_selector("div.index_title__9DEwH span")
                    title = await title_el.text_content() if title_el else ""
                    if "labubu" not in title.lower(): # Replace this condition if you need to track only specific names (e.g., 'Labubu Strawberry')
                        continue
                    href = await card.query_selector("a[href^='/us']")
                    url = await href.get_attribute('href')
                    results.append({"title": title, "url": f"https://www.popmart.com{url}"})
                except Exception as inner_err:
                    print(f"❗️ Card is missing: {inner_err}")  # If a card throws an error, the bot skips it and continues processing others
            await browser.close()
    except Exception as e:
        print(f"Scraping error: {e}")

    return results

# ---------- ADD TO CART via an authenticated session ----------

async def add_to_cart(product_url, storage_file="auth_state.json"):
    try:
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=False)  # launch in visible mode for debugging
            context = await browser.new_context(storage_state=storage_file)
            page = await context.new_page()
            await page.goto(product_url, timeout=30000)
            await page.wait_for_selector("button[aria-label='Add to bag'], button:has-text('ADD TO BAG'), button[class*='add'], button[class*='buy'], div[class*='btn'][class*='add'], div[class*='btn'][class*='buy'], div[class*='btn'][class*='red']", timeout=10000)
            await page.click("button[aria-label='Add to bag'], button:has-text('ADD TO BAG'), button[class*='add'], button[class*='buy'], div[class*='btn'][class*='add'], div[class*='btn'][class*='buy'], div[class*='btn'][class*='red']"), button[class*='add'], button[class*='buy']")
            await asyncio.sleep(2)
            await browser.close()
            return True
    except Exception as e:
        print(f"❌ Failed to add to cart: {e}")
        return False

This script searches for products with “Labubu” in the name on the new arrivals page and returns a list of matches. Added features:

• User-Agent rotation support;
• proxy support;
• random delays;
• error handling for each product card.

Step 5: Creating bot.py

import aiohttp
import json

async def notify_discord(webhook_url, message):
    async with aiohttp.ClientSession() as session:
        await session.post(webhook_url, json={"content": message})

This function sends a message to a Discord channel using a webhook.

Step 6: Creating main.py

At this stage, the script logic is implemented: it first searches for Labubu products, and if needed, adds them to the cart via an authenticated session (using the auth_state.json file).

This file is created after a one-time manual login to Pop Mart using Playwright—instructions for this are provided below.

This block handles the core monitoring logic. The Discord channel will receive notifications when:

• an item is found;
• nothing is found;
• a check error occurs;
• the monitoring loop starts;
• the current time is outside the defined active_hours.

import asyncio
import json
from datetime import datetime
from scraper import scrape_labubu
from bot import notify_discord

with open("config.json", encoding="utf-8") as f:
    config = json.load(f)

proxy = config.get("proxy")
discord_webhook = config["discord_webhook"]
active_hours = config.get("active_hours", list(range(24)))

async def run():
    await notify_discord(discord_webhook, "✅ Bot started. Beginning Labubu monitoring..."
    while True:
        now = datetime.now().hour
        if now in active_hours:
            await notify_discord(discord_webhook, f"✅ Check started at {now}:00")
            try:
                products = await scrape_labubu(proxy)
                if products:
                    from scraper import add_to_cart
                    for item in products:
                        msg = f"Labubu found: {item['title']}\n{item['url']}"
                        await notify_discord(discord_webhook, msg)
                        success = await add_to_cart(item['url'])
                        if success:
                            await notify_discord(discord_webhook, "Added to cart.")
                        else:
                            await notify_discord(discord_webhook, "⚠️ Failed to add to cart.")
                else:
                    await notify_discord(discord_webhook, "❌ No Labubu found.")
            except Exception as e:
                await notify_discord(discord_webhook, f"Error: {e}")
                else:
            await notify_discord(discord_webhook, f"{now}:00 -- Time outside active_hours. Bot paused.")

        await asyncio.sleep(60) # check every minute

if __name__ == '__main__':
    asyncio.run(run())

Note: The loop checks the site every minute, but only during the hours specified in active_hours.

Additional: How to Save an Authenticated Session (auth_state.json)

For the bot to add items to the cart on your behalf, you first need to save an authenticated session.

1. Launch a manual login using Playwright:

   
   from playwright.sync_api import sync_playwright
   
   with sync_playwright() as p:
       browser = p.chromium.launch(headless=False)
       context = browser.new_context()
       page = context.new_page()
       page.goto("https://www.popmart.com/us/login")
       print("Log in to your account manually...")
       input("Press Enter after login...")
       context.storage_state(path="auth_state.json")
       browser.close()
   

2. This opens a browser window where you should log in to your Pop Mart account. Perform these actions slowly to avoid triggering anti-bot systems; this helps prevent captchas when the bot uses the saved session for cart operations.
3. After logging in and pressing Enter, the session will be saved to auth_state.json.
4. Do not delete this file. The bot will utilize it in add_to_cart() to perform actions as if you were logged in.

Otherwise, the Pop Mart site may detect bot activity and discard the session, causing the cart operation to fail.

Step 7: Launch

Use this command to start the monitoring loop:

python main.py

Done!

Once the target product is found, the bot switches to the authenticated session. It uses this session to open the page and press the “ADD TO BAG” button. All actions after scraping are performed with the saved Pop Mart session. After that, you can log into your account manually and complete the purchase – the item will already be in your cart. This approach is more reliable and straightforward, as manual payment carries less risk of failure.

It is also recommended to review resources on fixing syntax errors in Python.

When to Expect Drops: Estimated Labubu Release Times

Labubu drops occur at different times in different regions. Based on user observations on Reddit and Telegram, an approximate schedule can be outlined:

These are unofficial times but serve as useful reference points. Drops often coincide with weekends, holidays, or major Pop Mart marketing campaigns.

Tips for tracking:

• Subscribe to store push notifications;
• Monitor Pop Mart’s Twitter accounts;
• Watch Reddit threads: r/vinyltoys, r/popmart;
• Utilize Discord bots and Telegram channels.

The bot described here checks the “New Arrivals” section daily, making it easy to determine when drops are most likely to occur based on Discord notifications.

Conclusion

A Labubu bot is a tool that increases the chances of purchasing collectible figures. In addition to building a solution in Python, using such a bot requires proper configuration, understanding drop specifics, and awareness of associated risks. In a highly competitive environment, automation becomes essential – especially when it comes to rare Pop Mart releases.

Regardless of whether you utilize a custom script or a ready-made solution, correct bot configuration helps ensure that drops are not missed and purchases are successful, minimizing human error and saving valuable time.