Fetch first, open a Browser when a task needs interaction

import requests
from playwright.sync_api import sync_playwright

ZENROWS_API_KEY = "YOUR_ZENROWS_API_KEY"

def read_page(url: str) -> str:
    """Fetch: read one page as markdown. Use for any task that only reads."""
    response = requests.get(
        "https://api.zenrows.com/v1/",
        params={
            "apikey": ZENROWS_API_KEY,
            "url": url,
            "mode": "auto",
            "response_type": "markdown",
        },
        timeout=180,
    )
    response.raise_for_status()
    return response.text

def run_browser_task(url: str, steps: list[dict]) -> str:
    """Browser: open the page, run each step in order, return the final page text."""
    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(
            f"wss://browser.zenrows.com?apikey={ZENROWS_API_KEY}"
        )
        try:
            page = browser.contexts[0].new_page()
            page.goto(url)
            for step in steps:
                action, selector = step["action"], step.get("selector")
                if action == "fill":
                    page.fill(selector, step["value"])
                elif action == "click":
                    page.click(selector, no_wait_after=True)
                elif action == "wait_for_text":
                    page.wait_for_function(
                        "text => document.body.innerText.includes(text)", arg=step["value"]
                    )
                elif action == "goto":
                    page.goto(step["value"])
            return page.evaluate("document.body.innerText")
        finally:
            browser.close()

def handle_web_task(url: str, steps: list[dict] | None = None) -> str:
    """Route: Fetch when the agent only reads, Browser when it must interact."""
    if not steps:
        return read_page(url)
    return run_browser_task(url, steps)

if __name__ == "__main__":
    # Read-only task: goes to Fetch
    page = handle_web_task("https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/")
    print("FETCH:", page[page.find("# Abominable"):][:120])

    # Multi-step task: goes to Browser
    result = handle_web_task(
        "https://www.scrapingcourse.com/login",
        steps=[
            {"action": "fill", "selector": "#email", "value": "admin@example.com"},
            {"action": "fill", "selector": "#password", "value": "password"},
            {"action": "click", "selector": "#submit-button"},
            {"action": "wait_for_text", "value": "Welcome"},
        ],
    )
    print("BROWSER:", result[:200])

import { chromium } from "playwright-core";

const ZENROWS_API_KEY = "YOUR_ZENROWS_API_KEY";

// Fetch: read one page as markdown. Use for any task that only reads.
async function readPage(url) {
  const params = new URLSearchParams({
    apikey: ZENROWS_API_KEY,
    url,
    mode: "auto",
    response_type: "markdown",
  });
  const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
    signal: AbortSignal.timeout(180_000),
  });
  if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
  return response.text();
}

// Browser: open the page, run each step in order, return the final page text.
async function runBrowserTask(url, steps) {
  const browser = await chromium.connectOverCDP(`wss://browser.zenrows.com?apikey=${ZENROWS_API_KEY}`);
  try {
    const page = await browser.contexts()[0].newPage();
    await page.goto(url);
    for (const step of steps) {
      if (step.action === "fill") await page.fill(step.selector, step.value);
      else if (step.action === "click") await page.click(step.selector, { noWaitAfter: true });
      else if (step.action === "wait_for_text")
        await page.waitForFunction((text) => document.body.innerText.includes(text), step.value);
      else if (step.action === "goto") await page.goto(step.value);
    }
    return await page.evaluate(() => document.body.innerText);
  } finally {
    await browser.close();
  }
}

// Route: Fetch when the agent only reads, Browser when it must interact.
async function handleWebTask(url, steps = []) {
  return steps.length ? runBrowserTask(url, steps) : readPage(url);
}

const page = await handleWebTask("https://www.scrapingcourse.com/ecommerce/product/abominable-hoodie/");
console.log("FETCH:", page.slice(page.indexOf("# Abominable"), page.indexOf("# Abominable") + 60));

const result = await handleWebTask("https://www.scrapingcourse.com/login", [
  { action: "fill", selector: "#email", value: "admin@example.com" },
  { action: "fill", selector: "#password", value: "password" },
  { action: "click", selector: "#submit-button" },
  { action: "wait_for_text", value: "Welcome" },
]);
console.log("BROWSER:", result.slice(0, 120));