# Jev AI Browser Task Agent (`rainminer/jev-browser-agent-scraper`) Actor

Plain-English browser tasks on Apify. TypeSafe AI's Jev picks each click and fill in a stealth Cloak browser. One instruction covers consent and your goal. Reuse session id for cookies and sticky proxy.

- **URL**: https://apify.com/rainminer/jev-browser-agent-scraper.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** AI, Automation
- **Stats:** 3 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 jev input tokens (1k)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Jev Browser Agent

**Plain-English browser automation on Apify** powered by **[TypeSafe Jev](https://docs.typesafe.ai/introduction)** — structured click/fill/scroll decisions in milliseconds, not a full chat model on every step. You send a **start URL** and an **instruction**; the Actor runs a **real anti-detect browser**, handles **cookie and consent interstitials** as part of the same goal, and returns **structured JSON** (summary, URLs, step log, billing breakdown).

[![Jev Browser Agent](https://api.apify.com/v2/key-value-stores/vdPXKRB5smkRYhtEV/records/jev-browser-agent-scraper-banner.jpg)](https://apify.com/rainminer/jev-browser-agent-scraper)

***

### What you get (under the hood, without you wiring it)

| Layer                                                                 | What it does for you                                                               |
| --------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| **[Cloak Browser](https://cloakbrowser.dev/)**                        | Stealth Chromium profile per `sessionId` — fewer bot blocks on real sites          |
| **[jev-ultrafast](https://github.com/browser-use/jev-ultrafast)**     | Official Jev loop: numbered controls `[N]`, one System One call per step           |
| **[Browser Harness](https://github.com/browser-use/browser-harness)** | Reliable CDP execution (click, type, scroll) against the live page                 |
| **OpenRouter**                                                        | `jev-latest` for decisions; small chat model only when Jev picks **TYPE\_TEXT**     |
| **Apify session store**                                               | Cookies + Cloak profile tarball restored on the next run with the same id          |
| **Apify Proxy (optional)**                                            | Sticky session id tied to `sessionId` when you enable residential/datacenter proxy |

You describe the task once. The agent does not stop at a consent screen and ask you to continue — **consent, blockers, and your goal are one continuous run**.

***

### What is Jev Browser Agent?

**Jev Browser Agent** opens a public page, builds an accessibility-style **action table** from what is on screen, and repeats:

1. **Jev** chooses the next operation (click, type, scroll, select, done) and which `[N]` target fits your instruction.
2. The browser **executes** it over CDP.
3. The Actor **logs** each step until Jev marks the goal **done** or step budget is reached.

Reuse **`sessionId`** (`demo`, `flights-research`, …) to bring back **cookies and browser profile** from the named store `jev-browser-sessions`. Use **`resetSession`** when you want a clean computer.

Public pages only — no username/password inputs.

***

### Who uses Jev Browser Agent?

- **QA engineers** smoke-testing signup, checkout, or settings flows in English—with a step log in JSON
- **Product managers** asking “is this flow still working?” without maintaining Playwright scripts
- **Agencies** handing clients a **session id** instead of fragile cookie exports
- **Researchers** revisiting a public dashboard on a schedule with restored cookies
- **Support teams** reproducing a UI path with a structured step log
- **Indie hackers** validating a competitor pricing or onboarding path before shipping
- **Ops teams** filling the same public form every morning with a saved browser profile
- **Travel shoppers** running multi-step flight or hotel searches with sticky residential proxy
- **Localization checks** opening the same site from a geo-stable session
- **Builders** replacing a chat “computer use” demo with an API they can schedule on Apify
- **Analysts** capturing structured JSON (summary, steps, URLs) after a manual-style browse

***

### What can this agent do?

- **Multi-step flows** from one instruction (forms, search, filters, date pickers, wizards)
- **Consent and GDPR banners** dismissed as part of reaching your goal (not a separate mode)
- **Persistent sessions** — log in once on a public site, continue later with the same `sessionId`
- **Sticky proxy** — same IP across runs when Apify Proxy is on
- **Evidence** — structured `steps` with tool, target, success, and Jev action labels
- **API / schedule** — same Actor from Console, REST, Zapier, Make, or n8n

#### Example instructions

- *Add two todos on the demo list and confirm both titles appear.*
- *Search flights from Sofia to Berlin, departure October 5 2026, economy, stop when priced results show.*
- *Open the pricing page, switch to annual billing, and stop when the price is visible.*

***

### Why Jev instead of a chat computer-use loop?

| Chat agent (typical)           | Jev Browser Agent                                        |
| ------------------------------ | -------------------------------------------------------- |
| Large LLM call every tool step | **System One** structured choice over visible controls   |
| Slow, costly on long flows     | **Sub-second** routing per step in practice              |
| Fragile free-form coordinates  | **Indexed refs** from a live snapshot                    |
| Opaque “I clicked something”   | **Calibrated probabilities** and step log in the dataset |

Fill text is still generated when Jev selects a field — via OpenRouter chat — but **navigation and clicks stay on Jev**, not on a general-purpose chat model.

***

### Dataset output

One row per run (see **Overview** in the dataset). Highlights:

| Field                      | What you get                                                             |
| -------------------------- | ------------------------------------------------------------------------ |
| `summary`                  | Plain-language outcome                                                   |
| `finalUrl`                 | Last page URL                                                            |
| `sessionRestored`          | Whether cookies/profile were loaded                                      |
| `stepCount` / `durationMs` | Steps taken and wall time                                                |
| `steps`                    | Each action (`click`, `fill`, …), target ref, success flag, detail label |
| `billing`                  | PPE `chargedEvents` and estimated total (charged at exit on every run that reached the agent) |
| `error`                    | Message if the session failed or Jev blocked                             |

Full **`OUTPUT`** is also written to the default key-value store for the run.

***

### How to run

1. Open [Jev Browser Agent](https://apify.com/rainminer/jev-browser-agent-scraper) → **Try for free**
2. **Start URL** — public https page (prefill: TodoMVC demo)
3. **Instruction** — what to accomplish, in English
4. **Session id** — keep stable to restore cookies; **`resetSession`** for a fresh profile
5. **Maximum steps** — default 15; raise for long flows (e.g. travel search)
6. **Proxy** — enable Apify residential proxy for strict sites; sticky session uses `sessionId`
7. Start the run → read the dataset row and **`OUTPUT`** in the key-value store

***

### Input

| Input                | Description                                         |
| -------------------- | --------------------------------------------------- |
| `startUrl`           | Public page to open                                 |
| `instruction`        | Task in natural language                            |
| `sessionId`          | Named computer (cookies + Cloak profile persist)    |
| `maxItems`           | Max Jev steps per run                               |
| `resetSession`       | Wipe saved profile for this id before start         |
| `proxyConfiguration` | Optional Apify Proxy (residential prefill on cloud) |

***

### Pricing

Three lines on your bill:

| Line | What it is |
| --- | --- |
| **Platform usage** | **`platform-usage-micro`** — charged once at exit for **Apify platform usage** on this run (compute, proxy, storage). See `billing.platformUsageUsd` on the dataset row. |
| **Jev input tokens** | **`jev-input-1k-tokens`** — per **1,000 input tokens** to TypeSafe Jev (System One), rounded up (**$0.001** / 1K). |
| **LLM text tokens** | **`llm-text-1k-tokens`** — per **1,000 tokens** from OpenRouter fill-text calls, rounded up (**$0.001** / 1K). |

All three lines are pay-per-event on the Actor (no separate platform-usage invoice line).

Successful runs include **`billing`** on the dataset row: `platformUsageUsd`, `chargedEvents`, and token counts. Failed or partial runs are billed the same way at exit (platform + tokens consumed).

***

### Limitations

- **Public data only** — no credential or login-wall scraping
- Heavy anti-bot sites may need **residential proxy** and a dedicated `sessionId`
- Very large pages may clip snapshot text for Jev’s context
- Jev only acts on **observed** controls; custom widgets may need scroll or extra steps

***

### Image Credit

Image credit: [TypeSafe — Introducing System One models and Jev](https://typesafe.ai/blog/introducing-system-one-models-and-jev)

# Actor input Schema

## `startUrl` (type: `string`):

Page to open at the start of this session. Required unless startUrls is set. The next run with the same session id continues from saved cookies, not necessarily this URL.

## `startUrls` (type: `array`):

Optional fallback when Start URL is empty. Only the first http(s) URL is used.

## `instruction` (type: `string`):

What the browser agent should do, in plain English. One Jev agent handles consent or blockers when they appear, then continues the same goal. TypeSafe Jev (jev-ultrafast) picks each click/fill/scroll step from the live page element table.

## `sessionId` (type: `string`):

Named computer. The same id restores cookies, local storage, and the sticky proxy on the next invoke. Use different ids for unrelated workflows.

## `maxItems` (type: `integer`):

Maximum agent tool steps in this run. Keep small for cheap tests.

## `resetSession` (type: `boolean`):

Delete saved cookies and profile for this session id before starting, so the computer is empty.

## `proxyConfiguration` (type: `object`):

Optional proxy. When Apify Proxy is on, the same session id is reused as a sticky session so the IP stays stable across invokes.

## Actor input object example

```json
{
  "startUrl": "https://demo.playwright.dev/todomvc",
  "instruction": "Open the page. Add a todo called Buy groceries, then add another todo called Walk the dog. Report the two items you see.",
  "sessionId": "demo",
  "maxItems": 15,
  "resetSession": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `output` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrl": "https://demo.playwright.dev/todomvc",
    "instruction": "Open the page. Add a todo called Buy groceries, then add another todo called Walk the dog. Report the two items you see.",
    "sessionId": "demo",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/jev-browser-agent-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrl": "https://demo.playwright.dev/todomvc",
    "instruction": "Open the page. Add a todo called Buy groceries, then add another todo called Walk the dog. Report the two items you see.",
    "sessionId": "demo",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/jev-browser-agent-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrl": "https://demo.playwright.dev/todomvc",
  "instruction": "Open the page. Add a todo called Buy groceries, then add another todo called Walk the dog. Report the two items you see.",
  "sessionId": "demo",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rainminer/jev-browser-agent-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/jev-browser-agent-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/YxrMXbiQLUdKWoPLc/builds/bLoMyEbgZtG9eFQ79/openapi.json