skyvern Documentation

GitHub

Automate browser based workflows with AI

22,740 stars

Python 1 file · ~5,875 tokens #ai #api #automation #browser #browser-automation #computer #gpt #llm

RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy skyvern on any server, homelab, or cloud container platform.

Raw YAML Docker Page → JSON API

1-Click Terminal Command

bash (docker run)

docker run -d --name skyvern -p 8000:8000 --restart always public.ecr.aws/skyvern/skyvern:latest

Configured Services & Ports

⚙️ postgres

image: postgres:14-alpine

⚙️ skyvern

image: public.ecr.aws/skyvern/skyvern:latest

🔌 Ports: 8000:8000, 6080:6080

⚙️ skyvern-ui

image: public.ecr.aws/skyvern/skyvern-ui:latest

🔌 Ports: 8080:8080, 9090:9090

docker-compose.yml

yaml (docker-compose.yml)

services:
  postgres:
    image: postgres:14-alpine
    restart: always
    # comment out if you want to externally connect DB
    # ports:
    #   - 5432:5432
    volumes:
      - ./postgres-data:/var/lib/postgresql/data
    environment:
      - PGDATA=/var/lib/postgresql/data/pgdata
      - POSTGRES_USER=skyvern
      - POSTGRES_PASSWORD=skyvern
      - POSTGRES_DB=skyvern
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U skyvern"]
      interval: 5s
      timeout: 5s
      retries: 5
  skyvern:
    image: public.ecr.aws/skyvern/skyvern:latest
    # For local backend development, replace the image line above with:
    # build:
    #   context: .
    #   dockerfile: Dockerfile
    # Or keep the public image and uncomment the source mounts below.
    restart: on-failure
    extra_hosts:
      - "host.docker.internal:host-gateway"
    env_file:
      - .env
    # comment out if you want to externally call skyvern API
    ports:
      - 8000:8000
      - 6080:6080 # for VNC WebSocket streaming
    volumes:
      - ./artifacts:/data/artifacts
      - ./videos:/data/videos
      - ./har:/data/har
      - ./log:/data/log
      - ./downloads:/data/downloads
      - ./browser_sessions:/data/browser_sessions
      - ./credential_vault:/data/credential_vault
      # Generated credentials allow the UI to pick up the local API key on first startup.
      - ./.skyvern:/app/.skyvern
      # Uncomment the following two lines if you want to connect to any local changes
      # - ./skyvern:/app/skyvern
      # - ./alembic:/app/alembic
    environment:
      # ─────────────────────────────────────────────────────────────────
      # Compose-network values live here. These are infrastructure values
      # tied to the docker compose network (e.g. the `postgres` hostname
      # only resolves inside this compose stack). DO NOT move these into
      # .env — `.env.example` uses a `localhost` host that points at the
      # backend container itself inside compose, which would break the DB
      # connection.
      #
      # User secrets (LLM API keys, etc.) go in `.env` (loaded above via
      # env_file). The split is intentional: compose owns infrastructure;
      # .env owns secrets.
      # ─────────────────────────────────────────────────────────────────
      - DATABASE_STRING=postgresql+psycopg://skyvern:skyvern@postgres:5432/skyvern
      - BROWSER_STREAMING_MODE=${BROWSER_STREAMING_MODE:-cdp}
      - BROWSER_TYPE=${BROWSER_TYPE:-chromium-headful}
      - BROWSER_REMOTE_DEBUGGING_URL=${BROWSER_REMOTE_DEBUGGING_URL:-http://127.0.0.1:9222}
      - BROWSER_REMOTE_DEBUGGING_HOST_HEADER=${BROWSER_REMOTE_DEBUGGING_HOST_HEADER:-}
      - BROWSER_CDP_CONNECT_TIMEOUT_MS=${BROWSER_CDP_CONNECT_TIMEOUT_MS:-120000}
      - DOWNLOAD_PATH=/data/downloads
      - BROWSER_SESSION_BASE_PATH=/data/browser_sessions
      - CREDENTIAL_VAULT_TYPE=${CREDENTIAL_VAULT_TYPE:-skyvern}
      - ENABLE_LOCAL_CREDENTIAL_VAULT=${ENABLE_LOCAL_CREDENTIAL_VAULT:-true}
      - LOCAL_CREDENTIAL_VAULT_PATH=/data/credential_vault
      - ENABLE_CODE_BLOCK=true
      # --- Control your own browser (Chrome/Chromium) ---
      # Prefer Chrome's chrome://inspect/#remote-debugging flow for an existing profile.
      # On Windows, scripts/windows_chrome_inspect_cdp.ps1 can bridge a
      # chrome://inspect/#remote-debugging listener and write the full ws:// URL.
      # If Docker cannot reach that listener, start an isolated Chrome profile
      # with --remote-debugging-address=0.0.0.0 and a non-default --user-data-dir.
      # Then set:
      # - BROWSER_TYPE=cdp-connect
      # - BROWSER_REMOTE_DEBUGGING_URL=http://host.docker.internal:9222/
      # See docs/developers/self-hosted/browser.mdx for Windows/Docker Desktop notes.
    # =========================
    #       LLM Settings - Use `skyvern init llm` for interactive setup
    # =========================
    # Docs: https://www.skyvern.com/docs/self-hosted/llm-configuration
    #
    # OpenAI:
    # - ENABLE_OPENAI=true
    # - LLM_KEY=OPENAI_GPT5_5
    # - OPENAI_API_KEY=
    #
    # Anthropic:
    # - ENABLE_ANTHROPIC=true
    # - LLM_KEY=ANTHROPIC_CLAUDE4.7_OPUS
    # - ANTHROPIC_API_KEY=
    #
    # Gemini:
    # - ENABLE_GEMINI=true
    # - LLM_KEY=GEMINI_3.0_FLASH
    # - GEMINI_API_KEY=
    #
    # Azure OpenAI:
    # - ENABLE_AZURE=true
    # - LLM_KEY=AZURE_OPENAI
    # - AZURE_DEPLOYMENT=
    # - AZURE_API_KEY=
    # - AZURE_API_BASE=
    # - AZURE_API_VERSION=2024-08-01-preview
    #
    # AWS Bedrock:
    # - ENABLE_BEDROCK=true
    # - LLM_KEY=BEDROCK_ANTHROPIC_CLAUDE4.7_OPUS_INFERENCE_PROFILE
    # - AWS_REGION=us-west-2
    # - AWS_ACCESS_KEY_ID=
    # - AWS_SECRET_ACCESS_KEY=
    #
    # Ollama (local models):
    # - ENABLE_OLLAMA=true
    # - LLM_KEY=OLLAMA
    # - OLLAMA_MODEL=gemma4:e4b
    # - OLLAMA_SERVER_URL=http://host.docker.internal:11434
    # - OLLAMA_SUPPORTS_VISION=false
    #
    # OpenRouter:
    # - ENABLE_OPENROUTER=true
    # - LLM_KEY=OPENROUTER
    # - OPENROUTER_API_KEY=
    # - OPENROUTER_MODEL=mistralai/mistral-small-3.1-24b-instruct
    #
    # Groq:
    # - ENABLE_GROQ=true
    # - LLM_KEY=GROQ
    # - GROQ_API_KEY=
    # - GROQ_MODEL=openai/gpt-oss-120b

    # Bitwarden Settings
    # If you are looking to integrate Skyvern with a password manager (eg Bitwarden), you can use the following environment variables.
    # - BITWARDEN_SERVER=http://localhost  # OPTIONAL IF YOU ARE SELF HOSTING BITWARDEN
    # - BITWARDEN_SERVER_PORT=8002 # IF YOU ARE SELF HOSTING BITWARDEN AND USE THIS COMPOSE FILE, PORT IS 8002 UNLESS CHANGED
    # - SKYVERN_AUTH_BITWARDEN_ORGANIZATION_ID=your-org-id-here
    # - SKYVERN_AUTH_BITWARDEN_CLIENT_ID=user.your-client-id-here
    # - SKYVERN_AUTH_BITWARDEN_CLIENT_SECRET=your-client-secret-here
    # - SKYVERN_AUTH_BITWARDEN_MASTER_PASSWORD=your-master-password-here

    # 1Password Integration
    # If you are looking to integrate Skyvern with 1Password, you can use the following environment variables.
    # OP_SERVICE_ACCOUNT_TOKEN=""
    depends_on:
      postgres:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8000/api/v1/heartbeat', timeout=5)"]
      interval: 5s
      timeout: 5s
      retries: 24
      start_period: 180s
  skyvern-ui:
    image: public.ecr.aws/skyvern/skyvern-ui:latest
    # For local UI development/testing, replace the image line above with:
    # build:
    #   context: .
    #   dockerfile: Dockerfile.ui
    restart: on-failure
    ports:
      - 8080:8080
      - 9090:9090
    volumes:
      - ./artifacts:/data/artifacts
      - ./videos:/data/videos
      - ./har:/data/har
      # Generated credentials allow the UI to pick up the local API key on first startup.
      - ./.skyvern:/app/.skyvern
    # User secrets and most frontend config live in skyvern-frontend/.env
    # (loaded via env_file). CDP streaming is inline so local livestreaming is
    # enabled even if an older frontend .env is present.
    env_file:
      - skyvern-frontend/.env
    environment:
      - VITE_BROWSER_STREAMING_MODE=${VITE_BROWSER_STREAMING_MODE:-cdp}
    #  - VITE_ENABLE_CODE_BLOCK=true
    # if you want to run skyvern on a remote server,
    # you need to change the host in VITE_WSS_BASE_URL and VITE_API_BASE_URL to match your server ip
    # If you're self-hosting this behind a dns, you'll want to set:
    #   A route for the API: api.yourdomain.com -> localhost:8000
    #   A route for the UI: yourdomain.com -> localhost:8080
    #   A route for the artifact API: artifact.yourdomain.com -> localhost:9090 (maybe not needed)
    # - VITE_WSS_BASE_URL=ws://localhost:8000/api/v1
    #   - VITE_ARTIFACT_API_BASE_URL=http://localhost:9090
    #   - VITE_API_BASE_URL=http://localhost:8000/api/v1
    #   - VITE_SKYVERN_API_KEY=
    depends_on:
      skyvern:
        condition: service_healthy

# uncomment for local usage of `vaultwarden` & bitwarden-cli - see more at: https://github.com/dani-garcia/vaultwarden
# First this container needs to be started and configured to sign up, create master password and organization
# Once created, under SETTINGS/SECURITY/KEYS/API you should be able to get client id and secret for CLI & Skyvern integrations
#  vaultwarden:
#    image: vaultwarden/server:latest-alpine
#    container_name: vaultwarden
#    restart: unless-stopped
#    environment:
#      # DOMAIN: "https://vaultwarden.example.com"  # required when using a reverse proxy; your domain; vaultwarden needs to know it's https to work properly with attachments
#      SIGNUPS_ALLOWED: "true" # Deactivate this with "false" after you have created your account so that no strangers can register
#    volumes:
#      - ~/vw-data/:/data/ # the path before the : can be changed
#    ports:
#      - 127.0.0.1:11002:80 # you can replace the 11002 with your preferred port

# Bitwarden CLI Server (provides REST API endpoints for Skyvern)
# Once you have master password and api credentials, you can set them below and this CLI should start providing secure access for Skyvern to Vaultwarden
#  bitwarden-cli:
#    build:
#      context: ./bitwarden-cli-server
#      dockerfile: Dockerfile
#    environment:
#      # Vaultwarden server URL
#      BW_HOST: "http://vaultwarden"
#      # API credentials for vaultwarden
#      BW_CLIENTID: "user.your-client-id-here"
#      BW_CLIENTSECRET: "your-client-secret-here"
#      # Master password for unlocking vault
#      BW_PASSWORD: "your-master-password-here"
#    ports:
#      # Bind to localhost only for security
#      - "127.0.0.1:8002:8087"
#    restart: unless-stopped
#    healthcheck:
#      test: [ "CMD", "curl", "-f", "http://localhost:8087/status" ]
#      interval: 30s
#      timeout: 10s
#      retries: 5
#      start_period: 30s
#    depends_on:
#      vaultwarden:
#        condition: service_healthy
#    volumes:
#      # Optional: persist Bitwarden CLI config
#      - ~/bitwarden-cli-config:/app/.config
#    labels:
#      - "traefik.enable=false"  # Don't expose via reverse proxy

1. Project Overview & Quickstart (Skyvern-AI/skyvern)

Skyvern automates browser-based workflows using LLMs and computer vision. It provides a Playwright-compatible SDK that adds AI functionality on top of playwright, as well as a no-code workflow builder to help both technical and non-technical users automate manual workflows on any website, replacing brittle or unreliable automation solutions.

Traditional approaches to browser automations required writing custom scripts for websites, often relying on DOM parsing and XPath-based interactions which would break whenever the website layouts changed.

Instead of only relying on code-defined XPath interactions, Skyvern relies on Vision LLMs to learn and interact with the websites.

How it works

Skyvern was inspired by the Task-Driven autonomous agent design popularized by BabyAGI and AutoGPT -- with one major bonus: we give Skyvern the ability to interact with websites using browser automation libraries like Playwright.

Skyvern uses a swarm of agents to comprehend a website, and plan and execute its actions:

This approach has a few advantages:

Skyvern can operate on websites it's never seen before, as it's able to map visual elements to actions necessary to complete a workflow, without any customized code
Skyvern is resistant to website layout changes, as there are no pre-determined XPaths or other selectors our system is looking for while trying to navigate
Skyvern is able to take a single workflow and apply it to a large number of websites, as it's able to reason through the interactions necessary to complete the workflow
A detailed technical report can be found here.

Demo

https://github.com/user-attachments/assets/5cab4668-e8e2-4982-8551-aab05ff73a7f

Quickstart

Skyvern Cloud

Skyvern Cloud is a managed cloud version of Skyvern that allows you to run Skyvern without worrying about the infrastructure. It allows you to run multiple Skyvern instances in parallel and comes bundled with anti-bot detection mechanisms, proxy network, and CAPTCHA solvers.

If you'd like to try it out, navigate to app.skyvern.com and create an account.

Run Locally (UI + Server)

Choose your preferred setup method:

Database default: skyvern quickstart and skyvern run server default to a SQLite database at ~/.skyvern/data.db so the pip path works without Postgres or Docker. To use Postgres instead, pass --database-string for an existing database (or omit --no-postgres so quickstart starts its own Postgres container). Docker Compose always uses the bundled Postgres service.

Option A: pip install (Recommended for Python-managed local setup)

Dependencies needed:

Python 3.11, 3.12, or 3.13

Additionally, for Windows:

Rust
VS Code with C++ dev tools and Windows SDK

1. Install Skyvern

bash

pip install "skyvern[all]"

2. Run Skyvern

bash

skyvern quickstart

The pip quickstart uses SQLite by default. To use a local Postgres container instead, run skyvern quickstart (Postgres container is started unless you pass --no-postgres), or connect to an existing database with --database-string=postgresql+psycopg://user:pass@host:5432/dbname.

Option B: Docker Compose

Use this option if you want everything containerized (Postgres, API, UI) and don't want to install Python/Node locally.

Install Docker Desktop

Clone the repository:

bash

git clone https://github.com/skyvern-ai/skyvern.git && cd skyvern

Configure your LLM provider in .env (the quickstart --docker-compose command below will create it from .env.example if missing):
bash
```
cp .env.example .env  # if not already created
# edit .env to add your LLM API key
```
Start everything:
bash
```
docker compose up -d
```
Open http://localhost:8080

Troubleshooting

(sqlite3.OperationalError) table organizations already exists — You hit a known bug in pip install skyvern==1.0.31. Fix:

bash

rm ~/.skyvern/data.db   # remove the leftover SQLite file
pip install --upgrade skyvern   # 1.0.32+ contains the fix
skyvern quickstart

If you are still on 1.0.31 and cannot upgrade, install via uv instead:

bash

uv pip install skyvern

pip install skyvern fails with ResolutionImpossible (litellm / fastmcp) — You hit a dependency-resolution conflict in 1.0.31. Either upgrade to 1.0.32+ or use uv: uv pip install skyvern.

SDK

Skyvern is a Playwright extension that adds AI-powered browser automation. It gives you the full power of Playwright with additional AI capabilities—use natural language prompts to interact with elements, extract data, and automate complex multi-step workflows.

Installation:

Python SDK / cloud API: pip install skyvern
Local server + packaged UI: pip install "skyvern[all]" then run skyvern quickstart
Local server + packaged UI with Postgres: pip install "skyvern[all]" then run skyvern quickstart --database-string=postgresql+psycopg://user:pass@host:5432/dbname
Packaged UI for an existing API: pip install "skyvern[ui]" then set VITE_API_BASE_URL (and VITE_SKYVERN_API_KEY if your API requires a key) and run skyvern run ui
TypeScript: npm install @skyvern/client

AI-Powered Page Commands

Skyvern adds four core AI commands directly on the page object:

Command	Description
`page.act(prompt)`	Perform actions using natural language (e.g., "Click the login button")
`page.extract(prompt, schema)`	Extract structured data from the page with optional JSON schema
`page.validate(prompt)`	Validate page state, returns `bool` (e.g., "Check if user is logged in")
`page.prompt(prompt, schema)`	Send arbitrary prompts to the LLM with optional response schema

Additionally, page.agent provides higher-level workflow commands:

Command	Description
`page.agent.run_task(prompt)`	Execute complex multi-step tasks
`page.agent.login(credential_type, credential_id)`	Authenticate with stored credentials (Skyvern, Bitwarden, 1Password)
`page.agent.download_files(prompt)`	Navigate and download files
`page.agent.run_workflow(workflow_id)`	Execute pre-built workflows

AI-Augmented Playwright Actions

All standard Playwright actions support an optional prompt parameter for AI-powered element location:

Action	Playwright	AI-Augmented
Click	`page.click("#btn")`	`page.click(prompt="Click login button")`
Fill	`page.fill("#email", "[email protected]")`	`page.fill(prompt="Email field", value="[email protected]")`
Select	`page.select_option("#country", "US")`	`page.select_option(prompt="Country dropdown", value="US")`
Upload	`page.upload_file("#file", "doc.pdf")`	`page.upload_file(prompt="Upload area", files="doc.pdf")`

Three interaction modes:

python

# 1. Traditional Playwright - CSS/XPath selectors
await page.click("#submit-button")

# 2. AI-powered - natural language
await page.click(prompt="Click the green Submit button")

# 3. AI fallback - tries selector first, falls back to AI if it fails
await page.click("#submit-btn", prompt="Click the Submit button")

Core AI Commands - Examples

python

# act - Perform actions using natural language
await page.act("Click the login button and wait for the dashboard to load")

# extract - Extract structured data with optional JSON schema
result = await page.extract("Get the product name and price")
result = await page.extract(
    prompt="Extract order details",
    schema={"order_id": "string", "total": "number", "items": "array"}
)

# validate - Check page state (returns bool)
is_logged_in = await page.validate("Check if the user is logged in")

# prompt - Send arbitrary prompts to the LLM
summary = await page.prompt("Summarize what's on this page")

Quick Start Examples

Run via UI:

bash

skyvern run all

Navigate to http://localhost:8080 to run tasks through the web interface. If the packaged UI is missing, skyvern run ui will offer to install the matching UI package.

To run only the packaged UI against an existing Skyvern API, install skyvern[ui] and set the
environment variables below before running skyvern run ui:

VITE_API_BASE_URL (e.g. http://localhost:8000/api/v1) — points the UI at your Skyvern API
VITE_SKYVERN_API_KEY — the API key if your API requires one
VITE_WSS_BASE_URL — WebSocket endpoint (inferred from VITE_API_BASE_URL if unset)
VITE_ARTIFACT_API_BASE_URL — base URL for artifact downloads
VITE_BROWSER_STREAMING_MODE — browser viewport streaming mode

Python SDK:

python

from skyvern import Skyvern

# Local mode
skyvern = Skyvern.local()

# Or connect to Skyvern Cloud
skyvern = Skyvern(api_key="your-api-key")

# Launch browser and get page
browser = await skyvern.launch_cloud_browser()
page = await browser.get_working_page()

# Mix Playwright with AI-powered actions
await page.goto("https://example.com")
await page.click("#login-button")  # Traditional Playwright
await page.agent.login(credential_type="skyvern", credential_id="cred_123")  # AI login
await page.click(prompt="Add first item to cart")  # AI-augmented click
await page.agent.run_task("Complete checkout with: John Snow, 12345")  # AI task

TypeScript SDK:

typescript

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

const skyvern = new Skyvern({ apiKey: "your-api-key" });
const browser = await skyvern.launchCloudBrowser();
const page = await browser.getWorkingPage();

// Mix Playwright with AI-powered actions
await page.goto("https://example.com");
await page.click("#login-button");  // Traditional Playwright
await page.agent.login("skyvern", { credentialId: "cred_123" });  // AI login
await page.click({ prompt: "Add first item to cart" });  // AI-augmented click
await page.agent.runTask("Complete checkout with: John Snow, 12345");  // AI task

await browser.close();

Simple task execution:

python

from skyvern import Skyvern

skyvern = Skyvern()
task = await skyvern.run_task(prompt="Find the top post on hackernews today")
print(task)

Advanced Usage

Control your own browser (Chrome)

Let Skyvern control your existing Chrome browser — with all your cookies, logins, and extensions.

Step 1: Enable remote debugging in Chrome

Open Chrome and navigate to chrome://inspect/#remote-debugging
Click Enable to start the debugging server
You should see: Server running at: 127.0.0.1:9222

[!TIP]
The skyvern init browser command can do this automatically — it opens chrome://inspect/#remote-debugging, waits for you to enable it, and saves the config.

Step 2: Connect Skyvern

Option A — Python Code:

python

from skyvern import Skyvern

skyvern = Skyvern(
    base_url="http://localhost:8000",
    api_key="YOUR_API_KEY",
    browser_address="http://127.0.0.1:9222",
)
task = await skyvern.run_task(
    prompt="Find the top post on hackernews today",
)

Option B — Skyvern Service:

Add two variables to your .env file:

bash

BROWSER_TYPE=cdp-connect
BROWSER_REMOTE_DEBUGGING_URL=http://127.0.0.1:9222

Restart Skyvern service skyvern run all and run the task through UI or code

Connect Skyvern Cloud to your local browser

Let Skyvern Cloud control a Chrome browser running on your machine — with all your existing cookies, logins, and extensions. Useful for automating sites where you're already logged in or behind a VPN.

bash

# One command to start Chrome + create a tunnel to Skyvern Cloud
skyvern browser serve --tunnel

Then use the tunnel URL in your task:

python

from skyvern import Skyvern

skyvern = Skyvern(api_key="your-api-key")
task = await skyvern.run_task(
    prompt="Download the latest invoice from my account",
    browser_address="https://abc123.ngrok-free.dev",
)

[!WARNING]
Always use --api-key when exposing your browser via a tunnel. Without it, anyone with the URL has full control of your browser. See the security docs.

See the full documentation for all options, manual tunnel setup, and troubleshooting.

Get consistent output schema from your run

You can do this by adding the data_extraction_schema parameter:

python

from skyvern import Skyvern

skyvern = Skyvern()
task = await skyvern.run_task(
    prompt="Find the top post on hackernews today",
    data_extraction_schema={
        "type": "object",
        "properties": {
            "title": {
                "type": "string",
                "description": "The title of the top post"
            },
            "url": {
                "type": "string",
                "description": "The URL of the top post"
            },
            "points": {
                "type": "integer",
                "description": "Number of points the post has received"
            }
        }
    }
)

Helpful commands to debug issues

bash

# Launch the Skyvern Server Separately*
skyvern run server

# Launch the Skyvern UI
skyvern run ui

# Check status of the Skyvern service
skyvern status

# Stop the Skyvern service
skyvern stop all

# Stop the Skyvern UI
skyvern stop ui

# Stop the Skyvern Server Separately
skyvern stop server

Performance & Evaluation

Skyvern has SOTA performance on the WebBench benchmark with a 64.4% accuracy. The technical report + evaluation can be found here

Performance on WRITE tasks (eg filling out forms, logging in, downloading files, etc)

Skyvern is the best performing agent on WRITE tasks (eg filling out forms, logging in, downloading files, etc), which is primarily used for RPA (Robotic Process Automation) adjacent tasks.

Skyvern Features

Skyvern Tasks

Tasks are the fundamental building block inside Skyvern. Each task is a single request to Skyvern, instructing it to navigate through a website and accomplish a specific goal.

Tasks require you to specify a url, prompt, and can optionally include a data schema (if you want the output to conform to a specific schema) and error codes (if you want Skyvern to stop running in specific situations).

Skyvern Workflows

Workflows are a way to chain multiple tasks together to form a cohesive unit of work.

For example, if you wanted to download all invoices newer than January 1st, you could create a workflow that first navigated to the invoices page, then filtered down to only show invoices newer than January 1st, extracted a list of all eligible invoices, and iterated through each invoice to download it.

Another example is if you wanted to automate purchasing products from an e-commerce store, you could create a workflow that first navigated to the desired product, then added it to a cart. Second, it would navigate to the cart and validate the cart state. Finally, it would go through the checkout process to purchase the items.

Supported workflow features include:

Browser Task
Browser Action
Data Extraction
Validation
For Loops
File parsing
Sending emails
Text Prompts
HTTP Request Block
Custom Code Block
Uploading files to block storage
(Coming soon) Conditionals

Livestreaming

Skyvern allows you to livestream the viewport of the browser to your local machine so that you can see exactly what Skyvern is doing on the web. This is useful for debugging and understanding how Skyvern is interacting with a website, and intervening when necessary

Form Filling

Skyvern is natively capable of filling out form inputs on websites. Passing in information via the navigation_goal will allow Skyvern to comprehend the information and fill out the form accordingly.

Data Extraction

Skyvern is also capable of extracting data from a website.

You can also specify a data_extraction_schema directly within the main prompt to tell Skyvern exactly what data you'd like to extract from the website, in jsonc format. Skyvern's output will be structured in accordance to the supplied schema.

File Downloading

Skyvern is also capable of downloading files from a website. All downloaded files are automatically uploaded to block storage (if configured), and you can access them via the UI.

Authentication

Skyvern supports a number of different authentication methods to make it easier to automate tasks behind a login. If you'd like to try it out, please reach out to us via email or discord.

🔐 2FA Support (TOTP)

Skyvern supports a number of different 2FA methods to allow you to automate workflows that require 2FA.

Examples include:

QR-based 2FA (e.g. Google Authenticator, Authy)
Email based 2FA
SMS based 2FA

🔐 Learn more about 2FA support here.

Password Manager Integrations

Skyvern currently supports the following password manager integrations:

Bitwarden
Custom Credential Service (HTTP API)
1Password
LastPass

Model Context Protocol (MCP)

Skyvern supports the Model Context Protocol (MCP) to allow you to use any LLM that supports MCP.

See the MCP documentation here

Zapier / Make.com / N8N Integration

Skyvern supports Zapier, Make.com, and N8N to allow you to connect your Skyvern workflows to other apps.

🔐 Learn more about 2FA support here.

Real-world examples of Skyvern

We love to see how Skyvern is being used in the wild. Here are some examples of how Skyvern is being used to automate workflows in the real world. Please open PRs to add your own examples!

Invoice Downloading on many different websites

Book a demo to see it live

Automate the job application process

💡 See it in action

Automate materials procurement for a manufacturing company

💡 See it in action

Navigating to government websites to register accounts or fill out forms

💡 See it in action

Filling out random contact us forms

💡 See it in action

Retrieving insurance quotes from insurance providers in any language

💡 See it in action

Contributor Setup

Make sure to have uv installed.

Run this to create your virtual environment (.venv)
bash
```
uv sync --group dev
```
Perform initial server configuration
bash
```
uv run skyvern quickstart
```
Navigate to http://localhost:8080 in your browser to start using the UI
The Skyvern CLI supports Windows, WSL, macOS, and Linux environments.

Documentation

More extensive documentation can be found on our 📕 docs page. Please let us know if something is unclear or missing by opening an issue or reaching out to us via email or discord.

Supported LLMs

Provider	Supported Models
OpenAI	GPT-5.5, GPT-5.4, GPT-5, GPT-4.1, o3, o4-mini
Anthropic	Claude 4.7 Opus, Claude 4.6 (Sonnet, Opus), Claude 4.5 (Haiku, Sonnet, Opus)
Azure OpenAI	Any GPT models deployed to your Azure subscription
AWS Bedrock	Claude 4.7, Claude 4.6 (Sonnet, Opus), Claude 4.5 (Sonnet, Opus)
Gemini	Gemini 3.1 Pro, Gemini 3 Flash, Gemini 2.5 Pro/Flash
Ollama	Run any locally hosted model via Ollama
OpenRouter	Access models through OpenRouter
OpenAI-compatible	Any custom API endpoint that follows OpenAI's API format (via liteLLM)

For detailed LLM configuration including all available model keys, environment variables, and multi-model setups, see the LLM Configuration docs.

Contributing

We welcome PRs and suggestions! Don't hesitate to open a PR/issue or to reach out to us via email or discord.
Please have a look at our contribution guide and
"Help Wanted" issues to get started!

If you want to chat with the skyvern repository to get a high level overview of how it is structured, how to build off it, and how to resolve usage questions, check out Code Sage.

Telemetry

By Default, Skyvern collects basic usage statistics to help us understand how Skyvern is being used. If you would like to opt-out of telemetry, please set the SKYVERN_TELEMETRY environment variable to false.

License

Skyvern's open source repository is supported via a managed cloud. All of the core logic powering Skyvern is available in this open source repository licensed under the AGPL-3.0 License, with the exception of anti-bot measures available in our managed cloud offering.

If you have any questions or concerns around licensing, please contact us and we would be happy to help.

Star History

2. Official Technical Reference & Guides (Skyvern-AI/docs)

👩‍💻 Development

Install the Mintlify CLI to preview the documentation changes locally. To install, use the following command

text

npm i mintlify

Run the following command at the root of your documentation (where mint.json is). Currently mintlify only supports node version of v19. Run nvm use 19 if you have a different node version before running the following command.

text

mintlify dev

😎 Publishing Changes

Changes will be deployed to production automatically after pushing to the default branch.

You can also preview changes using PRs, which generates a preview link of the docs.

Troubleshooting

Mintlify dev isn't running - Run mintlify install it'll re-install dependencies.
Page loads as a 404 - Make sure you are running in a folder with mint.json

Docker & Self-Hosted Deployment Verified OCI

1. Project Overview & Quickstart (Skyvern-AI/skyvern) Copy Chapter

How it works

Demo

Quickstart

Skyvern Cloud Copy Chapter

Run Locally (UI + Server) Copy Chapter

Option A: pip install (Recommended for Python-managed local setup) Copy Section

1. Install Skyvern

2. Run Skyvern

Option B: Docker Compose Copy Section

Troubleshooting Copy Section

SDK Copy Chapter

AI-Powered Page Commands Copy Section

AI-Augmented Playwright Actions Copy Section

Core AI Commands - Examples Copy Section

Quick Start Examples Copy Section

Advanced Usage Copy Chapter

Control your own browser (Chrome) Copy Section

Step 1: Enable remote debugging in Chrome

Step 2: Connect Skyvern

Connect Skyvern Cloud to your local browser Copy Section

Get consistent output schema from your run Copy Section

Helpful commands to debug issues Copy Section

Performance & Evaluation

Performance on WRITE tasks (eg filling out forms, logging in, downloading files, etc) Copy Chapter

Skyvern Features

Skyvern Tasks Copy Chapter

Skyvern Workflows Copy Chapter

Livestreaming Copy Chapter

Form Filling Copy Chapter

Data Extraction Copy Chapter

File Downloading Copy Chapter

Authentication Copy Chapter

🔐 2FA Support (TOTP) Copy Section

Password Manager Integrations Copy Section

Model Context Protocol (MCP) Copy Chapter

Zapier / Make.com / N8N Integration Copy Chapter

Real-world examples of Skyvern

Invoice Downloading on many different websites Copy Chapter

Automate the job application process Copy Chapter

Automate materials procurement for a manufacturing company Copy Chapter

Navigating to government websites to register accounts or fill out forms Copy Chapter

Filling out random contact us forms Copy Chapter

Retrieving insurance quotes from insurance providers in any language Copy Chapter

Contributor Setup

Documentation

Supported LLMs

Contributing

Telemetry

License

Star History

2. Official Technical Reference & Guides (Skyvern-AI/docs) Copy Chapter

👩‍💻 Development Copy Section

😎 Publishing Changes Copy Section

Troubleshooting

Explore Related Technologies & Topics

1. Project Overview & Quickstart (Skyvern-AI/skyvern)

Skyvern Cloud

Run Locally (UI + Server)

Option A: pip install (Recommended for Python-managed local setup)

Option B: Docker Compose

Troubleshooting

SDK

AI-Powered Page Commands

AI-Augmented Playwright Actions

Core AI Commands - Examples

Quick Start Examples

Advanced Usage

Control your own browser (Chrome)

Connect Skyvern Cloud to your local browser

Get consistent output schema from your run

Helpful commands to debug issues

Performance on WRITE tasks (eg filling out forms, logging in, downloading files, etc)

Skyvern Tasks

Skyvern Workflows

Livestreaming

Form Filling

Data Extraction

File Downloading

Authentication

🔐 2FA Support (TOTP)

Password Manager Integrations

Model Context Protocol (MCP)

Zapier / Make.com / N8N Integration

Invoice Downloading on many different websites

Automate the job application process

Automate materials procurement for a manufacturing company

Navigating to government websites to register accounts or fill out forms

Filling out random contact us forms

Retrieving insurance quotes from insurance providers in any language

2. Official Technical Reference & Guides (Skyvern-AI/docs)

👩‍💻 Development

😎 Publishing Changes