Amazon Nova Actによる競合価格情報の自動化

Monitoring competitor prices is essential for ecommerce teams to maintain a market edge. However, many teams remain trapped in manual tracking, wasting hours daily checking individual websites. This inefficient approach delays decision-making, raises operational costs, and risks human errors that result in missed revenue and lost opportunities.

Amazon Nova Act is an open-source browser automation SDK used to build intelligent agents that can navigate websites and extract data using natural language instructions. This post demonstrates how to build an automated competitive price intelligence system that streamlines manual workflows, supporting teams to make data-driven pricing decisions with real-time market insights.

The hidden cost of manual competitive price intelligence

Ecommerce teams need timely and accurate market data to stay competitive. Traditional workflows are manual and error-prone, involving searching multiple competitor websites for certain products, recording pricing and promotional data, and consolidating this data into spreadsheets for analysis. This process presents several critical challenges:

• Time and resource consumption: Manual price monitoring consumes hours of staff time every day, representing a significant operational cost that scales poorly as product catalogs grow.

• Data quality issues: Manual data entry introduces inconsistency and human error, potentially leading to incorrect pricing decisions based on flawed information.

• Scalability limitations: As product catalogs expand, manual processes become increasingly unsustainable, creating bottlenecks in competitive analysis.

• Delayed insights: The most critical issue is timing. Competitor pricing can change rapidly throughout the day, meaning decisions made on stale data can result in lost revenue or missed opportunities.

These challenges extend far beyond ecommerce. Insurance providers routinely review competitor policies, inclusions, exclusions, and premium structures to maintain market competitiveness. Financial services institutions analyze loan rates, credit card offers, and fee structures through time-consuming manual checks. Travel and hospitality businesses monitor fluctuating prices for flights, accommodations, and packages to adjust their offerings dynamically. Regardless of the industry, the same struggles exist. Manual research is slow, labor-intensive, and prone to human error. In markets where prices change by the hour, these delays make it almost impossible to stay competitive.

Automating with Amazon Nova Act

Amazon Nova Act is an AWS service, with an accompanying SDK, designed to help developers build agents that can act within web browsers. Developers structure their automations by composing smaller, targeted commands in Python, combining natural language instructions for browser interactions with programmatic logic such as tests, breakpoints, assertions, or thread-pooling for parallelization. Through its tool calling capability, developers can also enable API calls alongside browser actions. This gives teams full control over how their automations run and scale. Nova Act supports agentic commerce scenarios where automated agents handle tasks such as competitive monitoring, content validation, catalogue updates, and multi-step browsing workflows. Competitive price intelligence is a strong fit because the SDK is designed to cope with real-world website behavior, including layout changes and dynamic content.

Ecommerce sites frequently change layouts, run short-lived promotions, or rotate banners and components. These shifts often break traditional rules-based scripts that rely on fixed element selectors or rigid navigation paths. Nova Act’s flexible, natural language command-driven approach helps agents continue operating even as pages evolve, providing the resilience needed for production competitive intelligence systems.

Common building blocks

Nova Act includes a set of building blocks that simplify browser automation. This can be used by ecommerce companies to collect and record product prices from websites without human intervention. The building blocks that enable this include:

Extracting information from a webpage

With the extraction capabilities in Nova Act, agents can gather structured data directly from a rendered webpage. You can define a Pydantic model that represents the schema that they want returned, then ask an act_get() call to answer a question about the current browser page using that schema. This keeps the extracted data strongly typed, validated, and ready for downstream use.

Nova.act_get("Search for 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi'.", schema=ProductData.model_json_schema())

Navigate to a webpage

This step redirects the agent to a specific webpage as a starting point. A new browser session opens at a desired starting point, enabling the agent to take actions or extract data.

nova.go_to_url(website_url)

Running multiple sessions in parallel

Price intelligence workloads often require checking dozens of competitor pages in a short period. A single Nova Act instance can invoke only one browser at a time, but multiple instances can run concurrently. Each instance is lightweight, making it practical to spin up several in parallel and distribute work across them. This enables a map‑reduce style approach to browser automation where different Nova Act instances handle separate tasks at the same time. By parallelizing searches or extraction work across many instances, organizations can reduce total execution time and monitor large product catalogs with minimal latency.

from concurrent.futures import ThreadPoolExecutor, as_completed

from nova_act import ActError, NovaAct

# Accumulate the complete list here.
all_prices = []

# Set max workers to the max number of active browser sessions.
with ThreadPoolExecutor(max_workers=10) as executor:
    # Get all prices in parallel.
    future_to_source = {
        executor.submit(
            check_source_price, product_name, source_name, source_url, headless
        ): source_name
        for source_name, source_url in sources
    }
    # Collect the results in all_books.
    for future in as_completed(future_to_source.keys()):
        try:
            source = future_to_source[future]
            source_price = future.result()
            if source_price is not None:
                all_prices.extend(source_price.source)
        except ActError as exc:
            print(f"Skipping source price due to error: {exc}")

