Using Singapore mobile proxies with Apify in 2026

Apify gives you a solid actor runtime, a cloud scheduler, and a proxy management layer that handles basic rotation out of the box. For a long time, that was enough. Southeast Asian platforms have matured their anti-bot stacks, though, and more workflows now target SG-specific services like Shopee SG, Lazada SG, Carousell, and Singpass-adjacent fintech apps. At that point, the quality of the IP pool underneath your actors starts to matter as much as the actor logic itself. Datacenter IPs that worked fine in 2023 are getting hard-blocked at the TLS fingerprint layer before a single HTML byte lands. Closing that gap means using real Singapore carrier IPs.

why Apify hits walls without residential mobile IPs

The most common block pattern Apify users report is a clean 403 or a redirect to a CAPTCHA page that happens within the first one or two requests, before any rate-limit threshold could plausibly be triggered. That is almost always IP reputation, not behavior. Apify’s built-in datacenter proxy pool is well-known to major platforms; the ASN ranges are documented in public blocklists and routinely scrubbed by Cloudflare, Akamai, and every major CDN’s bot management layer. Even Apify’s residential pool, which sources IPs from consumer networks, skews heavily toward US and EU exit nodes because that is where the supply is.

For actors scraping Shopee SG product listings, Lazada SG seller pages, or any platform that checks whether your IP’s geography matches the locale you are requesting, a US residential IP causes a second problem beyond reputation: you get the wrong content. Shopee SG will silently serve regional pricing, redirect to a localised variant, or throttle the response with soft blocks that look like success but return incomplete data. You only discover this downstream when your price-monitoring pipeline starts producing anomalies you cannot explain.

The third failure mode is session continuity. Actors using Playwright or Puppeteer that maintain a browser context across multiple steps depend on cookies and local storage staying consistent with the apparent IP. When the proxy rotates mid-session to a different country, any platform doing geo-consistency checks on session tokens will invalidate the session silently, producing logged-out page states that your actor was not written to handle. Mobile IPs on a fixed carrier with controlled rotation eliminate this class of bug entirely.

setting up SMP credentials in Apify

Singapore Mobile Proxy delivers credentials in the standard host:port:username:password format. You will receive an HTTP endpoint and a SOCKS5 endpoint; they share the same credentials but behave differently at the protocol layer (the trade-offs are covered in HTTP vs SOCKS5 mobile proxies). For most Apify actors using Playwright or Cheerio, HTTP is the right starting point.

The cleanest way to wire SMP into an Apify actor is through the ProxyConfiguration object. Do not hardcode credentials in the actor source. Store them as an Apify secret input or in the actor’s input schema, then construct the proxy URL at runtime.

import { Actor } from 'apify';
import { ProxyConfiguration } from 'apify';

await Actor.init();

const input = await Actor.getInput();
const { smpHost, smpPort, smpUser, smpPass } = input;

// Build a custom proxy URL from SMP credentials
const proxyUrl = `http://${smpUser}:${smpPass}@${smpHost}:${smpPort}`;

const proxyConfiguration = new ProxyConfiguration({
  proxyUrls: [proxyUrl],
});

const crawler = new PlaywrightCrawler({
  proxyConfiguration,
  async requestHandler({ page, request }) {
    // your actor logic here
    const title = await page.title();
    await Actor.pushData({ url: request.url, title });
  },
});

await crawler.run(['https://www.shopee.sg/']);
await Actor.exit();

A few notes on this pattern. First, ProxyConfiguration with a proxyUrls array will round-robin across the URLs you supply. If you want pure sticky behaviour, supply a single URL. If you want Apify’s built-in rotation cadence to control the switch, supply multiple SMP endpoints (one per session group). Second, do not pass the SOCKS5 URL into PlaywrightCrawler directly unless you have confirmed your Playwright version handles SOCKS5 correctly; there have been intermittent issues with SOCKS5 and Chromium’s proxy resolver in certain Node.js environments. HTTP proxies are more predictable here. Third, treat smpHost, smpPort, smpUser, and smpPass as secret inputs in your actor schema, marked with "isSecret": true, so they are masked in Apify Console logs.

