# AWS Marketplace Scraper – Competitor Pricing Monitor (`marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor`) Actor

Scrape and monitor public AWS Marketplace listings. Track competitor pricing, contract terms, positioning, categories, delivery model, and listing changes with clear before-and-after evidence for product marketing, marketplace, and procurement teams.

- **URL**: https://apify.com/marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor.md
- **Developed by:** [Marielise](https://apify.com/marielise.dev) (community)
- **Categories:** Automation, Developer tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 aws marketplace listing intelligences

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AWS Marketplace Intelligence — Pricing & Listing Change Monitor

AWS Marketplace is where cloud-software vendors compete on far more than a logo and a star rating. A public listing can reveal a new annual contract dimension, a switch from usage-based to private-offer positioning, an expanded category footprint, or a rewritten message aimed at a new buyer. Checking those pages manually is slow, easy to miss, and impossible to scale across a meaningful competitor watchlist.

**AWS Marketplace Intelligence** turns public AWS Marketplace product pages into a structured, repeatable competitive-intelligence dataset. Paste direct AWS Marketplace product URLs—or add labelled targets such as “Q4 AI-security competitor”—and receive the fields a marketplace, product-marketing, partnerships, or procurement team actually needs: seller, product type, categories, rating and review count, public overview and highlights, pricing model, private-offer and trial signals, visible pricing dimensions, support contact, and a source-linked change record.

This is not a generic website scraper. It understands public AWS Marketplace product pages and keeps a snapshot for every stable `prodview` listing ID. Re-run the same watchlist on a schedule to see whether a competitor changed pricing, packaging, positioning, categories, reviews, or support details. Set **Return only changed listings** to create a compact alert-ready feed instead of exporting the same rows every week.

### Who uses it

- **AWS Marketplace sellers and channel teams** monitoring competitor packaging, price visibility, trial cues, and category moves.
- **Cloud software product marketers** building reliable battlecards from source-linked public evidence.
- **Competitive-intelligence agencies** delivering repeatable marketplace reports without copying page text by hand.
- **Cloud procurement and FinOps teams** comparing public software purchasing models before engaging vendors.

### Quick start

1. Open the product page in AWS Marketplace.
2. Copy its URL, for example `https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw`.
3. Add one or more URLs to **AWS Marketplace product URLs**.
4. Run the Actor and export the Dataset as JSON, CSV, or Excel.

```json
{
  "productUrls": [
    "https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw"
  ],
  "includeDescription": true,
  "onlyChanged": false,
  "snapshotKey": "security-competitors"
}
```

For a recurring watchlist, keep `snapshotKey` unchanged and schedule the same input weekly. After the initial baseline run, set `onlyChanged` to `true`. Changed records include `changedFields`, `previousSourceHash`, and `changedAt`; unchanged listings are skipped from the Dataset while errors are always reported.

#### Customer-ready watchlist

Use **Named watchlist targets** when the output is going to a buyer, consulting client, or internal battlecard. It keeps their relationship and reporting tags alongside each live listing:

```json
{
  "targets": [{
    "url": "https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw",
    "label": "AI-security competitor",
    "relationship": "competitor",
    "tags": ["AI security", "Q4 watchlist"]
  }],
  "snapshotKey": "ai-security-competitors"
}
```

Each output then includes a customer-friendly `changeSummary` and `customerTakeaway`, not merely raw page data.

### What each listing includes

| Field | Meaning |
|---|---|
| `productName`, `sellerName`, `sellerProfileUrl`, `listingId`, `productUrl` | Stable listing identity and source links |
| `deliveryMethod`, `isDeployedOnAws` | Public delivery/deployment signals when AWS exposes them |
| `categories`, `productType` | Public AWS Marketplace classification when published |
| `pricingModel`, `hasCustomPricing`, `hasFreeTrial` | Normalized public pricing and purchasing signals |
| `priceDimensions` | Public table rows with raw price plus sortable `amount`, `currency`, and `billingTerm` |
| `positioningSummary` | Short executive-ready positioning summary alongside the full public overview |
| `overview`, `highlights` | Public positioning copy; disable with `includeDescription` for a pricing-only run |
| `rating`, `reviewCount`, `reviewStatus` | Public review signals, including an explicit no-review vs unavailable distinction |
| `supportContact`, `supportUrl` | Public vendor-support details when exposed |
| `watchlistLabel`, `relationship`, `tags` | Your customer context for filtering, reporting, and battlecards |
| `status`, `changedFields`, `changeSummary`, `changeDetails`, `sourceHash` | State plus exact previous/current values for scheduled-monitoring changes |
| `customerTakeaway` | Deterministic commercial next step based on public price, review, and delivery signals |

### Reliable, low-cost architecture

AWS Marketplace product pages are server-rendered, so this Actor uses direct HTTP requests and Cheerio rather than a headless browser. That keeps the run fast and cost-efficient. The default is two concurrent requests with a 500 ms request delay, three bounded retries, and a 45-second request timeout. Increase concurrency only for a larger watchlist; private offers, account-only purchase details, and login-gated information are intentionally not accessed.

A blank field means AWS did not publish that data on the public product page or it could not be safely extracted. The Actor never invents prices, product types, categories, or support contacts. A blocked, missing, or malformed page produces a transparent error record instead of an empty listing record.

### Boundaries and responsible use

This Actor collects only public AWS Marketplace listing pages supplied by you. It does not log into AWS, access seller portals, retrieve private offers, bypass access controls, or make claims about a vendor's product quality or legal compliance. Use the resulting public data in accordance with AWS terms, applicable law, and your organization’s policies.

### Suggested pay-per-event pricing

For Store publication, price successful listing records on a pay-per-event basis (for example, $0.01–$0.03 per parsed listing plus a small start fee). Error records and unchanged records skipped by `onlyChanged` should not be charged. This makes small ad-hoc research inexpensive while remaining practical for high-volume scheduled competitive intelligence.

### Run locally

The same extraction and diff pipeline can be smoke-tested without an Apify account or browser:

```bash
npm install
npm run local -- --input input.example.json
```

This writes a local Dataset-shaped JSON file to `.local/dataset.json` and stores the monitoring baseline in `.local/snapshots.json`. Re-run the same command with `"onlyChanged": true` to verify the no-change path locally. Both files are ignored by Git.

### Store pricing

This Actor is designed for **Pay per Event** pricing: `$0.025` for each successfully saved marketplace listing plus Apify's standard `$0.00005` start event. Error records are free. See [PRICING.md](./PRICING.md) for buyer segments, margin guardrails, and the exact Store configuration.

# Actor input Schema

## `productUrls` (type: `array`):

One or more public AWS Marketplace product URLs. Paste URLs containing /marketplace/pp/prodview-.

## `maxProducts` (type: `integer`):

Safety limit after URL deduplication. Lower values make a first run faster and cheaper.

## `onlyChanged` (type: `boolean`):

With the same snapshot key, unchanged listings are not written to the Dataset. Errors are always written.

## `snapshotKey` (type: `string`):

A stable identifier for this watchlist. Use a different key for separate teams, competitors, or regions.

## `includeDescription` (type: `boolean`):

Captures public overview text and highlights for copy-change monitoring. Disable for a compact pricing-only feed.

## `concurrency` (type: `integer`):

AWS Marketplace is fetched politely over HTTP. Keep this low for reliable recurring runs.

## `requestDelayMs` (type: `integer`):

Minimum delay before each fetch. Increase it for large watchlists.

## `targets` (type: `array`):

Optional richer alternative to plain URLs. Add a label, relationship and tags so exported records are ready for battlecards and reporting.

## Actor input object example

```json
{
  "productUrls": [
    "https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw"
  ],
  "maxProducts": 25,
  "onlyChanged": false,
  "snapshotKey": "aws-marketplace-intelligence-snapshots",
  "includeDescription": true,
  "concurrency": 2,
  "requestDelayMs": 500,
  "targets": []
}
```

# Actor output Schema

## `marketplaceListings` (type: `string`):

Listing intelligence records and transparent diagnostic error records from this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productUrls": [
        "https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "productUrls": ["https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw"] }

# Run the Actor and wait for it to finish
run = client.actor("marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productUrls": [
    "https://aws.amazon.com/marketplace/pp/prodview-xphnsjsox7vjw"
  ]
}' |
apify call marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=marielise.dev/aws-marketplace-scraper-competitor-pricing-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/FVJw1WFiy0cD5A4sD/builds/lT5S2MtYGYgZcveSX/openapi.json