print(f"Found {len(all_prices)} source prices:\n{all_books}")

Captchas

Some websites present captchas during automated browsing. For ethical reasons, we recommend involving a human to solve captchas rather than attempting automated solutions. Nova Act does not solve captchas on the user’s behalf.

When running Nova Act locally, your workflow can use an act_get() call to detect whether a captcha is present. If one is detected, the workflow can pause and prompt the user to complete it manually, for example, by calling input() in a terminal-launched process. To enable this, run your workflow in headed mode (set headless=False, which is the default) so the user can interact with the browser window directly.

When deploying Nova Act workflows with AgentCore Browser Tool (ACBT), you can use its built-in human-in-the-loop (HITL) capabilities. ACBT provides serverless browser infrastructure with live streaming from the AgentCore AWS Console. When a captcha is encountered, a human operator can take over the browser session in real-time through the UI takeover feature, solve the challenge, and return control to the Nova Act workflow.

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")
...

Handling errors

Once the Nova Act client is started, it may encounter errors during an act() call. These issues can arise from dynamic layouts, missing elements, or unexpected page changes. Nova Act surfaces these situations as ActErrors so that developers can catch them, retry operations, apply fallback logic, or log details for further analysis. This helps price intelligence agents avoid silent failures and continue running even when websites behave unpredictably.

Building and Monitoring Nova Act workflows

Building with AI-powered IDEs

Developers building Nova Act automation workflows can accelerate experimentation and prototyping by using AI-powered development environments with Nova Act IDE extensions. The extension is available for popular IDEs including Kiro, Visual Studio Code, and Cursor, bringing intelligent code generation and context-aware assistance directly into your preferred development environment. The IDE extension for Amazon Nova Act speeds up development by turning natural language prompts into production-ready code. Instead of digging through documentation or writing repetitive boilerplate, you can simply describe your automation goals. This is helpful for complex tasks like competitive price intelligence, where the extension can help you quickly structure ThreadPoolExecutor logic, design Pydantic schemas, and build robust error handling.

Observing workflows in the Nova Act console

The Nova Act AWS console provides visibility into your workflow execution with detailed traces and artifacts from your AWS environment via the AWS Management Console. It provides a central place to manage and monitor automation workflows in real-time. You can navigate from a high-level view of the workflow runs into the specific details of individual sessions, acts, and steps. This visibility helps you to debug and analyze performance by showing you exactly how the agent makes decisions and executes loops. With direct access to screenshots, logs, and data stored in Amazon S3, you can troubleshoot issues quickly without switching between different tools. This streamlines the troubleshooting process and accelerates the iteration cycle from experimentation to production deployment.

Running the solution

To help you get started with automated market research, we’ve released a Python-based sample project that handles the heavy lifting of price monitoring. This solution uses Amazon Nova Act to launch multiple browser sessions at once, searching for products across various competitor sites simultaneously. Instead of going through tabs yourself, the script navigates the web to find prices and promotions. It then gathers everything into a clean, structured format so you can use it in your own pricing models. The following sections will describe how you can get started building the competitive price intelligence agent. After exploring, you can deploy to AWS and monitor your workflows in the AWS Management Console.

The competitive price intelligence agent is available as an AWS Samples solution in the Amazon Nova Samples GitHub repository as part of the Price Comparison use case.

1. Prerequisites

Your development environment must include: Python: 3.10 or later and the Nova Act SDK.

2. Get Nova Act API key:

Navigate to https://nova.amazon.com/act and generate an API key. When using the Nova Act Playground or choosing Nova Act developer tools with API key authentication, access and use are subject to the nova.amazon.com Terms of Use.

3. Clone the repo, set the API key, and install the dependencies:

To get started, clone the repository, set your API key so the application can authenticate, and install the required Python dependencies. This prepares your environment so you can run the project locally without issues. An API Key can be generated on Nova Act.

# Clone the repo
https://github.com/aws-samples/amazon-nova-samples.git
cd nova-act/usecases/price_comparison

# Create and activate a virtual environment (optional but recommended)
python3 -m venv .venv
source .venv/bin/activate

# Windows:
.venv\Scripts\activate

# Install Python dependencies
pip install -r requirements.txt

# Set the Nova Act API Key export NOVA_ACT_API_KEY="your_api_key"

4. Running the script

Once your environment is set up, you can run the agent to perform competitive price intelligence. The script takes a product name (optional) and a list of competitor websites (optional), launches concurrent Nova Act browser sessions, searches each site, extracts price and promotional details, and returns a structured, aggregated result.

