docs: rotate proxy per request in the Playwright example and tidy guide wording

Author: vdusek

docs/03_guides/03_playwright.mdx

@@ -58,7 +58,7 @@ It uses Playwright to open the pages in an automated Chrome browser, and to extr
 
 ## Using Apify Proxy
 
-Running on the Apify platform gives your scraper access to [Apify Proxy](https://docs.apify.com/platform/proxy), which rotates IP addresses to avoid rate limiting and blocking. The example creates a proxy configuration with `Actor.create_proxy_configuration` and launches the browser through it. Playwright applies the proxy at the browser level, so the whole run shares a single proxy URL rather than rotating per request; the `to_playwright_proxy` helper splits that URL into the `server`, `username`, and `password` fields Playwright expects. To select specific proxy groups or a country, pass the relevant arguments to `Actor.create_proxy_configuration`. For more details, see the [Proxy management](../concepts/proxy-management) guide.
+Running on the Apify platform gives your scraper access to [Apify Proxy](https://docs.apify.com/platform/proxy), which rotates IP addresses to avoid rate limiting and blocking. The example creates a proxy configuration with `Actor.create_proxy_configuration` and fetches a fresh proxy URL for every request. Playwright applies a proxy per browser context, so each request runs in its own new context to rotate the IP. The `to_playwright_proxy` helper splits that URL into the `server`, `username`, and `password` fields Playwright expects. To select specific proxy groups or a country, pass the relevant arguments to `Actor.create_proxy_configuration`. For more details, see the [Proxy management](../concepts/proxy-management) guide.
 
 ## Conclusion
 

docs/03_guides/12_running_webserver.mdx

@@ -33,7 +33,7 @@ The following example shows how to start a simple web server in your Actor, whic
 
 ## Using FastAPI
 
-The example above relies only on Python's standard library, which keeps it dependency-free but leaves you handling requests by hand. For anything beyond a single endpoint, a web framework such as [FastAPI](https://fastapi.tiangolo.com/) is a better fit - it gives you routing, request parsing, and automatic JSON responses, and is served by an ASGI server like [uvicorn](https://www.uvicorn.org/).
+The example above relies only on Python's standard library, which keeps it dependency-free but leaves you handling requests by hand. For anything beyond a single endpoint, a web framework such as [FastAPI](https://fastapi.tiangolo.com/) is a better fit. It gives you routing, request parsing, and automatic JSON responses, and is served by an ASGI server like [uvicorn](https://www.uvicorn.org/).
 
 Install both, for example by adding them to your `requirements.txt`:
 
@@ -52,13 +52,13 @@ A few things worth pointing out:
 
 - `uvicorn.Server(...).serve()` is a coroutine, so it runs as an `asyncio` task alongside the Actor's own work instead of blocking it. Setting `server.should_exit = True` triggers a graceful shutdown once the work is done.
 - The server binds to `0.0.0.0` (all interfaces) rather than `localhost`, so it's reachable through the container URL, not only from inside the container.
-- The same pattern powers an [Actor Standby](#actor-standby) service - swap the one-off work loop for an Actor that just keeps serving requests.
+- The same pattern powers an [Actor Standby](#actor-standby) service. Swap the one-off work loop for an Actor that just keeps serving requests.
 
 ## Actor Standby
 
 The example above runs a web server for the duration of a single Actor run. With [Actor Standby](https://docs.apify.com/platform/actors/development/programming-interface/standby), you can instead expose your Actor as an always-ready HTTP API: the platform keeps the Actor running in the background and routes incoming HTTP requests to the web server inside it, spinning up additional instances as the load grows.
 
-From the SDK's perspective, a Standby Actor is built the same way as the web server above — start an HTTP server listening on the port from `Actor.configuration.web_server_port`. The difference is operational: instead of doing its work once and exiting, a Standby Actor stays up and serves requests. This makes it a good fit for low-latency, on-demand use cases, such as serving scraped data or acting as a microservice.
+From the SDK's perspective, a Standby Actor is built the same way as the web server above. You start an HTTP server listening on the port from `Actor.configuration.web_server_port`. The difference is operational: instead of doing its work once and exiting, a Standby Actor stays up and serves requests. This makes it a good fit for low-latency, on-demand use cases, such as serving scraped data or acting as a microservice.
 
 To get started quickly, use the [Standby Python template](https://apify.com/templates/python-standby). For details on enabling Standby, request routing, and readiness probes, see the [Actor Standby documentation](https://docs.apify.com/platform/actors/development/programming-interface/standby).
 

docs/03_guides/code/03_playwright.py

@@ -83,9 +83,8 @@ async def main() -> None:
             Actor.log.info('No start URLs specified in Actor input, exiting...')
             await Actor.exit()
 
-        # Playwright proxies at the browser level, so one URL is shared per run.
+        # Set up the proxy configuration; a fresh proxy URL is fetched per request below.
         proxy_configuration = await Actor.create_proxy_configuration()
-        proxy_url = await proxy_configuration.new_url() if proxy_configuration else None
 
         # Open the request queue and enqueue the start URLs (crawl depth 0).
         request_queue = await Actor.open_request_queue()
@@ -103,10 +102,8 @@ async def main() -> None:
         async with async_playwright() as playwright:
             browser = await playwright.chromium.launch(
                 headless=Actor.configuration.headless,
-                proxy=to_playwright_proxy(proxy_url) if proxy_url else None,
                 args=['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
             )
-            context = await browser.new_context()
 
             while handled_requests < max_requests and (
                 request := await request_queue.fetch_next_request()
@@ -116,6 +113,14 @@ async def main() -> None:
                 depth = request.crawl_depth
                 Actor.log.info(f'Scraping {url} (depth={depth}) ...')
 
+                # A new context with a fresh proxy URL per request rotates the proxy IP.
+                proxy_url = (
+                    await proxy_configuration.new_url() if proxy_configuration else None
+                )
+                context = await browser.new_context(
+                    proxy=to_playwright_proxy(proxy_url) if proxy_url else None,
+                )
+
                 try:
                     data, links = await scrape_page(context, url)
                     await Actor.push_data(data)
@@ -131,6 +136,7 @@ async def main() -> None:
                     Actor.log.exception(f'Cannot extract data from {url}.')
 
                 finally:
+                    await context.close()
                     await request_queue.mark_request_as_handled(request)