StageHand: AI-Powered Browser Automation

#%pip install stagehand python-dotenv pydantic -q

BROWSERBASE_API_KEY="your_browserbase_api_key"
BROWSERBASE_PROJECT_ID="your_browserbase_project_id"
OPENAI_API_KEY="your_openai_api_key"

import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# Read env vars without exposing their values
BROWSERBASE_API_KEY = os.getenv("BROWSERBASE_API_KEY")
BROWSERBASE_PROJECT_ID = os.getenv("BROWSERBASE_PROJECT_ID")
MODEL_API_KEY = os.getenv("OPENAI_API_KEY")

# Print only a boolean status, not the keys themselves
keys_loaded = all([
    bool(BROWSERBASE_API_KEY),
    bool(BROWSERBASE_PROJECT_ID),
    bool(MODEL_API_KEY),
])
print("API keys loaded:", keys_loaded)

from stagehand import Stagehand, StagehandConfig
import asyncio
import os

async def main():
    server_url = os.getenv("STAGEHAND_SERVER_URL", "https://api.stagehand.browserbase.com/v1")
    
    config = StagehandConfig(
        env="BROWSERBASE",
        api_key=BROWSERBASE_API_KEY,
        project_id=BROWSERBASE_PROJECT_ID,
        model_api_key=MODEL_API_KEY,
        model_name="gpt-4o",
    )
    
    stagehand = Stagehand(config)
    
    # Set the server URL if it's not already set
    if hasattr(stagehand, 'server_url'):
        stagehand.server_url = server_url
    
    try:
        await stagehand.init()
        page = stagehand.page
        
        await page.goto("https://docs.stagehand.dev/")
        await page.act("click the quickstart link")
        
        result = await page.extract("extract the main heading of the page")
        
        print(f"Extracted: {result}")
        
    except Exception as e:
        print(f"Error occurred: {e}")
    finally:
        try:
            await stagehand.close()
        except:
            pass

# Run the async main function in a notebook-safe way
try:
    loop = asyncio.get_running_loop()
    import nest_asyncio
    nest_asyncio.apply()
    loop.run_until_complete(main())
except RuntimeError:
    asyncio.run(main())

import asyncio
import os
from pydantic import BaseModel, Field
from stagehand import Stagehand, StagehandConfig

# Define the data structure we want to extract
class RepoInfo(BaseModel):
    name: str = Field(description="The name of the repository")
    stars: str = Field(description="The star count of the repository")

async def main():
    # Get the server URL - using the correct StageHand API endpoint
    server_url = os.getenv("STAGEHAND_SERVER_URL", "https://api.stagehand.browserbase.com/v1")
    
    config = StagehandConfig(
        env="BROWSERBASE",
        api_key=BROWSERBASE_API_KEY,
        project_id=BROWSERBASE_PROJECT_ID,
        model_api_key=MODEL_API_KEY,
        model_name="gpt-4o",
    )
    
    stagehand = Stagehand(config)
    
    # Set the server URL if it's not already set
    if hasattr(stagehand, 'server_url'):
        stagehand.server_url = server_url
    
    try:
        await stagehand.init()
        page = stagehand.page
        
        await page.goto("https://github.com/browserbase/stagehand")
        print(f"Navigated to: {page.url}")

        # Method 1: Extract using structured format with specific instruction
        result = await page.extract(
            instruction="""Extract the repository information and return it in this exact JSON format:
            {
                "name": "repository name from the page",
                "stars": "star count number with k suffix if applicable"
            }
            
            Only return the JSON object, nothing else."""
        )
        
        print(f"Raw extraction result: {result}")
        
        # Try to parse the result
        try:
            import json
            if hasattr(result, 'extraction'):
                data_str = result.extraction
            else:
                data_str = str(result)
            
            # Try to extract JSON from the string
            if '{' in data_str and '}' in data_str:
                start = data_str.find('{')
                end = data_str.rfind('}') + 1
                json_str = data_str[start:end]
                data = json.loads(json_str)
                
                # Validate and print the extracted data
                repo_data = RepoInfo(**data)
                print(f"✅ Structured Extraction Success!")
                print(f"   Repository Name: {repo_data.name}")
                print(f"   Stars: {repo_data.stars}")
            else:
                print(f"ℹ️ Extraction result (text format): {data_str}")
                
        except Exception as parse_error:
            print(f"⚠️ Could not parse as JSON: {parse_error}")
            print(f"   Raw result: {result}")

    except Exception as e:
        print(f"❌ Error occurred: {e}")
        import traceback
        traceback.print_exc()
    finally:
        try:
            await stagehand.close()
        except:
            pass
        print("Session closed.")

# Run the async main function in a notebook-safe way
try:
    loop = asyncio.get_running_loop()
    import nest_asyncio
    nest_asyncio.apply()
    loop.run_until_complete(main())
except RuntimeError:
    asyncio.run(main())

import asyncio
import os
from stagehand import Stagehand, StagehandConfig

async def main():
    # Initialize StageHand with correct API endpoint
    server_url = os.getenv("STAGEHAND_SERVER_URL", "https://api.stagehand.browserbase.com/v1")
    
    config = StagehandConfig(
        env="BROWSERBASE",
        api_key=BROWSERBASE_API_KEY,
        project_id=BROWSERBASE_PROJECT_ID,
        model_api_key=MODEL_API_KEY,
        model_name="gpt-4o",
    )
    
    stagehand = Stagehand(config)
    
    # Set the server URL if it's not already set
    if hasattr(stagehand, 'server_url'):
        stagehand.server_url = server_url
    
    try:
        await stagehand.init()
        print("✓ StageHand initialized successfully")
        
        page = stagehand.page
        
        # Demonstrate multi-step automation (agent-like behavior using page methods)
        print("🤖 Performing multi-step automation...")
        
        # Step 1: Navigate to StageHand docs
        await page.goto("https://docs.stagehand.dev/")
        print("   ✓ Navigated to StageHand documentation")
        
        # Step 2: Extract the main introduction
        intro = await page.extract("extract the main heading and first description paragraph")
        print(f"   ✓ Extracted introduction: {intro}")
        
        # Step 3: Try to navigate to getting started
        await page.act("click on the getting started or quickstart link")
        print("   ✓ Clicked on getting started")
        
        # Step 4: Extract information from the new page
        getting_started_info = await page.extract("extract the main heading and first paragraph from this page")
        print(f"   ✓ Extracted getting started info: {getting_started_info}")
        
        print("\n🎉 Multi-step automation completed successfully!")
        print("This demonstrates how StageHand can perform complex, multi-step workflows")
        print("by chaining together goto(), act(), and extract() operations.")

    except Exception as e:
        print(f"❌ Error occurred: {e}")
        import traceback
        traceback.print_exc()
            
    finally:
        try:
            await stagehand.close()
        except:
            pass
        print("Session closed.")

# Run the async main function in a notebook-safe way
try:
    loop = asyncio.get_running_loop()
    import nest_asyncio
    nest_asyncio.apply()
    loop.run_until_complete(main())
except RuntimeError:
    asyncio.run(main())