The previous example uses the script’s default competitor list, which includes major retailers such as Amazon, Target, Best Buy, and Costco. You can override these defaults by supplying your own list of competitor URLs when running the script.

python -m main.py \
    --product_name "iPad Pro 13-inch, 256GB Wi-Fi" \
    --product_sku "MVX23LL/A" \
    --headless

The agent launches multiple Nova Act browser sessions in parallel, one per competitor site. Each session loads the retailer’s website, checks whether a captcha is present, and pauses for user input if one needs to be solved. Once clear, the agent searches for the product, reviews the returned results, clicks the most relevant listing, and extracts the price and promotional information. Running these flows concurrently allows the agent to complete a multi-site comparison efficiently.

For example, when targeting Amazon, the agent opens a fresh browser session, navigates to amazon.com, and performs a site-specific search for the product. It inspects the returned results, identifies the product listing that most closely matches the query, and extracts key details such as price, promotions, availability, and relevant metadata. This process is reflected in the following terminal output that reflects each reasoning step (prices in this example are illustrative and not representative of real market prices):

583c> act("Is there a captcha on the screen?, format output with jsonschema: {"type": "boolean"}")
583c> ...
583c> think("I am on the Amazon homepage. My task is to return whether there is a captcha on the screen. I can look around the page to try and find a captcha. I don't see anything that looks like a captcha. I also don't see anything that seems like it would require a captcha to be displayed. I should return false to indicate that there is no captcha on the page.");
...
583c> act("Search for 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi'.")
583c> ...
583c> think("I am on the amazon homepage. My task is to search for 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi'. I see an empty search field. I need to type 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi' into the search field.");
583c> ...
583c> think("I see that the search field is populated with 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi', but the search has not been initiated. Therefore, my last action was not correct. I see a search button to the right of the search field which can be used to complete the search. I will click on the search button to complete the search.");
...
583c> think("I am now on the search results page for 'iPad Pro 13-inch (M4 chip), 256GB Wi-Fi'. My task is complete, and I need to return.");
...
583c> think("I am on the Amazon search results page for "iPad Pro 13-inch (M4 chip), 256GB Wi-Fi". My task is to review all the results and find the most relevant one, then extract the price and any promotion details. I need to return the information in the specified JSON format. I see a list of products, but the first few are sponsored. I should scroll down the page to find the most relevant, non-sponsored product.");
583c> ...
583c> think("The page has scrolled down and I see more products. My prior action of scrolling down was successful. I see the first non-sponsored product, which is the "Apple iPad Pro 13-Inch (M4): Built for Apple Intelligence, Ultra Retina XDR Display, 256GB, 12MP Front/Back Camera, LiDAR Scanner, Wi-Fi 6E, Face ID, All-Day Battery Life — Space Black". I should click on the product to navigate to its page and find the price and promotion details.");
583c> ...
583c> think("I am now on the product page for the "Apple iPad Pro (M4) 13-inch (M4 chip), 256GB Wi-Fi". My prior action of clicking on the product was successful. I see the price of the product is $1,039.99 and there is a promotion for 19% off. I should return the price and promotion details in the specified JSON format.");

4. Reviewing the output

After the agent finishes searching all competitor sites, it returns a consolidated table that lists each retailer, the matched product, the extracted price, the promotion details, and additional metadata. From this table, you can compare results across multiple sources in one view. For example, the output might look as follows (prices in this example are illustrative and not representative of real market prices):

| Source | Product Name | Product SKU | Price | Promotion Details |
|--------|--------------|-------|-------|-------------------|
| Amazon | Apple iPad Pro (M4) 13-inch (M4 chip), 256GB Wi-Fi | MVX23LL/A | $1,039.99 | 19% off |
| Best Buy | Apple - 13-inch iPad Pro M4 chip Built for Apple Intelligence Wi-Fi 256GB with OLED - Silver |  MVX23LL/A | $1239.00 | Save $50 |
| Costco | iPad Pro 13-inch (M4 chip), 256GB Wi-Fi | MVX23LL/A | $1039.99 | $200 OFF; savings is valid 11/12/25 through 11/22/25. While supplies last. Limit 2 per member. |
| Target | Apple iPad Pro (M4) WiFi with Standard glass | MVX23LL/A | $999.00 | Sale ends Wednesday |

The agent writes the extracted results to a CSV file to later integrate with pricing tools, dashboards, or internal APIs.

まとめ

Amazon Nova Act transforms browser automation from a complex technical task into a simple natural language interface, so retailers can automate manual workflows, reduce operational costs, and gain real-time market insights. By significantly reducing the time spent on manual data collection, teams can shift their focus to strategic pricing decisions. The solution scales efficiently as monitoring needs grow, without requiring proportional increases in resources. Nova Act enables developers