Using Singapore mobile proxies with Browserbase in 2026

If you have been running Browserbase sessions against any Southeast Asian platform in the last year, you have probably noticed that the failure modes have gotten worse, not better. Shopee, Lazada, Grab, Singpass-gated flows, and even standard Google SERPs rendered from a Singapore locale are now applying stricter IP reputation checks at the TLS handshake layer, not just at the cookie or fingerprint layer. Browserbase gives you a managed headless browser that handles fingerprinting well, but it cannot fix the underlying problem of where the request appears to originate. That is the gap that Singapore residential mobile proxies fill. This post covers exactly how to wire them together.

why Browserbase hits walls without residential mobile IPs

The most common Browserbase setup routes egress through the platform’s own datacenter ranges or through a generic residential proxy pool, usually US or EU anchored. For most automation targets this works fine. For anything that cares about ASN reputation, carrier association, or geographic specificity at the subnet level, it breaks in ways that are genuinely hard to debug. The failures are silent. You get a 200 response with a CAPTCHA page body, or a redirect to a consent wall, or a completely different page variant than a real Singapore mobile user would see.

Browserbase sessions targeting e-commerce platforms in SEA hit two specific problems. First, platforms like Shopee and Lazada have invested heavily in IP reputation scoring that penalises datacenter ASNs even when the browser fingerprint is clean. A headless session coming from an AWS Singapore region IP is not treated the same as one from a SingTel mobile IP, regardless of how good your user-agent and canvas fingerprint are. Second, price and inventory APIs frequently return geo-segmented responses. If your scraping pipeline is trying to capture what a real Singapore mobile user sees, arriving from a US residential IP (or even a Singapore datacenter IP) produces a subtly wrong result that poisons your dataset without raising obvious errors.

The third problem is session continuity. Some workflows require holding a login session across multiple Browserbase sessions, and mobile carrier IPs have a stability advantage here. Rotating datacenter IPs will often trigger re-authentication challenges mid-workflow because the platform’s fraud model flags the IP class change. A sticky session on a real SingTel modem looks like a normal user who has not moved from their location, which is exactly what it is.

setting up SMP credentials in Browserbase

Singapore Mobile Proxy provides HTTP and SOCKS5 endpoints. For Browserbase, HTTP proxy is the right choice. Browserbase’s proxy configuration accepts a standard proxy URL, and SOCKS5 requires a different setup path that varies by SDK version. If you want to understand the tradeoffs between the two protocols before committing, the HTTP vs SOCKS5 mobile proxies comparison covers the latency and compatibility differences in detail.

SMP credentials come in the format ip:port:username:password. To use them in Browserbase via the Node SDK, construct a proxy URL from those components and pass it through the session creation options:

import Browserbase from "@browserbasehq/sdk";
import { chromium } from "playwright-core";

const bb = new Browserbase({ apiKey: process.env.BROWSERBASE_API_KEY });

// SMP credential components from your dashboard
const SMP_HOST = "your.smp.endpoint";   // the IP or hostname from your SMP panel
const SMP_PORT = 12345;                  // the port assigned to your modem
const SMP_USER = "your_username";
const SMP_PASS = "your_password";

const proxyUrl = `http://${SMP_USER}:${SMP_PASS}@${SMP_HOST}:${SMP_PORT}`;

const session = await bb.sessions.create({
  projectId: process.env.BROWSERBASE_PROJECT_ID,
  proxies: [
    {
      type: "external",
      server: `http://${SMP_HOST}:${SMP_PORT}`,
      username: SMP_USER,
      password: SMP_PASS,
    },
  ],
});

const browser = await chromium.connectOverCDP(session.connectUrl);
const context = browser.contexts()[0];
const page = await context.newPage();

await page.goto("https://shopee.sg/");
// your automation logic here

await browser.close();
await bb.sessions.stop(session.id);

