Browser automation

import os
from skyvern import Skyvern

skyvern = Skyvern(api_key=os.environ["SKYVERN_API_KEY"])
browser = await skyvern.launch_cloud_browser()
page = await browser.get_working_page()
try:
    await page.goto("https://example.com")
    # ... your automation ...
finally:
    await browser.close()

import { Skyvern } from "@skyvern/client";

const skyvern = new Skyvern({ apiKey: process.env.SKYVERN_API_KEY! });
const browser = await skyvern.launchCloudBrowser();
const page = await browser.getWorkingPage();
try {
  await page.goto("https://example.com");
  // ... your automation ...
} finally {
  await browser.close();
}

# The newest idle session, or a new one
browser = await skyvern.use_cloud_browser()

# Or a specific session
# browser = await skyvern.connect_to_cloud_browser_session("pbs_123")

// The newest idle session, or a new one
const browser = await skyvern.useCloudBrowser();

// Or a specific session
// const browser = await skyvern.connectToCloudBrowserSession("pbs_123");

# Do one thing per call. Returns None.
await page.act("Accept the cookie banner")
await page.act("Open the Pricing page")

# Read data. Returns a dict, or a list when the schema root is an array.
plan = await page.extract("Get the name and monthly price of the cheapest plan")

# Check a condition. Returns True or False.
logged_in = await page.validate("The user is logged in")

# Ask the model about text you pass. It doesn't see the page. Returns {"llm_response": "..."} without a schema.
answer = await page.prompt("Classify this support ticket as billing, bug or other: 'I was charged twice this month.'")

// Do one thing per call.
await page.act("Accept the cookie banner");
await page.act("Open the Pricing page");

// Read data. Returns an object, or an array when the schema root is an array.
const plan = await page.extract({ prompt: "Get the name and monthly price of the cheapest plan" });

// Check a condition. Returns true or false.
const loggedIn = await page.validate("The user is logged in");

// Ask the model about text you pass. It doesn't see the page. Returns { llm_response: "..." } without a schema.
const answer = await page.prompt("Classify this support ticket as billing, bug or other: 'I was charged twice this month.'");

await page.click("#submit")                                    # selector
await page.click(prompt="Click the Submit button")             # AI
await page.click("#submit", prompt="Click the Submit button")  # selector, AI fallback

await page.fill("#email", "you@example.com", prompt="Fill the email field")
await page.select_option("#country", "US", prompt="Select United States")

await page.wait_for_selector("#dashboard")                     # plain Playwright

await page.click("#submit");                                     // selector
await page.click({ prompt: "Click the Submit button" });         // AI
await page.click("#submit", { prompt: "Click the Submit button" }); // selector, AI fallback

await page.fill("#email", "you@example.com", { prompt: "Fill the email field" });
await page.selectOption("#country", "US", { prompt: "Select United States" });

await page.waitForSelector("#dashboard");                        // plain Playwright

posts = await page.extract(
    "Extract the top 5 posts",
    schema={
        "type": "array",
        "items": {
            "type": "object",
            "properties": {
                "title": {"type": "string", "description": "Post title as shown"},
                "points": {"type": "integer", "description": "Points, digits only"},
                "url": {"type": "string", "description": "Link the title points to"},
            },
            "required": ["title"],
        },
    },
)
for post in posts:
    print(post["title"], post.get("points"))

type Post = { title: string; points?: number; url?: string };

const posts = (await page.extract({
  prompt: "Extract the top 5 posts",
  schema: {
    type: "array",
    items: {
      type: "object",
      properties: {
        title: { type: "string", description: "Post title as shown" },
        points: { type: "integer", description: "Points, digits only" },
        url: { type: "string", description: "Link the title points to" },
      },
      required: ["title"],
    },
  },
})) as Post[];
for (const post of posts) console.log(post.title, post.points);

# Log in with a credential stored in Skyvern. Handles multi-page logins and 2FA.
await page.agent.login(credential_type="skyvern", credential_id="cred_123")

