Amazon Nova Act: Next-Gen AI Browser Automation for Developers

Amazon Nova Act is a research preview by Amazon Artificial General Intelligence (AGI) that brings a new approach to browser automation. By combining natural language instructions, Python scripting, and Playwright automation, developers can build intelligent agents that interact with websites—navigating pages, clicking buttons, filling forms, and extracting dynamic data.

For API-focused teams and backend engineers, Nova Act’s flexibility opens new ways to automate and test web interfaces. If you’re looking to streamline your API development or browser automation workflows, consider pairing Nova Act with robust API tools like Apidog—an all-in-one alternative to Postman for designing, debugging, and testing APIs efficiently.

With Apidog’s intuitive UI and advanced collaboration features, you can cut down on development time and improve API quality while seamlessly integrating with browser automation tasks.

What Makes Amazon Nova Act Different?

Traditional browser automation relies on rigid, website-specific scripts that often break when sites change. Nova Act uses AI to interpret natural language commands, adapting to layout updates and minimizing the need for constant script maintenance.

Key features:

• Adaptive to site changes via AI
• Natural language + Python integration
• Dynamic data extraction
• Parallel browser session support

Prerequisites

Before using Amazon Nova Act, ensure you have:

• Operating System: macOS or Ubuntu (Windows not supported)
• Python: 3.10 or above
• Amazon Account: For API key access
• Location: Only available in the US (research preview)

Obtaining Your Nova Act API Key

1. Go to nova.amazon.com/act and sign in.
2. Select “Act” in the Labs navigation pane.
3. Generate an API key.
4. If not immediately granted, you may be placed on a waitlist and notified via email.

Installing Nova Act

After receiving your API key, install Nova Act and set up your environment:

# Install the SDK
pip install nova-act

# Set your API key as an environment variable
export NOVA_ACT_API_KEY="your_api_key"

Note: The initial run may take 1–2 minutes as dependencies are installed. Subsequent launches are faster.

Quick Start: Basic Usage

Here’s a simple automation script that searches Amazon for a coffee maker and adds it to the cart:

from nova_act import NovaAct

with NovaAct(starting_page="https://www.amazon.com") as nova:
    nova.act("search for a coffee maker")
    nova.act("select the first result")
    nova.act("scroll down or up until you see 'add to cart' and then click 'add to cart'")

What this does:

• Launches Chrome and navigates to Amazon
• Performs a search
• Selects the top result
• Adds the item to the cart

Experimenting in Interactive Mode

Nova Act supports interactive use for rapid prototyping. Start a Python shell:

$ python
>>> from nova_act import NovaAct
>>> nova = NovaAct(starting_page="https://www.amazon.com")
>>> nova.start()
>>> nova.act("search for a coffee maker")
>>> nova.act("select the first result")

Tip: Use the standard Python shell (not iPython) for compatibility.

How to Write Effective Prompts

Nova Act works best when you break tasks into clear, specific steps. Here’s how:

Be Specific and Explicit

Avoid:

nova.act("From my order history, find my most recent order from India Palace and reorder it")

Use instead:

nova.act("Click the hamburger menu icon, go to Order History, find my most recent order from India Palace and reorder it")

Break Down Complex Actions

Avoid:

nova.act("book me a hotel that costs less than $100 with the highest star rating")

Use instead:

nova.act(f"search for hotels in Houston between {startdate} and {enddate}")
nova.act("sort by avg customer review")
nova.act("hit book on the first hotel that is $100 or less")
nova.act(f"fill in my name, address, and DOB according to {blob}")

Extracting Structured Data from Web Pages

Leverage Pydantic models to extract and validate structured data:

from pydantic import BaseModel
from nova_act import NovaAct, BOOL_SCHEMA

class Book(BaseModel):
    title: str
    author: str

class BookList(BaseModel):
    books: list[Book]

def get_books(year: int) -> BookList | None:
    with NovaAct(starting_page=f"https://en.wikipedia.org/wiki/List_of_The_New_York_Times_number-one_books_of_{year}#Fiction") as nova:
        result = nova.act(
            "Return the books in the Fiction list",
            schema=BookList.model_json_schema()
        )
        if not result.matches_schema:
            return None
        return BookList.model_validate(result.parsed_response)

For simple yes/no checks, use BOOL_SCHEMA:

result = nova.act("Am I logged in?", schema=BOOL_SCHEMA)
if result.matches_schema:
    print("You are logged in" if result.parsed_response else "You are not logged in")