A few notes on this setup. The proxies array in the Browserbase session options takes server, username, and password as separate fields, not a combined URL string. If you pass a combined URL with credentials embedded, some SDK versions will parse it correctly and some will not, so keep the fields separate. Also, make sure the type field is set to "external" whenever you are supplying your own proxy rather than using Browserbase’s built-in residential pool. Leaving it unset or using the wrong type causes the session to silently ignore your proxy config and fall back to default egress.

rotating IPs per request or per session

The decision between rotating and sticky sessions comes down to what you are automating. Rotating endpoints give you a fresh IP on every connection, which is useful for bulk data collection where each request is independent and you want maximum IP diversity. Sticky sessions hold the same modem IP for the duration of your session lease, which is essential for any workflow that involves authentication, multi-step forms, or stateful cart interactions.

For most Browserbase workflows, sticky sessions are the right default. Browserbase is session-oriented, and mixing a stateful browser session with a rotating IP creates a mismatch that fraud detection systems notice. If you log into a platform on IP A and then the next request comes from IP B (same city, same carrier, but a different modem), many platforms will treat this as a session anomaly and either re-challenge or silently degrade your access.

SMP provides separate endpoint addresses for rotating and sticky modes. To switch between them, you change the host and port in your session config rather than any parameter in the request itself. The sticky endpoint holds the connection on the same physical modem for the duration of your lease period. To request a new sticky IP, you request a new SMP session (which maps to a new Browserbase session in most pipeline designs):

// Rotating: a different modem IP is assigned on each new TCP connection
const rotatingProxy = {
  type: "external" as const,
  server: `http://${SMP_ROTATING_HOST}:${SMP_ROTATING_PORT}`,
  username: SMP_USER,
  password: SMP_PASS,
};

// Sticky: the same modem IP is held for the lease duration
// Change the host/port to your sticky endpoint from the SMP dashboard
const stickyProxy = {
  type: "external" as const,
  server: `http://${SMP_STICKY_HOST}:${SMP_STICKY_PORT}`,
  username: SMP_USER,
  password: SMP_PASS,
};

// Use stickyProxy for login flows and multi-step automation
// Use rotatingProxy for independent bulk collection tasks
const session = await bb.sessions.create({
  projectId: process.env.BROWSERBASE_PROJECT_ID,
  proxies: [loginFlowRequired ? stickyProxy : rotatingProxy],
});

One practical pattern: for a scraping pipeline that needs to collect data across many product pages, spin up rotating sessions in parallel, each as a separate Browserbase session with its own SMP connection. For a pipeline that needs to log in, work through a dashboard, and export data, use a single sticky session for the entire workflow and only rotate when you need a fresh identity.

three real workflows where this combo wins

shopee and lazada product intelligence

Price monitoring on Shopee SG and Lazada SG is a common Browserbase use case, and it is also where datacenter IPs fail most visibly. Both platforms serve different pricing, promotion banners, and inventory signals depending on the detected carrier. A request arriving from an AWS Singapore IP gets treated as a bot even with a clean fingerprint, and the price data returned often omits flash sale pricing that is only shown to mobile users. Running the same Browserbase session through a real SingTel or StarHub modem IP means you receive the same page a real Singapore mobile user sees. That is the data you actually want. For teams doing competitive intelligence or mobile proxies for SEO research across SEA markets, this is often the difference between useful data and misleading data.

singpass and government portal automation

A number of enterprise workflows involve accessing Singapore government portals that use Singpass for authentication. These portals perform IP geolocation checks as part of their fraud prevention stack, and they are significantly stricter than commercial platforms. Requests from datacenter IPs, even Singapore-region datacenter IPs, are flagged at the network layer before the browser fingerprint is even evaluated. Real SG carrier IPs (SingTel, StarHub, M1, Vivifi) pass these checks because they belong to ASNs that the portal’s risk model associates with legitimate Singapore residents. Browserbase provides the managed browser environment; SMP provides the IP that makes the connection credible.