# Run a multi-step goal and get structured output.
result = await page.agent.run_task(
    "Open Billing and get the plan name and next invoice date",
    data_extraction_schema={
        "type": "object",
        "properties": {
            "plan": {"type": "string"},
            "next_invoice_date": {"type": "string"},
        },
    },
)
print(result.status, result.output, result.app_url)

# Run an agent you built in Studio on this page, after your own setup steps.
run = await page.agent.run_workflow("wpid_123", parameters={"month": "2026-09"})

// Log in with a credential stored in Skyvern. Handles multi-page logins and 2FA.
await page.agent.login("skyvern", { credentialId: "cred_123" });

// Run a multi-step goal and get structured output.
const result = await page.agent.runTask(
  "Open Billing and get the plan name and next invoice date",
  {
    dataExtractionSchema: {
      type: "object",
      properties: {
        plan: { type: "string" },
        next_invoice_date: { type: "string" },
      },
    },
  },
);
console.log(result.status, result.output, result.app_url);

// Run an agent you built in Studio on this page, after your own setup steps.
const run = await page.agent.runWorkflow("wpid_123", { parameters: { month: "2026-09" } });

result = await page.agent.download_files(
    "Download the statement for September 2026",
    download_suffix="statement-2026-09",
)
for file in result.downloaded_files or []:
    print(file.filename, file.url, file.checksum)

const result = await page.agent.downloadFiles("Download the statement for September 2026", {
  downloadSuffix: "statement-2026-09",
});
for (const file of result.downloaded_files ?? []) {
  console.log(file.filename, file.url, file.checksum);
}

second = await browser.new_page()          # open a new tab
await second.goto("https://example.com/reports")

latest = await browser.get_working_page()  # the most recent tab

# Wrap a tab the site opened itself (browser.pages lists Playwright pages)
popup = await browser.get_page_for(browser.pages[-1])

const second = await browser.newPage(); // open a new tab
await second.goto("https://example.com/reports");

const latest = await browser.getWorkingPage(); // the most recent tab

// Every open tab, with AI methods
const tabs = browser.pages();

task = await skyvern.run_task(
    prompt="Find the support email on the Contact page",
    url="https://example.com",
    wait_for_completion=True,
)

agent_run = await skyvern.run_workflow(
    "wpid_123",                      # the agent's ID
    parameters={"month": "2026-09"},
    wait_for_completion=True,
)

const task = await skyvern.runTask({
  prompt: "Find the support email on the Contact page",
  url: "https://example.com",
  waitForCompletion: true,
});

const agentRun = await skyvern.runWorkflow({
  agent_id: "wpid_123", // the agent's ID
  parameters: { month: "2026-09" },
  waitForCompletion: true,
});

run = await skyvern.run_workflow("wpid_123", run_with="code", wait_for_completion=True)

const run = await skyvern.runWorkflow({ agent_id: "wpid_123", run_with: "code", waitForCompletion: true });

import asyncio
import os
from pathlib import Path

import httpx
from skyvern import Skyvern

PORTAL_URL = "https://vendor-portal.example.com/login"
CREDENTIAL_ID = os.environ["VENDOR_CREDENTIAL_ID"]  # cred_...
SINCE = "2026-09-01"
OUT_DIR = Path("invoices")

ORDER_SCHEMA = {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "order_number": {"type": "string", "description": "Order number as shown in the table"},
            "order_date": {"type": "string", "description": "Order date, YYYY-MM-DD"},
            "total": {"type": "number", "description": "Order total, number only, no currency symbol"},
        },
        "required": ["order_number"],
    },
}