Running Multiple Browser Sessions in Parallel

Nova Act supports concurrent automation using Python’s ThreadPoolExecutor:

from concurrent.futures import ThreadPoolExecutor, as_completed
from nova_act import NovaAct, ActError

all_books = []
with ThreadPoolExecutor(max_workers=10) as executor:
    future_to_books = {
        executor.submit(get_books, year): year
        for year in range(2010, 2025)
    }
    for future in as_completed(future_to_books.keys()):
        try:
            year = future_to_books[future]
            book_list = future.result()
            if book_list is not None:
                all_books.extend(book_list.books)
        except ActError as exc:
            print(f"Skipping year {year} due to error: {exc}")

Authentication and Browser State Management

For sites requiring login, Nova Act can use your existing Chrome user profile:

import os
from nova_act import NovaAct

user_data_dir = "path/to/my/chrome_profile"
os.makedirs(user_data_dir, exist_ok=True)

with NovaAct(
    starting_page="https://amazon.com/", 
    user_data_dir=user_data_dir,
    clone_user_data_dir=False
) as nova:
    input("Log into your websites, then press enter...")

Or use the built-in setup script:

python -m nova_act.samples.setup_chrome_user_data_dir

Handling Sensitive Data

• Passwords: Use Playwright’s direct keyboard input for passwords, not natural language:

  from getpass import getpass
  nova.page.keyboard.type(getpass())
  

• Security Note: Screenshots during execution may capture sensitive info. Use with caution.

Advanced Features

Detecting Captchas

result = nova.act("Is there a captcha on the screen?", schema=BOOL_SCHEMA)
if result.matches_schema and result.parsed_response:
    input("Please solve the captcha and hit return when done")

Downloading Files

with nova.page.expect_download() as download_info:
    nova.act("click on the download button")
download_info.value.save_as("my_downloaded_file")

Recording Sessions

nova = NovaAct(
    starting_page="https://example.com",
    logs_directory="/path/to/logs",
    record_video=True
)

Real-World Example: Apartment Search Automation

Here’s how Nova Act can power a real-world workflow—finding and ranking apartments near a train station:

from concurrent.futures import ThreadPoolExecutor, as_completed
import pandas as pd
from pydantic import BaseModel
from nova_act import NovaAct

class Apartment(BaseModel):
    address: str
    price: str
    beds: str
    baths: str

class ApartmentList(BaseModel):
    apartments: list[Apartment]

# Step 1: Extract apartment listings
with NovaAct(starting_page="https://zumper.com/", headless=True) as client:
    client.act(
        "Close any cookie banners. "
        f"Search for apartments near {caltrain_city}, CA, "
        f"then filter for {bedrooms} bedrooms and {baths} bathrooms."
    )
    result = client.act(
        "Return the currently visible list of apartments",
        schema=ApartmentList.model_json_schema()
    )

# Step 2: Rank or enrich listings using parallel tasks...
# (details omitted for brevity)

apartments_df = pd.DataFrame(apartments_with_biking)

Highlights:

• Extracts structured data from a website
• Processes multiple browser sessions in parallel
• Supports combining and analyzing data programmatically

Known Limitations

According to Amazon’s documentation, Nova Act currently:

• Only works with browser-based tasks (not desktop apps)
• May be unreliable for very complex/abstract prompts
• Can’t interact with elements hidden behind mouseovers or browser modals
• Is only available in the US (research preview)
• Is not recommended for production use yet

NovaAct Constructor: Key Options

You can customize Nova Act’s behavior when initializing:

NovaAct(
    starting_page="https://example.com",  # Required URL
    headless=False,                       # Run browser in headless mode
    quiet=False,                          # Suppress logs
    user_data_dir=None,                   # Chrome profile directory
    nova_act_api_key=None,                # API key (else use env var)
    logs_directory=None,                  # Log storage path
    record_video=False,                   # Record session video
    # ...and other documented options
)

Conclusion

Amazon Nova Act introduces a smarter approach to browser automation—using AI to adapt to real-world web changes and giving developers a flexible, Python-driven toolset for browser tasks. While still in research preview (US-only), it’s a promising tool for teams automating complex workflows, scraping data, or testing UI flows.

For API-centric projects, combining Nova Act’s browser automation with Apidog’s complete API development suite can significantly speed up your workflows and improve quality—especially when high reliability and collaboration are key.

For the latest updates, always check the official documentation and nova.amazon.com/act.