# AWS Cloud Pricing Cost Impact Report (`taroyamada/aws-cloud-pricing-cost-impact-report`) Actor

Read official AWS public USD offer files for Lambda, S3, and RDS and emit stable price changes and cost-impact report rows.

- **URL**: https://apify.com/taroyamada/aws-cloud-pricing-cost-impact-report.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 aws price rows

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 Cloud Pricing Cost Impact Report

### Store Quickstart

Run this input to exercise the documented first-run path. Review the pricing section before increasing the scope.

```json
{
  "scopes": [
    {
      "serviceCode": "AWSLambda",
      "region": "us-east-1",
      "usage": {
        "Requests": 12000000,
        "GB-Seconds": 300000
      }
    },
    {
      "serviceCode": "AmazonS3",
      "region": "us-east-1",
      "filters": {
        "productFamily": "Storage",
        "unit": "GB-Mo",
        "attributes": {
          "storageClass": "General Purpose",
          "volumeType": "Standard"
        }
      },
      "usage": {
        "GB-Mo": 2500
      }
    }
  ],
  "mode": "report",
  "initialRunMode": "emit_current",
  "generateReport": true,
  "emitUnchanged": false,
  "emitRawRows": false,
  "maxChargeUsd": 10
}
```

### Buyer, Input, Output, Value

**Buyer:** FinOps teams, cloud platform owners, procurement analysts, and pricing operations teams that need a repeatable view of AWS list-price exposure.

**Input:** `scopes[]` with a supported AWS service code (`AWSLambda`, `AmazonS3`, or `AmazonRDS`), a required region, optional price filters, and optional monthly quantities keyed by the AWS price-list unit. Choose `mode: "report"` or `mode: "watch"`; the actor uses USD only and never requests credentials.

**Output:** Dataset rows with stable SKU/term identities. The exact row types are `aws_price_row`, `aws_sku_price_change`, `aws_cost_impact_report`, and `aws_price_export`. Every report row includes `scopeCount`, `estimatedMonthlyCostUsd`, and `sourceUrl`. Report rows also show observed price changes and estimated monthly deltas where a supplied usage quantity matches the AWS unit.

**Value report:** A scheduled run turns official AWS public price-list changes into a review queue with the affected service, region, SKU, term, previous/current USD unit price, and estimated monthly cost impact. Baselines and identical watch runs are quiet by default, so buyers pay for new information rather than heartbeat activity.

This is an official-list-price reader, not an AWS account billing calculator. Public list prices can differ from an account invoice because of discounts, credits, free tier, taxes, negotiated pricing, Savings Plans, Reserved Instance utilization, data transfer, commitments, and other account or workload conditions.

### Run the next report

