> ## Documentation Index
> Fetch the complete documentation index at: https://docs.stagehand.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Observe
> Discover and plan executable actions on any web page
## What is `observe()`?
```typescript theme={null}
await stagehand.observe("find the login button");
```
```python theme={null}
await stagehand.observe("find the login button")
```
```go theme={null}
instruction := "find the login button"
if _, err := client.Observe(ctx, &instruction, nil); err != nil {
return err
}
```
`observe()` discovers actionable elements on a page and returns structured actions you can execute or validate before acting. Use it to explore pages, plan multi-step workflows, cache actions, and validate elements before acting.
## Why use `observe()`?
Discover what's possible on a page: find buttons, forms, links, and interactive elements
Map out multi-step workflows by discovering all required actions upfront
Store discovered actions to skip LLM calls and speed up repeated workflows
Verify elements exist and check their properties before performing critical actions
## Using `observe()`
Use `observe()` to discover actionable elements on a page. Here's how to find a button:
```typescript theme={null}
const [page] = await browser.context.pages();
if (!page) {
throw new Error("Stagehand initialized without an active page");
}
await page.goto("https://example.com");
const { data: actions } = await stagehand.observe("find the learn more button");
```
```python theme={null}
page = (await browser.context.pages())[0]
if page is None:
raise RuntimeError("Stagehand initialized without an active page")
await page.goto("https://example.com")
result = await stagehand.observe("find the learn more button")
```
```go theme={null}
page, err := browserContext.ActivePage(ctx)
if err != nil {
return err
}
if page == nil {
return errors.New("Stagehand initialized without an active page")
}
if _, err := page.Goto(ctx, "https://example.com", nil); err != nil {
return err
}
instruction := "find the learn more button"
result, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
fmt.Println("found", len(result.Data), "actions")
```
**iFrame and Shadow DOM support** Stagehand automatically handles iFrame traversal and shadow DOM elements without requiring additional configuration.
| Use Case | Example instruction |
| ----------------- | ----------------------------------- |
| Find buttons | `find the submit button` |
| Locate forms | `find all input fields in the form` |
| Discover links | `find navigation links` |
| Identify tables | `find the pricing table` |
| Map workflows | `find all checkout steps` |
| Validate elements | `find the delete account button` |
### Return value of `observe()`
When you use `observe()`, Stagehand returns a result whose `data` field is a list of `Action` objects, alongside `metadata` carrying the action ID and server-side cache status. Each `Action` can be passed straight to [`act()`](/v4/basics/act) for deterministic replay:
```typescript theme={null}
[
{
description: 'Learn more button',
method: 'click',
arguments: [],
selector: 'xpath=/html[1]/body[1]/shadow-demo[1]//div[1]/button[1]'
}
]
```
```python theme={null}
[
Action(
description="Learn more button",
method="click",
arguments=[],
selector="xpath=/html[1]/body[1]/shadow-demo[1]//div[1]/button[1]",
)
]
```
```go theme={null}
clickMethod := "click"
actions := []stagehand.Action{
{
Description: "Learn more button",
Method: &clickMethod,
Arguments: []string{},
Selector: "xpath=/html[1]/body[1]/shadow-demo[1]//div[1]/button[1]",
},
}
fmt.Println(actions[0].Description, *actions[0].Method, actions[0].Selector)
```
Use specific, descriptive instructions.
```typescript theme={null}
// Clear and specific
await stagehand.observe("find the primary call-to-action button in the hero section");
await stagehand.observe("find all input fields in the checkout form");
await stagehand.observe("find the delete account button in settings");
```
```python theme={null}
# Clear and specific
await stagehand.observe(
"find the primary call-to-action button in the hero section"
)
await stagehand.observe("find all input fields in the checkout form")
await stagehand.observe("find the delete account button in settings")
```
```go theme={null}
// Clear and specific
hero := "find the primary call-to-action button in the hero section"
if _, err := client.Observe(ctx, &hero, nil); err != nil {
return err
}
fields := "find all input fields in the checkout form"
if _, err := client.Observe(ctx, &fields, nil); err != nil {
return err
}
deleteButton := "find the delete account button in settings"
if _, err := client.Observe(ctx, &deleteButton, nil); err != nil {
return err
}
```
Avoid vague or data-oriented queries.
```typescript theme={null}
// Too vague
await stagehand.observe("find buttons");
// Use extract() for data instead
await stagehand.observe("what is the page title?");
```
```python theme={null}
# Too vague
await stagehand.observe("find buttons")
# Use extract() for data instead
await stagehand.observe("what is the page title?")
```
```go theme={null}
// Too vague
vague := "find buttons"
if _, err := client.Observe(ctx, &vague, nil); err != nil {
return err
}
// Use Extract() for data instead
title := "what is the page title?"
if _, err := client.Observe(ctx, &title, nil); err != nil {
return err
}
```
## Advanced configuration
You can pass additional options to configure the model, timeout, locator scope, ignored page regions, and placeholder variables:
```typescript theme={null}
const page = await stagehand.browser.context.activePage();
// Custom model configuration
const { data: actions } = await stagehand.observe("find navigation links", {
model: {
modelName: "openai/gpt-5.4-mini",
apiKey: process.env.OPENAI_API_KEY,
},
timeout: 30000,
locator: page.locator("xpath=//header"), // Focus on specific area
});
```
```python theme={null}
import os
from stagehand import ModelConfig
page = await stagehand.browser.context.active_page()
# Custom model configuration
result = await stagehand.observe(
"find navigation links",
model=ModelConfig(
model_name="openai/gpt-5.4-mini",
api_key=os.environ["OPENAI_API_KEY"],
),
timeout=30000,
locator=page.locator("xpath=//header"), # Focus on specific area
)
```
```go theme={null}
// Custom model configuration
modelAPIKey := os.Getenv("OPENAI_API_KEY")
model := stagehand.ModelConfig{
ModelName: "openai/gpt-5.4-mini",
APIKey: &modelAPIKey,
}
timeout := 30000.0
instruction := "find navigation links"
result, err := client.Observe(ctx, &instruction, &stagehand.StagehandClientObserveOptions{
Page: page,
Model: &model,
Timeout: &timeout,
Locator: page.Locator("xpath=//header"), // Focus on specific area
})
if err != nil {
return err
}
fmt.Println("found", len(result.Data), "navigation links")
```
You can also exclude specific nodes, including their descendant nodes, with ignored locators.
```typescript theme={null}
const page = await stagehand.browser.context.activePage();
const { data: actions } = await stagehand.observe("find the main call-to-action buttons", {
ignoreLocators: [
page.locator("xpath=//aside[contains(@class, 'promo-rail')]"),
page.locator("xpath=//div[@id='floating-chat-launcher']"),
page.locator("xpath=//section[@aria-label='recommended articles']"),
],
});
```
```python theme={null}
page = await stagehand.browser.context.active_page()
result = await stagehand.observe(
"find the main call-to-action buttons",
ignore_locators=[
page.locator("xpath=//aside[contains(@class, 'promo-rail')]"),
page.locator("xpath=//div[@id='floating-chat-launcher']"),
page.locator("xpath=//section[@aria-label='recommended articles']"),
],
)
```
```go theme={null}
instruction := "find the main call-to-action buttons"
result, err := client.Observe(ctx, &instruction, &stagehand.StagehandClientObserveOptions{
Page: page,
IgnoreLocators: []*stagehand.PageLocator{
page.Locator("xpath=//aside[contains(@class, 'promo-rail')]"),
page.Locator("xpath=//div[@id='floating-chat-launcher']"),
page.Locator("xpath=//section[@aria-label='recommended articles']"),
},
})
if err != nil {
return err
}
fmt.Println("found", len(result.Data), "call-to-action buttons")
```
`ignoreLocators` remove each resolved locator target and its descendants from the snapshot. A locator without `nth` removes all matching targets; a locator with `nth` removes only that indexed match. The `locator` option scopes observation to one resolved subtree, using `nth` when present.
Scoped `observe` currently supports CSS and XPath locators. `text=` locators are supported by locator methods, but not yet by observe snapshot scoping.
### Validate then act with variables
For login and other safety-sensitive flows, use `observe()` to discover candidate actions, validate them, and then execute them. When you pass variables, `observe()` returns `%variableName%` placeholders in the suggested action arguments instead of raw secret values, so no secret ever reaches the model.
```typescript theme={null}
const { data: actions } = await stagehand.observe("find the login form fields", {
variables: {
username: { value: "user@example.com", description: "The login email" },
password: { value: process.env.USER_PASSWORD, description: "The login password" },
},
});
const emailField = actions.find((action) => action.arguments?.includes("%username%"));
const passwordField = actions.find((action) => action.arguments?.includes("%password%"));
if (emailField && passwordField) {
// Replay the observed actions, resolving placeholders locally
await stagehand.act(emailField, { variables: { username: "user@example.com" } });
await stagehand.act(passwordField, { variables: { password: process.env.USER_PASSWORD } });
}
```
```python theme={null}
observed = await stagehand.observe(
"find the login form fields",
variables={
"username": {"value": "user@example.com", "description": "The login email"},
"password": {
"value": os.environ["USER_PASSWORD"],
"description": "The login password",
},
},
)
email_field = next(
(a for a in observed.data if "%username%" in (a.arguments or [])), None
)
password_field = next(
(a for a in observed.data if "%password%" in (a.arguments or [])), None
)
if email_field is not None and password_field is not None:
# Replay the observed actions, resolving placeholders locally
await stagehand.act(email_field, variables={"username": "user@example.com"})
await stagehand.act(
password_field, variables={"password": os.environ["USER_PASSWORD"]}
)
```
```go theme={null}
usernameDescription := "The login email"
passwordDescription := "The login password"
password := os.Getenv("USER_PASSWORD")
instruction := "find the login form fields"
result, err := client.Observe(ctx, &instruction, &stagehand.StagehandClientObserveOptions{
ObserveOptions: stagehand.ObserveOptions{
Variables: stagehand.Variables{
"username": stagehand.DescribedVariable(stagehand.DescribedVariableValue{
Value: stagehand.StringVariable("user@example.com"),
Description: &usernameDescription,
}),
"password": stagehand.DescribedVariable(stagehand.DescribedVariableValue{
Value: stagehand.StringVariable(password),
Description: &passwordDescription,
}),
},
},
})
if err != nil {
return err
}
var emailField, passwordField *stagehand.Action
for i, action := range result.Data {
if slices.Contains(action.Arguments, "%username%") {
emailField = &result.Data[i]
}
if slices.Contains(action.Arguments, "%password%") {
passwordField = &result.Data[i]
}
}
if emailField != nil && passwordField != nil {
// Replay the observed actions, resolving placeholders locally
if _, err := client.Act(ctx, stagehand.ObservedAction(*emailField), &stagehand.StagehandClientActOptions{
ActOptions: stagehand.ActOptions{
Variables: stagehand.Variables{
"username": stagehand.PrimitiveVariable(stagehand.StringVariable("user@example.com")),
},
},
}); err != nil {
return err
}
if _, err := client.Act(ctx, stagehand.ObservedAction(*passwordField), &stagehand.StagehandClientActOptions{
ActOptions: stagehand.ActOptions{
Variables: stagehand.Variables{
"password": stagehand.PrimitiveVariable(stagehand.StringVariable(password)),
},
},
}); err != nil {
return err
}
}
```
`act()` supports the same variables option with either input form. Pass an instruction when you want Stagehand to locate the field for you, or pass the observed `Action` to replay a known target, in both cases keeping the value out of the prompt.
### Server-side caching
`cache` requires a Browserbase browser and a Browserbase API key. It has no effect on local browsers.
When running on Browserbase, Stagehand can cache `observe()` results server-side. Repeated calls with the same inputs return instantly without consuming LLM tokens. Enable caching on the constructor and override it per call:
Locator-scoped observations, including calls with `locator` or `ignoreLocators`, bypass the server-side cache and report `metadata.cache.status` as `DISABLED`.
```typescript theme={null}
import { browserbase, Stagehand } from "@browserbasehq/stagehand";
// Enable server-side caching for the entire instance
const browser = await browserbase.launch({
apiKey: process.env.BROWSERBASE_API_KEY,
});
const stagehand = await Stagehand.create({
browser,
cache: true,
});
// Or disable it for a single call
const { data: actions } = await stagehand.observe("find the login button", { cache: false });
```
```python theme={null}
import os
from stagehand import Stagehand, browserbase
# Enable server-side caching for the entire instance
browser = await browserbase.launch(
api_key=os.environ["BROWSERBASE_API_KEY"],
)
stagehand = await Stagehand.create(
browser=browser,
cache=True,
)
# Or disable it for a single call
result = await stagehand.observe("find the login button", cache=False)
```
```go theme={null}
// Enable server-side caching for the entire instance
apiKey := os.Getenv("BROWSERBASE_API_KEY")
instanceCache := stagehand.CacheEnabled(true)
browser, err := stagehand.LaunchBrowserbase(ctx, stagehand.BrowserbaseLaunchOptions{APIKey: apiKey})
if err != nil {
return err
}
client, err := stagehand.Create(ctx, stagehand.CreateOptions{
Browser: browser,
Cache: &instanceCache,
})
// Or disable it for a single call
off := stagehand.CacheEnabled(false)
instruction := "find the login button"
result, err := client.Observe(ctx, &instruction, &stagehand.StagehandClientObserveOptions{
ObserveOptions: stagehand.ObserveOptions{Cache: &off},
})
if err != nil {
return err
}
fmt.Println(result.Metadata.Cache.Status) // "HIT", "MISS", or "DISABLED"
```
Cache status is reported on the result metadata, alongside the observed actions. You can also see it in the [Browserbase session replay dashboard](https://docs.browserbase.com/features/observability#stagehand) or in the session logs at debug level.
### Using with custom pages
Stagehand v4 drives the browser directly over the Chrome DevTools Protocol, so there is no Puppeteer, Playwright, or Patchright page interop. Instead, target any page Stagehand manages by passing the `page` option:
```typescript theme={null}
const browser = await browserbase.launch({
apiKey: process.env.BROWSERBASE_API_KEY,
});
const stagehand = await Stagehand.create({ browser });
// Open a second page in the same browser context
const productsPage = await browser.context.newPage("https://www.example.com/products");
// Use observe with that specific page
const { data: actions } = await stagehand.observe("find all product cards", {
page: productsPage,
});
```
```python theme={null}
browser = await browserbase.launch(
api_key=os.environ["BROWSERBASE_API_KEY"],
)
stagehand = await Stagehand.create(browser=browser)
# Open a second page in the same browser context
products_page = await browser.context.new_page("https://www.example.com/products")
# Use observe with that specific page
result = await stagehand.observe(
"find all product cards",
page=products_page,
)
```
```go theme={null}
apiKey := os.Getenv("BROWSERBASE_API_KEY")
browser, err := stagehand.LaunchBrowserbase(ctx, stagehand.BrowserbaseLaunchOptions{APIKey: apiKey})
if err != nil {
return err
}
client, err := stagehand.Create(ctx, stagehand.CreateOptions{Browser: browser})
if err != nil {
return err
}
browserContext, err := browser.Context()
if err != nil {
return err
}
// Open a second page in the same browser context
productsPage, err := browserContext.NewPage(ctx, "https://www.example.com/products")
if err != nil {
return err
}
// Use Observe with that specific page
instruction := "find all product cards"
result, err := client.Observe(ctx, &instruction, &stagehand.StagehandClientObserveOptions{
Page: productsPage,
})
if err != nil {
return err
}
fmt.Println("found", len(result.Data), "product cards")
```
This works with:
* **Active page:** omit `page` and Stagehand uses the active page (default)
* **Existing pages:** index into the list of context pages
* **New pages:** create one on the context
* **Existing browsers:** attach to a browser you already run with `localBrowser.connect()`
See the full `Stagehand` reference for detailed parameter documentation, return values, and advanced examples.
## Best practices
### Plan then execute
Discover all actions once, then feed each one back to `act()`. Passing an action rather than a string skips inference, so the loop below makes one model call for the whole form instead of one per field.
```typescript theme={null}
const { data: formFields } = await stagehand.observe("find all form input fields");
for (const field of formFields) {
// No LLM call: Stagehand replays the observed action
await stagehand.act(field);
}
```
```python theme={null}
observed = await stagehand.observe("find all form input fields")
for field in observed.data:
# No LLM call: Stagehand replays the observed action
await stagehand.act(field)
```
```go theme={null}
instruction := "find all form input fields"
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
for _, field := range observed.Data {
// No LLM call: Stagehand replays the observed action
if _, err := client.Act(ctx, stagehand.ObservedAction(field), nil); err != nil {
return err
}
}
```
Complete guide to planning actions with `observe()`.
### Scope extractions
Use `observe()` to find a container, then create a page locator from the observed selector and pass that locator to `extract()`. Extraction then sees only that subtree instead of the whole page, so token usage falls in proportion to how much of the page you exclude.
```typescript theme={null}
const PricingSchema = z.object({
tiers: z.array(
z.object({
name: z.string(),
price: z.string(),
}),
),
});
const { data: tables } = await stagehand.observe("find the pricing table");
const [table] = tables;
const page = await stagehand.browser.context.activePage();
const { data: pricing } = await stagehand.extract(
"extract all pricing tiers",
PricingSchema,
{ locator: page.locator(table.selector) },
);
for (const tier of pricing.tiers) {
console.log(tier.name, tier.price);
}
```
```python theme={null}
class PricingTier(BaseModel):
name: str
price: str
class Pricing(BaseModel):
tiers: list[PricingTier]
observed = await stagehand.observe("find the pricing table")
page = await stagehand.browser.context.active_page()
pricing = (await stagehand.extract(
"extract all pricing tiers",
Pricing,
locator=page.locator(observed.data[0].selector),
)).data
for tier in pricing.tiers:
print(tier.name, tier.price)
```
```go theme={null}
type pricingTier struct {
Name string `json:"name"`
Price string `json:"price"`
}
type pricingTiers struct {
Tiers []pricingTier `json:"tiers"`
}
instruction := "find the pricing table"
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
if len(observed.Data) == 0 {
return errors.New("pricing table not found")
}
pricing, err := stagehand.Extract[pricingTiers](
ctx,
client,
"extract all pricing tiers",
&stagehand.StagehandClientExtractOptions{
Page: page,
Locator: page.Locator(observed.Data[0].Selector),
},
)
if err != nil {
return err
}
for _, tier := range pricing.Data.Tiers {
fmt.Println(tier.Name, tier.Price)
}
```
Learn how to use `observe()` with `extract()` for precise data extraction.
### Validate before acting
Check elements exist and verify their properties before performing critical operations.
```typescript theme={null}
const { data: buttons } = await stagehand.observe("find the delete account button");
const [deleteButton] = buttons;
if (deleteButton?.method === "click") {
await stagehand.act(deleteButton);
} else {
throw new Error("Delete button not found");
}
```
```python theme={null}
observed = await stagehand.observe("find the delete account button")
delete_button = observed.data[0] if observed.data else None
if delete_button is not None and delete_button.method == "click":
await stagehand.act(delete_button)
else:
raise RuntimeError("Delete button not found")
```
```go theme={null}
instruction := "find the delete account button"
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
if len(observed.Data) == 0 || observed.Data[0].Method == nil || *observed.Data[0].Method != "click" {
return errors.New("Delete button not found")
}
if _, err := client.Act(ctx, stagehand.ObservedAction(observed.Data[0]), nil); err != nil {
return err
}
```
Learn how to execute observed actions reliably.
### Cache observed actions
Store and reuse observed actions to eliminate redundant LLM calls. Build a simple in-process cache:
```typescript theme={null}
const actionCache = new Map();
async function cachedObserve(instruction: string) {
if (actionCache.has(instruction)) {
return actionCache.get(instruction)!;
}
const { data: actions } = await stagehand.observe(instruction);
actionCache.set(instruction, actions);
return actions;
}
```
```python theme={null}
action_cache: dict[str, list[Action]] = {}
async def cached_observe(instruction: str) -> list[Action]:
if instruction in action_cache:
return action_cache[instruction]
observed = await stagehand.observe(instruction)
action_cache[instruction] = observed.data
return observed.data
```
```go theme={null}
actionCache := map[string][]stagehand.Action{}
cachedObserve := func(ctx context.Context, instruction string) ([]stagehand.Action, error) {
if cached, ok := actionCache[instruction]; ok {
return cached, nil
}
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return nil, err
}
actionCache[instruction] = observed.Data
return observed.Data, nil
}
```
Learn advanced caching techniques and patterns for optimal performance.
## Troubleshooting
**Problem**: `observe()` returns an empty list
**Solutions**:
* Verify the element exists on the page
* Use more specific instructions (e.g., "find the blue submit button" instead of "find button")
* Ensure page has fully loaded before calling `observe()`
* Set the log level to `debug` in your Stagehand configuration to inspect detection behavior
```typescript theme={null}
// Check page state before observing
const [page] = await browser.context.pages();
if (!page) {
throw new Error("Stagehand initialized without an active page");
}
await page.waitForLoadState("domcontentloaded");
const { data: actions } = await stagehand.observe("find the submit button");
if (actions.length === 0) {
console.log("No elements found, trying alternative instruction");
const { data: altActions } = await stagehand.observe("find the button at the bottom of the form");
}
```
```python theme={null}
# Check page state before observing
page = (await browser.context.pages())[0]
if page is None:
raise RuntimeError("Stagehand initialized without an active page")
await page.wait_for_load_state("domcontentloaded")
observed = await stagehand.observe("find the submit button")
if not observed.data:
print("No elements found, trying alternative instruction")
alt = await stagehand.observe(
"find the button at the bottom of the form"
)
```
```go theme={null}
// Check page state before observing
page, err := browserContext.ActivePage(ctx)
if err != nil {
return err
}
if page == nil {
return errors.New("Stagehand initialized without an active page")
}
if err := page.WaitForLoadState(ctx, stagehand.LoadStateDOMContentLoaded, nil); err != nil {
return err
}
instruction := "find the submit button"
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
if len(observed.Data) == 0 {
fmt.Println("No elements found, trying alternative instruction")
alt := "find the button at the bottom of the form"
if _, err := client.Observe(ctx, &alt, nil); err != nil {
return err
}
}
```
**Problem**: Descriptions or selectors don't match actual elements
**Solutions**:
* Use more capable models, and check [model evals](https://stagehand.dev/evals) for recommendations
* Provide more context in your instruction (e.g., "find the submit button in the checkout form")
* Set the log level to `debug` in your Stagehand configuration to inspect LLM reasoning
```typescript theme={null}
// More specific instructions improve accuracy
// Instead of:
await stagehand.observe("find the button");
// Use context:
await stagehand.observe("find the red 'Delete' button in the user settings panel");
```
```python theme={null}
# More specific instructions improve accuracy
# Instead of:
await stagehand.observe("find the button")
# Use context:
await stagehand.observe(
"find the red 'Delete' button in the user settings panel"
)
```
```go theme={null}
// More specific instructions improve accuracy
// Instead of:
vague := "find the button"
if _, err := client.Observe(ctx, &vague, nil); err != nil {
return err
}
// Use context:
specific := "find the red 'Delete' button in the user settings panel"
if _, err := client.Observe(ctx, &specific, nil); err != nil {
return err
}
```
**Problem**: The `method` field has an unexpected value
**Solutions**:
* Validate the method before using it
* Check [supported actions](/v4/basics/act) for valid method names
* Reach for a [locator](/v4/reference/locator) when you want to call a specific method instead of trusting the suggestion
```typescript theme={null}
const { data: actions } = await stagehand.observe("find the submit button");
const [action] = actions;
// Validate method before acting
const validMethods = ["click", "fill", "type", "press"];
if (action && validMethods.includes(action.method || "")) {
await stagehand.act(action);
} else {
console.warn(`Unexpected method: ${action?.method}`);
}
```
```python theme={null}
observed = await stagehand.observe("find the submit button")
action = observed.data[0] if observed.data else None
# Validate method before acting
valid_methods = {"click", "fill", "type", "press"}
if action is not None and action.method in valid_methods:
await stagehand.act(action)
else:
print(f"Unexpected method: {action.method if action else None}")
```
```go theme={null}
instruction := "find the submit button"
observed, err := client.Observe(ctx, &instruction, nil)
if err != nil {
return err
}
var action *stagehand.Action
if len(observed.Data) > 0 {
action = &observed.Data[0]
}
method := ""
if action != nil && action.Method != nil {
method = *action.Method
}
// Validate method before acting
validMethods := []string{"click", "fill", "type", "press"}
if action != nil && slices.Contains(validMethods, method) {
if _, err := client.Act(ctx, stagehand.ObservedAction(*action), nil); err != nil {
return err
}
} else {
fmt.Println("Unexpected method:", method)
}
```
## Next steps
Use `act()` to execute discovered actions reliably.
Combine `observe()` with `extract()` for precise data extraction.
Build action caches to eliminate redundant LLM calls.
Full `Stagehand` reference with detailed parameter documentation.