Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

migrated Target to Page

Gregor Žunič504f8cad0941
diff --git a/browser_use/actor/README.md b/browser_use/actor/README.md
index 7814c17f9..327cae3d7 100644
--- a/browser_use/actor/README.md
+++ b/browser_use/actor/README.md
@@ -1,135 +1,189 @@
# Browser Actor
-Browser Actor is a web automation library built directly on CDP.
+Browser Actor is a web automation library built on CDP (Chrome DevTools Protocol) that provides low-level browser automation capabilities within the browser-use ecosystem.
## Usage
-### Option 1: Direct CDP Usage
+### Integrated with BrowserSession (Recommended)
```python
-from cdp_use import CDPClient
-from browser_use.actor import Target, Element, Mouse
-
-# Create client directly - no Browser class needed
-client = CDPClient(ws_url)
-```
-
-### Option 2: Integrated with Browser (Recommended)
-```python
-from browser_use import Browser
+from browser_use import Browser # Alias for BrowserSession
# Create and start browser session
browser = Browser()
await browser.start()
-# Use integrated browser methods directly
-target = await browser.new_target("https://example.com")
-targets = await browser.get_targets()
-current_target = await browser.get_current_target()
+# Create new tabs and navigate
+page = await browser.new_page("https://example.com")
+pages = await browser.get_pages()
+current_page = await browser.get_current_page()
```
+### Direct Page Access (Advanced)
```python
-# Get targets (multiple ways) - using browser methods
-target = await browser.new_target() # Create blank tab
-target = await browser.new_target("https://example.com") # Create tab with URL
-targets = await browser.get_targets() # Get all existing tabs
+from browser_use.actor import Page, Element, Mouse
+
+# Create page with existing browser session
+page = Page(browser_session, target_id, session_id)
+```
-# Navigate target to URL
-await target.goto("https://example.com")
+## Basic Operations
-await browser.close_target(target)
+```python
+# Tab Management
+page = await browser.new_page() # Create blank tab
+page = await browser.new_page("https://example.com") # Create tab with URL
+pages = await browser.get_pages() # Get all existing tabs
+await browser.close_page(page) # Close specific tab
+
+# Navigation
+await page.goto("https://example.com")
+await page.go_back()
+await page.go_forward()
+await page.reload()
```
+## Element Operations
+
```python
# Find elements by CSS selector
-elements = await target.get_elements_by_css_selector("input[type='text']")
-buttons = await target.get_elements_by_css_selector("button.submit")
+elements = await page.get_elements_by_css_selector("input[type='text']")
+buttons = await page.get_elements_by_css_selector("button.submit")
# Get element by backend node ID
-element = await target.get_element(backend_node_id=12345)
+element = await page.get_element(backend_node_id=12345)
+
+# AI-powered element finding (requires LLM)
+element = await page.get_element_by_prompt("search button", llm=your_llm)
+element = await page.must_get_element_by_prompt("login form", llm=your_llm)
```
-Unlike other libraries, the native implementation for `get_elements_by_css_selector` does not support waiting for the element to be visible.
+> **Note**: `get_elements_by_css_selector` returns immediately without waiting for visibility.
+
+## Element Interactions
```python
# Element actions
await element.click(button='left', click_count=1, modifiers=['Control'])
-await element.fill("Hello World")
+await element.fill("Hello World") # Clears first, then types
await element.hover()
await element.focus()
-await element.check()
-await element.select_option(["option1", "option2"])
+await element.check() # Toggle checkbox/radio
+await element.select_option(["option1", "option2"]) # For dropdown/select
+await element.drag_to(target_element) # Drag and drop
-# Element properties
+# Element properties
value = await element.get_attribute("value")
-box = await element.get_bounding_box()
-info = await element.get_basic_info()
+box = await element.get_bounding_box() # Returns BoundingBox or None
+info = await element.get_basic_info() # Comprehensive element info
+screenshot_b64 = await element.screenshot(format='jpeg')
```
+## Mouse Operations
+
```python
# Mouse operations
-mouse = await target.mouse
-await mouse.click(x=100, y=200, button='left')
-await mouse.move(x=300, y=400)
+mouse = await page.mouse
+await mouse.click(x=100, y=200, button='left', click_count=1)
+await mouse.move(x=300, y=400, steps=1)
+await mouse.down(button='left') # Press button
+await mouse.up(button='left') # Release button
+await mouse.scroll(x=0, y=100, delta_x=0, delta_y=-500) # Scroll at coordinates
+```
+
+## Page Operations
+
+```python
+# JavaScript evaluation
+result = await page.evaluate('() => document.title') # Must use arrow function format
+result = await page.evaluate('(x, y) => x + y', 10, 20) # With arguments
+
+# Keyboard input
+await page.press("Control+A") # Key combinations supported
+await page.press("Escape") # Single keys
+
+# Page controls
+await page.set_viewport_size(width=1920, height=1080)
+page_screenshot = await page.screenshot() # JPEG by default
+page_png = await page.screenshot(format="png", quality=90)
+
+# Page information
+url = await page.get_url()
+title = await page.get_title()
```
+## AI-Powered Features
+
```python
-# Target operations
-mouse = await target.mouse
-await mouse.scroll(x=0, y=100, delta_y=-500) # x,y (coordinates to scroll on), delta_y (how much to scroll)
-await target.press("Control+A") # Key combinations supported
-await target.press("Escape")
-await target.set_viewport_size(width=1920, height=1080)
-await target.reload()
-page_screenshot = await target.screenshot() # JPEG by default
-page_png = await target.screenshot(format="png")
+# Content extraction using LLM
+from pydantic import BaseModel
+
+class ProductInfo(BaseModel):
+ name: str
+ price: float
+ description: str
+
+# Extract structured data from current page
+products = await page.extract_content(
+ "Find all products with their names, prices and descriptions",
+ ProductInfo,
+ llm=your_llm
+)
```
## Core Classes
-- **Browser**: Main browser session with integrated browser methods
-- **Target**, **Element**, **Mouse**: Core classes for browser operations
+- **BrowserSession** (aliased as **Browser**): Main browser session manager with tab operations
+- **Page**: Represents a single browser tab or iframe for page-level operations
+- **Element**: Individual DOM element for interactions and property access
+- **Mouse**: Mouse operations within a page (click, move, scroll)
## API Reference
-### Browser Methods (Browser Operations)
-- `new_target(url=None)` → `Target` - Create blank tab or navigate to URL
-- `get_targets()` → `list[Target]` - Get all page/iframe targets
-- `close_target(target: Target | str)` - Close target by object or ID
-- `cookies(urls=None)` → `list[Cookie]` - Get cookies for specified URLs (or all if None)
-- `clear_cookies()` - Clear all cookies
-- `get_current_target()` → `Target | None` - Get the current target
-
-### Target Methods
+### BrowserSession Methods (Tab Management)
+- `start()` - Initialize and start the browser session
+- `stop()` - Stop the browser session (keeps browser alive)
+- `kill()` - Kill the browser process and reset all state
+- `new_page(url=None)` → `Page` - Create blank tab or navigate to URL
+- `get_pages()` → `list[Page]` - Get all available pages
+- `get_current_page()` → `Page | None` - Get the currently focused page
+- `close_page(page: Page | str)` - Close page by object or ID
+- Session management and CDP client operations
+
+### Page Methods (Page Operations)
- `get_elements_by_css_selector(selector: str)` → `list[Element]` - Find elements by CSS selector
- `get_element(backend_node_id: int)` → `Element` - Get element by backend node ID
-- `goto(url: str)` - Navigate this target to URL
-- `go_back()`, `go_forward()` - Navigate target history (with proper error handling)
-- `evaluate(page_function: str, *args)` → `str` - Execute JavaScript (MUST use (...args) => format) and return string (objects/arrays are JSON-stringified)
+- `get_element_by_prompt(prompt: str, llm)` → `Element | None` - AI-powered element finding
+- `must_get_element_by_prompt(prompt: str, llm)` → `Element` - AI element finding (raises if not found)
+- `extract_content(prompt: str, structured_output: type[T], llm)` → `T` - Extract structured data using LLM
+- `goto(url: str)` - Navigate this page to URL
+- `go_back()`, `go_forward()` - Navigate history (with error handling)
+- `reload()` - Reload the current page
+- `evaluate(page_function: str, *args)` → `str` - Execute JavaScript (MUST use (...args) => format)
- `press(key: str)` - Press key on page (supports "Control+A" format)
- `set_viewport_size(width: int, height: int)` - Set viewport dimensions
-- `reload()` - Reload the current page
-- `screenshot(format='jpeg', quality=None)` → `str` - Take page screenshot and return base64
-- `get_url()` → `str`, `get_title()` → `str` - Get page info
+- `screenshot(format='jpeg', quality=None)` → `str` - Take page screenshot, return base64
+- `get_url()` → `str`, `get_title()` → `str` - Get page information
+- `mouse` → `Mouse` - Get mouse interface for this page
-### Element Methods (Supported Only)
-- `click(button='left', click_count=1, modifiers=None)` - Click element
-- `fill(text: str)` - Fill input with text (clears first)
+### Element Methods (DOM Interactions)
+- `click(button='left', click_count=1, modifiers=None)` - Click element with advanced fallbacks
+- `fill(text: str, clear_existing=True)` - Fill input with text (clears first by default)
- `hover()` - Hover over element
- `focus()` - Focus the element
- `check()` - Toggle checkbox/radio button (clicks to change state)
-- `select_option(values: str | list[str])` - Select dropdown options (string or array)
-- `drag_to(target: Element | Position, source_position=None, target_position=None)` - Drag to target
+- `select_option(values: str | list[str])` - Select dropdown options
+- `drag_to(target_element: Element | Position, source_position=None, target_position=None)` - Drag to target element
- `get_attribute(name: str)` → `str | None` - Get attribute value
- `get_bounding_box()` → `BoundingBox | None` - Get element position/size
-- `screenshot(format='jpeg', quality=None)` → `str` - Take element screenshot and return base64
+- `screenshot(format='jpeg', quality=None)` → `str` - Take element screenshot, return base64
- `get_basic_info()` → `ElementInfo` - Get comprehensive element information
-### Mouse Methods
+### Mouse Methods (Coordinate-Based Operations)
- `click(x: int, y: int, button='left', click_count=1)` - Click at coordinates
- `move(x: int, y: int, steps=1)` - Move to coordinates
-- `down(button='left')`, `up(button='left')` - Press/release button
-- `scroll(x=0, y=0, delta_x=None, delta_y=None)` - Scroll page (x,y coordinates to scroll on, delta_x/delta_y how much to scroll)
+- `down(button='left', click_count=1)`, `up(button='left', click_count=1)` - Press/release button
+- `scroll(x=0, y=0, delta_x=None, delta_y=None)` - Scroll page at coordinates
## Type Definitions
@@ -152,33 +206,39 @@ class BoundingBox(TypedDict):
### ElementInfo
```python
class ElementInfo(TypedDict):
- backend_node_id: int
- node_id: int | None
- node_name: str
- node_type: int
- node_value: str | None
- attributes: dict[str, str]
- bounding_box: BoundingBox | None
+ backendNodeId: int # CDP backend node ID
+ nodeId: int | None # CDP node ID
+ nodeName: str # HTML tag name (e.g., "DIV", "INPUT")
+ nodeType: int # DOM node type
+ nodeValue: str | None # Text content for text nodes
+ attributes: dict[str, str] # HTML attributes
+ boundingBox: BoundingBox | None # Element position and size
+ error: str | None # Error message if info retrieval failed
```
-## Important LLM Usage Notes
+## Important Usage Notes
+
+**This is browser-use actor, NOT Playwright or Selenium.** Only use the methods documented above.
-**This is NOT Playwright.**. You can NOT use other methods than the ones described here. Key constraints for code generation:
+### Critical JavaScript Rules
+- `page.evaluate()` MUST use `(...args) => {}` arrow function format
+- Always returns string (objects are JSON-stringified automatically)
+- Use single quotes around the function: `page.evaluate('() => document.title')`
+- For complex selectors in JS: `'() => document.querySelector("input[name=\\"email\\"]")'`
-**CRITICAL JAVASCRIPT EVALUATION RULES:**
-- `target.evaluate()` MUST use (...args) => format and always returns string (objects become JSON strings)
-- **STRING QUOTES**: Always use `target.evaluate('...')` (single quotes outside, double inside for CSS)
-- **CSS SELECTORS**: Use `"input[name=\\"email\\"]"` format inside evaluate calls
-- **ESCAPING**: Use `\\"` to escape double quotes inside selectors, never mix quote patterns
+### Method Restrictions
+- `get_elements_by_css_selector()` returns immediately (no automatic waiting)
+- For dropdowns: use `element.select_option()`, NOT `element.fill()`
+- Form submission: click submit button or use `page.press("Enter")`
+- No methods like: `element.submit()`, `element.dispatch_event()`, `element.get_property()`
-**METHOD RESTRICTIONS:**
-- `get_elements_by_css_selector()` returns immediately, no waiting
-- For dropdowns: use `element.select_option("value")` or `element.select_option(["val1", "val2"])`, not `element.fill()`
-- No methods: `element.submit()`, `element.dispatch_event()`, `element.get_property()`, `target.query_selector_all()`
-- Form submission: click submit button or use `target.press("Enter")`
-- Get properties: use `target.evaluate("() => element.value")` not `element.get_property()`
+### Error Prevention
+- Always verify page state changes with `page.get_url()`, `page.get_title()`
+- Use `element.get_attribute()` to check element properties
+- Validate CSS selectors before use
+- Handle navigation timing with appropriate `asyncio.sleep()` calls
-**ERROR PREVENTION:**
-- Loop prevention: verify page state changes with `target.get_url()`, `target.get_title()`, `element.get_attribute()`
-- Validate selectors before use: ensure no excessive escaping like `\\\\\\\\`
-- Test complex selectors: if a selector fails, simplify it step by step
+### AI Features
+- `get_element_by_prompt()` and `extract_content()` require an LLM instance
+- These methods use DOM analysis and structured output parsing
+- Best for complex page understanding and data extraction tasks
diff --git a/browser_use/actor/__init__.py b/browser_use/actor/__init__.py
index 176a51c41..840572a98 100644
--- a/browser_use/actor/__init__.py
+++ b/browser_use/actor/__init__.py
@@ -5,6 +5,6 @@ A Playwright-like library built on top of CDP (Chrome DevTools Protocol).
from .element import Element
from .mouse import Mouse
-from .target import Target
+from .page import Page
-__all__ = ['Target', 'Element', 'Mouse']
+__all__ = ['Page', 'Element', 'Mouse']
diff --git a/browser_use/actor/target.py b/browser_use/actor/page.py
similarity index 99%
rename from browser_use/actor/target.py
rename to browser_use/actor/page.py
index 49acddbe4..bed479e45 100644
--- a/browser_use/actor/target.py
+++ b/browser_use/actor/page.py
@@ -1,4 +1,4 @@
-"""Target class for target-level operations."""
+"""Page class for page-level operations."""
from typing import TYPE_CHECKING, TypeVar
@@ -34,8 +34,8 @@ if TYPE_CHECKING:
from .mouse import Mouse
-class Target:
- """Target operations (tab or iframe)."""
+class Page:
+ """Page operations (tab or iframe)."""
def __init__(
self, browser_session: 'BrowserSession', target_id: str, session_id: str | None = None, llm: 'BaseChatModel | None' = None
diff --git a/browser_use/actor/playground/flights.py b/browser_use/actor/playground/flights.py
index ab74bd429..417be8684 100644
--- a/browser_use/actor/playground/flights.py
+++ b/browser_use/actor/playground/flights.py
@@ -14,17 +14,17 @@ async def main():
browser = Browser(keep_alive=True)
await browser.start()
- target = await browser.get_current_target() or await browser.new_target()
+ page = await browser.get_current_page() or await browser.new_page()
# Go to apple wikipedia page
- await target.goto('https://www.google.com/travel/flights')
+ await page.goto('https://www.google.com/travel/flights')
await asyncio.sleep(1)
- round_trip_button = await target.must_get_element_by_prompt('round trip button', llm)
+ round_trip_button = await page.must_get_element_by_prompt('round trip button', llm)
await round_trip_button.click()
- one_way_button = await target.must_get_element_by_prompt('one way button', llm)
+ one_way_button = await page.must_get_element_by_prompt('one way button', llm)
await one_way_button.click()
await asyncio.sleep(1)
diff --git a/browser_use/actor/playground/mixed_automation.py b/browser_use/actor/playground/mixed_automation.py
index 3683c9661..d33377b7a 100644
--- a/browser_use/actor/playground/mixed_automation.py
+++ b/browser_use/actor/playground/mixed_automation.py
@@ -31,14 +31,14 @@ async def main():
browser = Browser(keep_alive=True)
await browser.start()
- target = await browser.get_current_target() or await browser.new_target()
+ page = await browser.get_current_page() or await browser.new_page()
# Go to apple wikipedia page
- await target.goto('https://browser-use.github.io/stress-tests/challenges/angularjs-form.html')
+ await page.goto('https://browser-use.github.io/stress-tests/challenges/angularjs-form.html')
await asyncio.sleep(1)
- element = await target.get_element_by_prompt('zip code input', llm)
+ element = await page.get_element_by_prompt('zip code input', llm)
print('Element found', element)
diff --git a/browser_use/actor/playground/playground.py b/browser_use/actor/playground/playground.py
index 1a234e665..d732ff5ae 100755
--- a/browser_use/actor/playground/playground.py
+++ b/browser_use/actor/playground/playground.py
@@ -34,21 +34,21 @@ async def main():
# Navigate to Wikipedia using integrated methods
logger.info('📖 Navigating to Wikipedia...')
- target = await browser.new_target('https://en.wikipedia.org')
+ page = await browser.new_page('https://en.wikipedia.org')
# Get basic page info
- url = await target.get_url()
- title = await target.get_title()
+ url = await page.get_url()
+ title = await page.get_title()
logger.info(f'📄 Page loaded: {title} ({url})')
# Take a screenshot
logger.info('📸 Taking initial screenshot...')
- screenshot_b64 = await target.screenshot()
+ screenshot_b64 = await page.screenshot()
logger.info(f'📸 Screenshot captured: {len(screenshot_b64)} bytes')
# Set viewport size
logger.info('🖥️ Setting viewport to 1920x1080...')
- await target.set_viewport_size(1920, 1080)
+ await page.set_viewport_size(1920, 1080)
# Execute some JavaScript to count links
logger.info('🔍 Counting article links using JavaScript...')
@@ -66,12 +66,12 @@ async def main():
};
}"""
- link_info = json.loads(await target.evaluate(js_code))
+ link_info = json.loads(await page.evaluate(js_code))
logger.info(f'🔗 Found {link_info["total"]} article links')
# Try to find and interact with links using CSS selector
try:
# Find article links on the page
- links = await target.get_elements_by_css_selector('a[href*="/wiki/"]:not([href*=":"])')
+ links = await page.get_elements_by_css_selector('a[href*="/wiki/"]:not([href*=":"])')
if links:
logger.info(f'📋 Found {len(links)} wiki links via CSS selector')
@@ -107,8 +107,8 @@ async def main():
await asyncio.sleep(3)
# Get new page info
- new_url = await target.get_url()
- new_title = await target.get_title()
+ new_url = await page.get_url()
+ new_title = await page.get_title()
logger.info(f'📄 Navigated to: {new_title}')
logger.info(f'🌐 New URL: {new_url}')
else:
@@ -119,7 +119,7 @@ async def main():
# Scroll down the page
logger.info('📜 Scrolling down the page...')
- mouse = await target.mouse
+ mouse = await page.mouse
await mouse.scroll(x=0, y=100, delta_y=500)
await asyncio.sleep(1)
@@ -132,17 +132,17 @@ async def main():
logger.info('🧪 Testing JavaScript evaluation...')
# Simple expressions
- page_height = await target.evaluate('() => document.body.scrollHeight')
- current_scroll = await target.evaluate('() => window.pageYOffset')
+ page_height = await page.evaluate('() => document.body.scrollHeight')
+ current_scroll = await page.evaluate('() => window.pageYOffset')
logger.info(f'📏 Page height: {page_height}px, current scroll: {current_scroll}px')
# JavaScript with arguments
- result = await target.evaluate('(x) => x * 2', 21)
+ result = await page.evaluate('(x) => x * 2', 21)
logger.info(f'🧮 JavaScript with args: 21 * 2 = {result}')
# More complex JavaScript
page_stats = json.loads(
- await target.evaluate("""() => {
+ await page.evaluate("""() => {
return {
url: window.location.href,
title: document.title,
@@ -156,43 +156,43 @@ async def main():
logger.info(f'📊 Page stats: {page_stats}')
# Get page title using different methods
- title_via_js = await target.evaluate('() => document.title')
- title_via_api = await target.get_title()
+ title_via_js = await page.evaluate('() => document.title')
+ title_via_api = await page.get_title()
logger.info(f'📝 Title via JS: "{title_via_js}"')
logger.info(f'📝 Title via API: "{title_via_api}"')
# Take a final screenshot
logger.info('📸 Taking final screenshot...')
- final_screenshot = await target.screenshot()
+ final_screenshot = await page.screenshot()
logger.info(f'📸 Final screenshot: {len(final_screenshot)} bytes')
# Test browser navigation with error handling
logger.info('⬅️ Testing browser back navigation...')
try:
- await target.go_back()
+ await page.go_back()
await asyncio.sleep(2)
- back_url = await target.get_url()
- back_title = await target.get_title()
+ back_url = await page.get_url()
+ back_title = await page.get_title()
logger.info(f'📄 After going back: {back_title}')
logger.info(f'🌐 Back URL: {back_url}')
except RuntimeError as e:
logger.info(f'ℹ️ Navigation back failed as expected: {e}')
- # Test creating new target
- logger.info('🆕 Creating new blank target...')
- new_target = await browser.new_target()
- new_target_url = await new_target.get_url()
- logger.info(f'🆕 New target created with URL: {new_target_url}')
+ # Test creating new page
+ logger.info('🆕 Creating new blank page...')
+ new_page = await browser.new_page()
+ new_page_url = await new_page.get_url()
+ logger.info(f'🆕 New page created with URL: {new_page_url}')
- # Get all targets
- all_targets = await browser.get_targets()
- logger.info(f'📑 Total targets: {len(all_targets)}')
+ # Get all pages
+ all_pages = await browser.get_pages()
+ logger.info(f'📑 Total pages: {len(all_pages)}')
# Test form interaction if we can find a form
try:
# Look for search input on the page
- search_inputs = await target.get_elements_by_css_selector('input[type="search"], input[name*="search"]')
+ search_inputs = await page.get_elements_by_css_selector('input[type="search"], input[name*="search"]')
if search_inputs:
search_input = search_inputs[0]
@@ -200,7 +200,7 @@ async def main():
await search_input.focus()
await search_input.fill('test search query')
- await target.press('Enter')
+ await page.press('Enter')
logger.info('✅ Form interaction test completed')
else:
@@ -209,11 +209,11 @@ async def main():
except Exception as e:
logger.info(f'ℹ️ Form interaction test skipped: {e}')
- # wait 2 seconds before closing the new target
- logger.info('🕒 Waiting 2 seconds before closing the new target...')
+ # wait 2 seconds before closing the new page
+ logger.info('🕒 Waiting 2 seconds before closing the new page...')
await asyncio.sleep(2)
- logger.info('🗑️ Closing new target...')
- await browser.close_target(new_target)
+ logger.info('🗑️ Closing new page...')
+ await browser.close_page(new_page)
logger.info('✅ Playground completed successfully!')
diff --git a/browser_use/browser/session.py b/browser_use/browser/session.py
index e8c9fb1eb..b4a5b41f5 100644
--- a/browser_use/browser/session.py
+++ b/browser_use/browser/session.py
@@ -43,7 +43,7 @@ from browser_use.observability import observe_debug
from browser_use.utils import _log_pretty_url, is_new_tab_page
if TYPE_CHECKING:
- from browser_use.actor.target import Target
+ from browser_use.actor.page import Page
DEFAULT_BROWSER_PROFILE = BrowserProfile()
@@ -844,8 +844,8 @@ class BrowserSession(BaseModel):
assert self._cdp_client_root is not None, 'CDP client not initialized - browser may not be connected yet'
return self._cdp_client_root
- async def new_target(self, url: str | None = None) -> 'Target':
- """Create a new target (tab)."""
+ async def new_page(self, url: str | None = None) -> 'Page':
+ """Create a new page (tab)."""
from cdp_use.cdp.target.commands import CreateTargetParameters
params: CreateTargetParameters = {'url': url or 'about:blank'}
@@ -854,28 +854,36 @@ class BrowserSession(BaseModel):
target_id = result['targetId']
# Import here to avoid circular import
- from browser_use.actor.target import Target
+ from browser_use.actor.page import Page as Target
return Target(self, target_id)
- async def get_current_target(self) -> 'Target | None':
- """Get the current target as an actor Target."""
+ async def get_current_page(self) -> 'Page | None':
+ """Get the current page as an actor Page."""
target_info = await self.get_current_target_info()
if not target_info:
return None
- from browser_use.actor.target import Target
+ from browser_use.actor.page import Page as Target
return Target(self, target_info['targetId'])
- async def get_targets(self) -> list['Target']:
- """Get all available targets."""
+ async def must_get_current_page(self) -> 'Page':
+ """Get the current page as an actor Page."""
+ page = await self.get_current_page()
+ if not page:
+ raise RuntimeError('No current target found')
+
+ return page
+
+ async def get_pages(self) -> list['Page']:
+ """Get all available pages."""
result = await self.cdp_client.send.Target.getTargets()
targets = []
# Import here to avoid circular import
- from browser_use.actor.target import Target
+ from browser_use.actor.page import Page as Target
for target_info in result['targetInfos']:
if target_info['type'] in ['page', 'iframe']:
@@ -883,17 +891,17 @@ class BrowserSession(BaseModel):
return targets
- async def close_target(self, target: 'Union[Target, str]') -> None:
- """Close a target by Target object or target ID."""
+ async def close_page(self, page: 'Union[Page, str]') -> None:
+ """Close a page by Page object or target ID."""
from cdp_use.cdp.target.commands import CloseTargetParameters
# Import here to avoid circular import
- from browser_use.actor.target import Target
+ from browser_use.actor.page import Page as Target
- if isinstance(target, Target):
- target_id = target._target_id
+ if isinstance(page, Target):
+ target_id = page._target_id
else:
- target_id = str(target)
+ target_id = str(page)
params: CloseTargetParameters = {'targetId': target_id}
await self.cdp_client.send.Target.closeTarget(params)
diff --git a/examples/custom-functions/actor_use.py b/examples/custom-functions/actor_use.py
new file mode 100644
index 000000000..20c4cd895
--- /dev/null
+++ b/examples/custom-functions/actor_use.py
@@ -0,0 +1,38 @@
+import asyncio
+import os
+import sys
+
+from browser_use.browser.session import BrowserSession
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from browser_use import ActionResult, Agent, ChatOpenAI, Tools
+
+tools = Tools()
+
+llm = ChatOpenAI(model='gpt-4.1-mini')
+
+
[email protected]('Click on submit button')
+async def click_submit_button(browser_session: BrowserSession):
+ page = await browser_session.must_get_current_page()
+
+ submit_button = await page.must_get_element_by_prompt('submit button', llm)
+ await submit_button.click()
+
+ return ActionResult(is_done=True, extracted_content='Submit button clicked!')
+
+
+async def main():
+ task = 'go to brower-use.com and then click on the submit button'
+ agent = Agent(task=task, llm=llm, tools=tools)
+
+ await agent.run()
+
+
+if __name__ == '__main__':
+ asyncio.run(main())