rotating IPs per request or per session

The decision between rotating and sticky depends entirely on what your actor is doing at the application layer, not on what feels more “anonymous.”

Rotating per request makes sense for pure data extraction where each URL is independent: SERP scraping, product listing pages, public price feeds. The target site sees each request from a different IP, which defeats rate-limiting based on IP frequency. SMP’s rotating endpoint handles this automatically; every connection to the rotating host gets a fresh carrier IP from the SG pool. Nothing special is needed in your actor beyond pointing at the rotating endpoint.

Sticky sessions are necessary any time your actor maintains state: login flows, shopping cart sequences, multi-step form submissions, or anything that sets a session cookie on step one and expects it to still be valid on step three. SMP’s sticky endpoint pins you to the same modem IP for the duration of your session window. You control the session identity by appending a session identifier to the username in the credential string. This is standard behaviour across mobile proxy providers and Apify’s SessionPool integrates with it naturally.

import { Actor, SessionPool } from 'apify';

await Actor.init();
const input = await Actor.getInput();
const { smpHost, smpPort, smpUser, smpPass } = input;

const sessionPool = await SessionPool.open({
  maxPoolSize: 10,
  sessionOptions: {
    maxUsageCount: 50,
  },
});

const crawler = new PlaywrightCrawler({
  useSessionPool: true,
  sessionPoolOptions: { maxPoolSize: 10 },
  proxyConfiguration: new ProxyConfiguration({
    // sessionId is injected by the crawler per-session
    newUrlFunction: async (session) => {
      // append session id to username for sticky routing
      const sessionUser = `${smpUser}-session-${session.id}`;
      return `http://${sessionUser}:${smpPass}@${smpHost}:${smpPort}`;
    },
  }),
  async requestHandler({ page, session, request }) {
    // session is reused for requests in the same session pool slot
    const content = await page.content();
    await Actor.pushData({ url: request.url, sessionId: session.id });
  },
});

await crawler.run(requestList);
await Actor.exit();

The session username suffix pattern (username-session-abc123) is a widely supported convention. Verify the exact syntax in your SMP dashboard; the separator character and field name may vary slightly. The key principle is that Apify’s SessionPool gives you a managed pool of logical sessions, and you map each logical session to a sticky proxy endpoint by baking the session identity into the credential string.

three real workflows where this combo wins

shopee sg and lazada sg price monitoring

Both platforms serve geo-differentiated pricing and inventory. A Shopee SG product page returned to a US datacenter IP will often show SGD pricing but with subtle differences in promotional labels, voucher availability, and stock counts compared to what a genuine SG mobile user sees. This matters for competitive pricing tools where the delta between “what the site shows a local user” and “what your scraper captures” erodes the value of the data. Running your Apify actor through SMP’s SingTel or StarHub modems means the IP reverse-resolves to the correct AS, the carrier metadata in any passive fingerprinting matches expectations, and the platform serves the same content it serves to actual Singapore mobile users. This is covered more broadly in the context of mobile proxies for SEO research, where the same geo-accuracy principle applies.

carousell and property listing platforms

Carousell is aggressive about bot detection on listing pages and search results. The platform combines IP reputation checks with behavioural signals, but the IP check is the first gate. Datacenter ranges are blocked outright. Even some residential proxy pools that have been used heavily for scraping have ended up on Carousell’s internal blocklists. Singapore carrier IPs from real SIM-bearing modems have not been through the same bulk-scraping history that commercial proxy pools accumulate. Running a Carousell monitoring actor through SMP gives you IPs with a clean history and a carrier fingerprint that matches the platform’s typical user base. Actors that previously had to implement heavy retry logic and CAPTCHA handling often see block rates drop to near zero after switching to mobile IPs.