Operators managing multiple accounts on Instagram, TikTok, or regional marketplaces use Browserbase to maintain separate browser contexts per account. The missing piece is IP-level account separation. Platforms correlate accounts by IP even when fingerprints are distinct, and that correlation is what gets accounts flagged. Assigning each account its own SMP sticky session gives it a real Singapore carrier IP that does not overlap with any other account’s IP, which is the correct architecture for this use case. The SingTel, StarHub, and M1 IP ranges are specifically valuable here because they are the carriers real Singapore users are actually on, so the IP matches the locale and device signals in the browser fingerprint.

common pitfalls

user-agent and IP class mismatch: if your Browserbase session sends a desktop Chrome user-agent but arrives on a mobile carrier IP, some platforms will flag the inconsistency. set a mobile user-agent to match the carrier IP class, or accept that some targets will notice the mismatch.
rotating IPs breaking session cookies: using a rotating endpoint for a logged-in workflow is the most common mistake. the platform sees a cookie from one IP and a subsequent request from a different IP and treats it as session hijacking. use sticky endpoints for anything stateful.
geolocation header overrides conflicting with IP geolocation: Browserbase allows you to set geolocation overrides in the session config. if you set a location that does not match the SMP IP’s actual location, some platforms will detect the discrepancy via IP geolocation versus browser API geolocation. either align both to Singapore, or disable the browser geolocation API override entirely and let the IP location speak for itself.
proxy auth failures silently falling through: if your SMP credentials are wrong or expired, Browserbase will sometimes proceed with its default egress rather than throwing a hard error. always verify the session’s actual egress IP at the start of your workflow by hitting an IP-check endpoint before doing any real work.
not accounting for modem rotation windows: SMP modems occasionally rotate their carrier-assigned IP (this is normal mobile network behavior). if your workflow runs longer than the modem’s IP lease period, the IP may change mid-session. for long-running workflows, design for this by checkpointing state.
timeout mismatches: mobile proxy connections have higher latency than datacenter connections. default Playwright and Browserbase timeouts are tuned for fast connections. increase navigation and selector wait timeouts when routing through mobile proxies to avoid false timeout failures.

when Singapore IPs specifically matter

The case for Singapore IPs specifically (not just any Southeast Asian residential pool) comes down to platform specificity and regulatory structure. Singapore is both a regional hub and a distinct market with its own carrier infrastructure, its own pricing, and its own geo-fenced content. Platforms like Grab, FairPrice Online, and Singtel’s own consumer apps behave differently for Singapore carrier IPs versus Malaysian or Indonesian IPs, even though all three are in SEA. If your automation target is specifically Singapore-facing, you need Singapore carrier IPs from the actual Singapore carriers (SingTel, StarHub, M1, Vivifi), not from generic “Singapore residential” pools that may be routing through VPS infrastructure labelled as residential.

There is also a regulatory dimension. Some Singapore government and financial services automations require IP geolocation to Singapore as part of compliance validation. Generic residential pools frequently fail these checks because their IP reputation databases include fraud signals from the same pool being used for non-compliant purposes elsewhere. Real Singapore mobile carrier IPs have clean reputation profiles because they are attached to physical modems on Singapore mobile networks. For the platforms where this matters, the distinction between “IP that resolves to Singapore” and “IP that is a real Singapore mobile carrier IP” is not subtle. If you want to understand what makes a mobile proxy different from other proxy types at the infrastructure level, what is a mobile proxy covers that distinction in depth.

getting started

If you are already using Browserbase and the workflows above match what you are building, the next step is to pick up an SMP plan and wire it in using the credential format and session config shown above. Plans are available at the Singapore Mobile Proxy plans page, with options for both rotating and sticky sessions depending on your use case. For teams doing multi-platform automation across SEA, read through the ethical mobile proxy use guidelines before scaling. Most platforms have terms of service that govern automated access, and Singapore’s own regulatory environment has specific provisions around automated interactions with licensed financial and government services.