Apify Proxy Integration with Mobile IPs (2026 Guide)

{
  "actorSpecification": 1,
  "name": "proxystyler-powered-scraper",
  "version": "0.1",
  "buildTag": "latest",
  "title": "ProxyStyler Mobile Proxy Scraper",
  "description": "Scrapes target URLs through ProxyStyler 4G mobile IPs.",
  "dockerfile": "./Dockerfile",
  "input": "./input_schema.json",
  "storages": {
    "dataset": {
      "actorSpecification": 1,
      "views": {
        "default": {
          "title": "Results",
          "transformation": { "fields": ["url", "title", "scrapedAt"] }
        }
      }
    }
  },
  "minMemoryMbytes": 512,
  "maxMemoryMbytes": 4096,
  "defaultRunOptions": {
    "build": "latest",
    "timeoutSecs": 3600,
    "memoryMbytes": 2048
  },
  "meta": { "templateId": "python-start" },
  "pricingInfos": [
    {
      "pricingModel": "PAY_PER_EVENT",
      "pricingPerEvent": {
        "actorChargeEvents": {
          "page-opened": {
            "eventTitle": "Page opened",
            "eventDescription": "Charged for each page the Actor visits.",
            "eventPriceUsd": 0.0005
          },
          "dataset-item-stored": {
            "eventTitle": "Result stored",
            "eventDescription": "Charged for each item pushed to the dataset.",
            "eventPriceUsd": 0.002
          }
        }
      }
    }
  ]
}

{
  "title": "ProxyStyler Scraper Input",
  "type": "object",
  "schemaVersion": 1,
  "properties": {
    "startUrls": {
      "title": "Start URLs",
      "type": "array",
      "editor": "requestListSources",
      "description": "URLs the Actor will visit first."
    },
    "proxyConfiguration": {
      "title": "Proxy",
      "type": "object",
      "editor": "proxy",
      "description": "Choose Apify Proxy or supply ProxyStyler URLs below.",
      "prefill": { "useApifyProxy": false }
    },
    "proxystylerProxyUrls": {
      "title": "ProxyStyler proxy URLs (BYOP)",
      "type": "array",
      "editor": "stringList",
      "description": "One or more ProxyStyler endpoints, e.g. http://user:pass@us.proxystyler.com:30000",
      "default": []
    },
    "proxystylerRotateUrl": {
      "title": "ProxyStyler rotate endpoint",
      "type": "string",
      "editor": "textfield",
      "description": "Optional HTTP rotation URL provided in your ProxyStyler dashboard.",
      "isSecret": true
    }
  },
  "required": ["startUrls"]
}

# main.py - Apify Python SDK with ProxyStyler BYOP
from apify import Actor, ProxyConfiguration
import httpx
from selectolax.parser import HTMLParser