async def main():
    skyvern = Skyvern(api_key=os.environ["SKYVERN_API_KEY"])
    browser = await skyvern.launch_cloud_browser()
    try:
        page = await browser.get_working_page()
        await page.goto(PORTAL_URL)

        # 1. Log in with the stored credential (no password in your code)
        login = await page.agent.login(credential_type="skyvern", credential_id=CREDENTIAL_ID)
        if login.status != "completed":
            raise RuntimeError(f"Login failed: {login.failure_reason}")

        # 2. Open order history: selector first, AI if the link moved
        await page.click("a[href*='orders']", prompt="Open the order history page")
        await page.act(f"Filter the orders to show only orders placed on or after {SINCE}")
        orders_url = page.url

        # 3. Extract the orders as typed data
        orders = await page.extract("Extract every order in the order history table", schema=ORDER_SCHEMA)
        print(f"Found {len(orders)} orders")

        # 4. Download each invoice and save it locally
        OUT_DIR.mkdir(exist_ok=True)
        async with httpx.AsyncClient() as http:
            for order in orders:
                number = order["order_number"]
                result = await page.agent.download_files(
                    f"Download the invoice PDF for order {number}",
                    url=orders_url,
                    download_suffix=f"invoice-{number}",
                )
                if result.status != "completed":
                    print(f"{number}: {result.status} {result.failure_reason}")
                    continue
                for file in result.downloaded_files or []:
                    response = await http.get(file.url)
                    response.raise_for_status()
                    path = OUT_DIR / (file.filename or f"invoice-{number}.pdf")
                    path.write_bytes(response.content)
                    print(f"{number}: saved {path}")
    finally:
        await browser.close()


asyncio.run(main())

import { mkdir, writeFile } from "node:fs/promises";
import path from "node:path";
import { Skyvern } from "@skyvern/client";

const PORTAL_URL = "https://vendor-portal.example.com/login";
const CREDENTIAL_ID = process.env.VENDOR_CREDENTIAL_ID!; // cred_...
const SINCE = "2026-09-01";
const OUT_DIR = "invoices";

type Order = { order_number: string; order_date?: string; total?: number };

const ORDER_SCHEMA = {
  type: "array",
  items: {
    type: "object",
    properties: {
      order_number: { type: "string", description: "Order number as shown in the table" },
      order_date: { type: "string", description: "Order date, YYYY-MM-DD" },
      total: { type: "number", description: "Order total, number only, no currency symbol" },
    },
    required: ["order_number"],
  },
};

async function main() {
  const skyvern = new Skyvern({ apiKey: process.env.SKYVERN_API_KEY! });
  const browser = await skyvern.launchCloudBrowser();
  try {
    const page = await browser.getWorkingPage();
    await page.goto(PORTAL_URL);

    // 1. Log in with the stored credential (no password in your code)
    const login = await page.agent.login("skyvern", { credentialId: CREDENTIAL_ID });
    if (login.status !== "completed") {
      throw new Error(`Login failed: ${login.failure_reason}`);
    }

    // 2. Open order history: selector first, AI if the link moved
    await page.click("a[href*='orders']", { prompt: "Open the order history page" });
    await page.act(`Filter the orders to show only orders placed on or after ${SINCE}`);
    const ordersUrl = page.url();

    // 3. Extract the orders as typed data
    const orders = (await page.extract({
      prompt: "Extract every order in the order history table",
      schema: ORDER_SCHEMA,
    })) as Order[];
    console.log(`Found ${orders.length} orders`);

    // 4. Download each invoice and save it locally
    await mkdir(OUT_DIR, { recursive: true });
    for (const order of orders) {
      const number = order.order_number;
      const result = await page.agent.downloadFiles(`Download the invoice PDF for order ${number}`, {
        url: ordersUrl,
        downloadSuffix: `invoice-${number}`,
      });
      if (result.status !== "completed") {
        console.log(`${number}: ${result.status} ${result.failure_reason ?? ""}`);
        continue;
      }
      for (const file of result.downloaded_files ?? []) {
        const response = await fetch(file.url);
        if (!response.ok) throw new Error(`Download failed: ${response.status}`);
        const filePath = path.join(OUT_DIR, file.filename ?? `invoice-${number}.pdf`);
        await writeFile(filePath, Buffer.from(await response.arrayBuffer()));
        console.log(`${number}: saved ${filePath}`);
      }
    }
  } finally {
    await browser.close();
  }
}

main();