singpass-adjacent fintech and insurance portals

A growing category of Apify use cases involves monitoring publicly accessible pages on platforms that integrate with or mimic Singpass-era UX patterns: insurance aggregators, CPF-adjacent tools, HDB resale portals. These platforms are almost universally hosted in Singapore, geo-fence their content to SG IPs, and have compliance reasons to be conservative about foreign traffic. An Apify actor hitting these from a US or EU residential pool will get either a block or a degraded response. SG mobile IPs solve the geo-fence problem directly, and because the carrier IPs resolve to the expected Singapore ASNs, the traffic looks exactly like what the platform’s security team expects to see in their access logs.

common pitfalls

user-agent and IP class mismatch. if you are routing through a mobile IP but sending a desktop Chrome user-agent, some platforms will flag the inconsistency. set your Playwright user agent to a mobile Chrome string that matches the carrier’s typical device profile, or at minimum use a generic mobile UA.
rotating mid-session and breaking cookies. the most common wiring mistake is using a rotating endpoint for a workflow that actually requires sticky sessions. if your actor logs in on request one and scrapes authenticated content on request two, a rotation between those requests invalidates the session token. use sticky endpoints for any multi-step authenticated flow.
not retiring sessions after errors. Apify’s SessionPool has a markBad mechanism that retires sessions after too many errors. wire this up. if a particular SMP session slot starts returning blocks, retiring it and opening a new sticky session gets you a fresh carrier IP assignment without manual intervention.
ignoring SOCKS5 for non-HTTP protocols. if your actor does anything beyond HTTP/HTTPS, such as WebSocket connections or custom TCP, you need SOCKS5. HTTP proxies cannot tunnel those. read through HTTP vs SOCKS5 mobile proxies before assuming HTTP is always fine.
hardcoding the proxy URL in actor source. credentials in source code get exposed in build logs, version history, and anyone who can read the actor source in Apify Console. use secret inputs or Apify’s key-value store for credentials.
not accounting for mobile IP latency. real modem-based mobile IPs have slightly higher latency than datacenter IPs. default request timeouts in some Apify actor templates are set low enough to cause spurious failures. bump your requestHandlerTimeoutSecs and navigationTimeoutSecs values when switching to mobile proxies.

when Singapore IPs specifically matter

The SEA digital market has a characteristic that makes generic residential pools a poor fit: platform-level geo-fencing is tighter than in Western markets, and the platforms that matter most (Shopee, Lazada, Grab, Carousell, local banking and insurance portals) are all Singapore-domiciled and serve Singapore users as their primary audience. A Romanian residential IP, even a clean one, will trigger geo-checks on these platforms that a Singapore carrier IP will not. This is not a subtle effect. It shows up as hard blocks, redirect loops, or content variants that make your scraped data wrong rather than merely incomplete.

The compliance angle also matters if you are operating ethically, which is the only way this should be done. The ethical mobile proxy use norms emerging in the industry distinguish between proxies sourced from real consenting device owners on local carrier networks and bulk-resold datacenter bandwidth rebranded as “residential.” SMP’s infrastructure is real SG carrier hardware, not repackaged datacenter capacity. For operators who need to answer questions from clients or legal teams about what their proxy infrastructure actually is, that distinction matters.

getting started

If you have been running Apify actors with datacenter or generic residential proxies and hitting the block patterns described here, the fastest way to validate whether mobile IPs change your results is to run a parallel test: same actor, same target URLs, one run through your current proxy setup and one through SMP. The difference in success rate is usually visible within the first hundred requests. Singapore Mobile Proxy plans are available at singaporemobileproxy.com with options for both rotating and sticky sessions, HTTP and SOCKS5, at bandwidth tiers that fit everything from small monitoring scripts to high-volume production actors. Start with the smallest plan that covers your expected daily GB, confirm the block rate improvement on your specific targets, then scale from there.