async def main() -> None:
    async with Actor:
        actor_input = await Actor.get_input() or {}

        start_urls = actor_input.get("startUrls", [])
        proxystyler_urls = actor_input.get("proxystylerProxyUrls", [])
        rotate_url = actor_input.get("proxystylerRotateUrl")

        # Build a ProxyConfiguration from ProxyStyler endpoints
        if proxystyler_urls:
            proxy_config = ProxyConfiguration(proxy_urls=proxystyler_urls)
        else:
            proxy_config = await Actor.create_proxy_configuration(
                groups=["RESIDENTIAL"],
                country_code="US",
            )

        async with httpx.AsyncClient(timeout=30) as session:
            for request in start_urls:
                url = request["url"] if isinstance(request, dict) else request
                proxy_url = await proxy_config.new_url()

                Actor.log.info(f"Fetching {url} via {proxy_url}")

                response = await session.get(
                    url,
                    proxies={"http://": proxy_url, "https://": proxy_url},
                    headers={"User-Agent": "Mozilla/5.0 Apify/ProxyStyler"},
                )

                # Charge one page-opened event
                await Actor.charge("page-opened")

                if response.status_code == 200:
                    tree = HTMLParser(response.text)
                    title = tree.css_first("title").text() if tree.css_first("title") else None

                    await Actor.push_data({
                        "url": url,
                        "title": title,
                        "status": response.status_code,
                        "scrapedAt": Actor.datetime_now_iso(),
                    })
                    await Actor.charge("dataset-item-stored")

                # Optional: rotate ProxyStyler IP for next request
                if rotate_url:
                    try:
                        await session.get(rotate_url, timeout=10)
                    except Exception as e:
                        Actor.log.warning(f"Rotation failed: {e}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

// main.js - Apify JS SDK + Crawlee + ProxyStyler BYOP
import { Actor } from 'apify';
import { PlaywrightCrawler, ProxyConfiguration } from 'crawlee';

await Actor.init();

const input = await Actor.getInput() ?? {};
const {
    startUrls = [],
    proxystylerProxyUrls = [],
    proxystylerRotateUrl,
    maxConcurrency = 5,
} = input;

// Build the proxy configuration from ProxyStyler endpoints
const proxyConfiguration = proxystylerProxyUrls.length > 0
    ? new ProxyConfiguration({ proxyUrls: proxystylerProxyUrls })
    : await Actor.createProxyConfiguration({
        groups: ['RESIDENTIAL'],
        countryCode: 'US',
    });

const crawler = new PlaywrightCrawler({
    proxyConfiguration,
    maxConcurrency,
    launchContext: {
        launchOptions: {
            headless: true,
            args: ['--disable-blink-features=AutomationControlled'],
        },
    },
    async requestHandler({ page, request, log }) {
        log.info(`Scraping ${request.url}`);
        await page.waitForLoadState('domcontentloaded');

        const title = await page.title();
        const html = await page.content();

        await Actor.charge({ eventName: 'page-opened' });

        await Actor.pushData({
            url: request.url,
            title,
            htmlLength: html.length,
            scrapedAt: new Date().toISOString(),
        });

        await Actor.charge({ eventName: 'dataset-item-stored' });

        // Rotate ProxyStyler IP between requests when an endpoint is supplied
        if (proxystylerRotateUrl) {
            try {
                await fetch(proxystylerRotateUrl, {
                    method: 'GET',
                    signal: AbortSignal.timeout(10_000),
                });
            } catch (err) {
                log.warning(`ProxyStyler rotate failed: ${err.message}`);
            }
        }
    },
    failedRequestHandler({ request, log }, error) {
        log.error(`${request.url} failed: ${error.message}`);
    },
});

await crawler.run(startUrls);

await Actor.exit();

import { CheerioCrawler, ProxyConfiguration } from 'crawlee';
import { Actor } from 'apify';

const crawler = new CheerioCrawler({
    proxyConfiguration: new ProxyConfiguration({
        proxyUrls: [
            'http://user:pass@us.proxystyler.com:30000',
            'http://user:pass@us.proxystyler.com:30001',
            'http://user:pass@us.proxystyler.com:30002',
        ],
    }),
    maxRequestsPerMinute: 180,       // stay polite
    requestHandlerTimeoutSecs: 60,
    async requestHandler({ $, request }) {
        const title = $('title').text();
        const prices = $('.price').map((_, el) => $(el).text()).get();
        await Actor.pushData({ url: request.url, title, prices });
        await Actor.charge({ eventName: 'page-opened' });
    },
});

await crawler.run(startUrls);

# pip install llama-index apify-client
from llama_index.core import VectorStoreIndex, Document
from llama_index.readers.apify import ApifyActor

# Run the ProxyStyler-powered scraper as an Actor
reader = ApifyActor("your-username/proxystyler-powered-scraper")

documents = reader.load_data(
    actor_id="your-username/proxystyler-powered-scraper",
    run_input={
        "startUrls": [
            {"url": "https://example.com/docs"},
            {"url": "https://example.com/blog"},
        ],
        "proxystylerProxyUrls": [
            "http://user:pass@us.proxystyler.com:30000",
        ],
    },
    dataset_mapping_function=lambda item: Document(
        text=item.get("htmlContent") or item.get("title", ""),
        metadata={
            "url": item.get("url"),
            "scraped_at": item.get("scrapedAt"),
            "source": "proxystyler-apify",
        },
    ),
)

# Build a vector index over the freshly scraped content
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine(similarity_top_k=5)

answer = query_engine.query("What changed in the pricing section last week?")
print(answer)

# pip install langchain langchain-apify apify-client
from langchain.indexes import VectorstoreIndexCreator
from langchain_apify import ApifyWrapper
from langchain_core.documents import Document
from langchain_openai import OpenAIEmbeddings

apify = ApifyWrapper()

loader = apify.call_actor(
    actor_id="your-username/proxystyler-powered-scraper",
    run_input={
        "startUrls": [{"url": "https://news.example.com/latest"}],
        "proxystylerProxyUrls": [
            "http://user:pass@us.proxystyler.com:30000",
            "http://user:pass@us.proxystyler.com:30001",
        ],
    },
    dataset_mapping_function=lambda item: Document(
        page_content=item["htmlContent"] or item["title"],
        metadata={
            "url": item["url"],
            "source": "proxystyler-apify",
            "scraped_at": item["scrapedAt"],
        },
    ),
)

# Vector index
index = VectorstoreIndexCreator(
    embedding=OpenAIEmbeddings(model="text-embedding-3-large"),
).from_loaders([loader])

result = index.query("Summarize today's top stories.")
print(result)

from langchain_apify import ApifyDatasetLoader

# Already ran the Actor? Load the dataset directly.
loader = ApifyDatasetLoader(
    dataset_id="AbCdEfGhIj1234567",
    dataset_mapping_function=lambda x: Document(
        page_content=x["html"] or "",
        metadata={"url": x["url"]},
    ),
)

docs = loader.load()
print(f"Loaded {len(docs)} documents from ProxyStyler-scraped dataset")

# 1. Install the Apify CLI
npm install -g apify-cli

# 2. Log in (opens browser to fetch token)
apify login

# 3. Create a new Actor from template
apify create proxystyler-powered-scraper --template=python-crawlee-playwright

# 4. Move into the folder
cd proxystyler-powered-scraper

# 5. Edit .actor/actor.json to add PPE events (see earlier snippet)
# 6. Edit .actor/input_schema.json to add proxystylerProxyUrls
# 7. Edit src/main.py to use ProxyConfiguration (see Python section)

# 8. Test locally with a real ProxyStyler endpoint
apify run --purge --input='{
  "startUrls": [{"url": "https://example.com"}],
  "proxystylerProxyUrls": ["http://user:pass@us.proxystyler.com:30000"]
}'

# 9. Push to Apify Cloud
apify push

# 10. (Optional) Publish to the Store
#    - Add screenshots, icon, category
#    - Submit for review
#    - Typical approval: 1-3 business days