- [Azure Retail Price Cost Impact Report](https://apify.com/taroyamada/azure-retail-price-cost-impact-report) generates the corresponding source-linked Azure retail price alerts and monthly cost-impact report.
- [AI API Pricing & Model Lifecycle Report](https://apify.com/taroyamada/ai-api-pricing-model-lifecycle-report) compares public model pricing and lifecycle changes.

### Quick Start

Run `npm install`, then `npm test`. For a local sample without network access, use `dryRun: true`. In Apify, supply the same JSON shape through the Actor input.

The actor reads only these official AWS Bulk API JSON paths on `pricing.us-east-1.amazonaws.com`:

```text
https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/index.json
https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/{serviceCode}/current/region_index.json
https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/{serviceCode}/{version}/{region}/index.json
```

There is no AWS SDK credential flow, signed request, account lookup, or EC2 support.

### Examples

#### 1. First report after a baseline

Use `baseline_only` on the first scheduled run, then use `emit_current` when the buyer wants the current report delivered.

```json
{
  "scopes": [
    {
      "serviceCode": "AWSLambda",
      "region": "us-east-1",
      "usage": {
        "Requests": 12000000,
        "GB-Seconds": 300000
      }
    },
    {
      "serviceCode": "AmazonS3",
      "region": "us-east-1",
      "filters": {
        "productFamily": "Storage",
        "unit": "GB-Mo",
        "attributes": {
          "storageClass": "General Purpose",
          "volumeType": "Standard"
        }
      },
      "usage": {
        "GB-Mo": 2500
      }
    }
  ],
  "mode": "report",
  "initialRunMode": "emit_current",
  "generateReport": true,
  "emitUnchanged": false,
  "emitRawRows": false,
  "maxChargeUsd": 10
}
```

This produces one report row when the snapshot is first delivered. Its `estimatedMonthlyCostUsd` uses one unambiguous pricing lane per unit. OnDemand tiers are applied only when their ranges are contiguous and non-overlapping; mutually exclusive terms are never added together.

#### 2. Scheduled price-change watch

```json
{
  "scopes": [
    {
      "label": "Lambda production",
      "serviceCode": "AWSLambda",
      "region": "ap-northeast-1",
      "filters": {
        "usageType": "Lambda-GB-Second",
        "unit": "Lambda-GB-Second"
      },
      "usage": {
        "Lambda-GB-Second": 800000
      }
    }
  ],
  "mode": "watch",
  "initialRunMode": "baseline_only",
  "generateReport": true,
  "emitUnchanged": false,
  "maxChargeUsd": 10
}
```

The baseline writes a durable snapshot and emits zero rows. Later runs emit only new, removed, or price-changed SKU/term dimensions. An identical watch emits zero rows and zero charges.

#### 3. Filtered raw price export

```json
{
  "scopes": [
    {
      "serviceCode": "AmazonRDS",
      "region": "us-west-2",
      "filters": {
        "productFamily": "Database Instance",
        "termTypes": ["OnDemand"],
        "descriptionIncludes": ["db.t3.micro"],
        "unit": "Hrs"
      },
      "usage": {
        "Hrs": 730
      }
    }
  ],
  "mode": "report",
  "initialRunMode": "emit_current",
  "generateReport": true,
  "emitRawRows": true,
  "maxChargeUsd": 10
}
```

Raw rows use the `aws-price-row` event at $0.002 each. A successful raw-row delivery also includes one `aws-price-export` handoff row.

### Pricing And No-Change Behavior

`productFamily`, `usageType`, `operation`, `unit`, `offerTermCode`, `tier`, and every entry in `filters.attributes` use exact case-insensitive matching. `descriptionIncludes` is only a description substring check and is never a product selector. For S3 storage, use exact `storageClass` or `volumeType` attributes. A scope that leaves multiple SKU lanes, S3 storage variants, overlapping or incomplete tiers, or Reserved alternatives selected fails closed instead of summing them.

| Value event | Price | Emitted when |
| --- | ---: | --- |
| `aws-price-row` | $0.002 | A selected canonical USD SKU/term price row is delivered |
| `aws-sku-price-change` | $0.10 | A stable SKU/term price dimension is added, removed, or changes price |
| `aws-cost-impact-report` | $3.00 | A report-worthy current snapshot or watch change is delivered |
| `aws-price-export` | $2.00 | A raw price-row handoff is delivered |

There is no start charge. Empty datasets are not pushed. `emitUnchanged` defaults to `false`; state suppresses repeated row content and stable report content. `baseline_only` always saves a successful snapshot with zero output rows. A successful identical watch has zero output rows and zero charges. `maxChargeUsd` is a hard preflight cap: if the estimated event total exceeds it, the run fails before delivery and state commit.

### Safety And Source Boundaries

- Only official public AWS offer/index JSON files are accepted. The host and `/offers/v1.0/aws/` path are allowlisted.
- Responses are streamed and bounded at 50 MiB. Timeouts, partial streams, invalid JSON, 403, 429, and suspicious-empty documents fail closed.
- ETag and Last-Modified validators are sent when a prior successful source response has them. A 304 uses the stored successful snapshot; a 304 without a baseline is an error.
- State is keyed by a normalized scope fingerprint. A missing first-run file is an empty baseline; malformed, unreadable, or failed state reads/writes fail closed. A failed or incomplete run never calls the state save path.
- Delivery validates every row, event name, stable key, planned charge, and `maxChargeUsd` before the first push. Unknown or invalid rows and `eventChargeLimitReached` are failures; an already accepted push cannot be rolled back by the platform.
- Currency is fixed to USD. `AmazonEC2` and every other service are rejected during input validation.

The Apify Console dataset view is defined in `.actor/dataset_schema.json`; `.actor/output_schema.json` links the `results` output to the run default dataset.

### See Also

- [Website Content Crawler](https://apify.com/apify/website-content-crawler)
- [Google Search Scraper](https://apify.com/apify/google-search-scraper)

# Actor input Schema

## `scopes` (type: `array`):

Each scope selects one supported AWS service and one required AWS region. Scope order is normalized for durable state.

## `mode` (type: `string`):

report creates a current cost-impact report; watch emits stable SKU/term changes.

## `initialRunMode` (type: `string`):

baseline\_only stores the first successful snapshot with zero rows; emit\_current permits current rows/report output on a new scope fingerprint.

## `generateReport` (type: `boolean`):

Emit one aws\_cost\_impact\_report row when the selected mode has a report-worthy observation.

## `emitUnchanged` (type: `boolean`):

When false, repeated identical rows and reports are suppressed. The default watch no-change run emits zero rows and zero charges.

## `emitRawRows` (type: `boolean`):

Emit canonical aws\_price\_row rows and an aws\_price\_export handoff row. Use filters and maxChargeUsd for broad services.

## `maxChargeUsd` (type: `number`):

Hard PAY\_PER\_EVENT cap. A run exceeding it fails before delivery and state commit.

## `dryRun` (type: `boolean`):

Return deterministic sample rows without network access, delivery, charges, or state writes.

## Actor input object example

```json
{
  "scopes": [
    {
      "serviceCode": "AWSLambda",
      "region": "us-east-1",
      "usage": {
        "Requests": 1000000,
        "GB-Seconds": 100000
      }
    }
  ],
  "mode": "report",
  "initialRunMode": "baseline_only",
  "generateReport": true,
  "emitUnchanged": false,
  "emitRawRows": false,
  "maxChargeUsd": 25,
  "dryRun": false
}
```

# Actor output Schema

## `results` (type: `string`):

Rows written to the run default dataset, resolved from the run defaultDatasetId.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/aws-cloud-pricing-cost-impact-report").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/aws-cloud-pricing-cost-impact-report").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 '{}' |
apify call taroyamada/aws-cloud-pricing-cost-impact-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=taroyamada/aws-cloud-pricing-cost-impact-report",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/gmvogja7BKOaBeRud/builds/oddhHRekIcoHwXaNm/openapi.json