# CAPI2 Commerce Revenue Operator (`wintry_nutmeg/my-actor-1`) Actor

Approval-gated e-commerce audit pipeline that finds product, measurement, and conversion gaps. Returns evidence-backed opportunities; never sends outreach or changes stores automatically.

- **URL**: https://apify.com/wintry\_nutmeg/my-actor-1.md
- **Developed by:** [Dries Vd](https://apify.com/wintry_nutmeg) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $490.00 / 1,000 commerce operator reports

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/actors/running/actors-in-store.md#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

## CAPI2 Commerce Revenue Operator

An approval-gated Apify Actor that turns public e-commerce signals into a reviewable CAPI2 sales pipeline. It can run a small, explicitly configured set of existing Apify Actors, extract only public store URLs from their results, perform a lightweight commerce-readiness check, and return qualified audit opportunities.

It does **not** send messages, buy services, publish ads, edit a store, or claim that pipeline value is revenue.

### What it manages

1. Optional sources: any Apify Actor that returns public shop URLs, such as search, e-commerce, ad-library, or jobs actors.
2. Store checks: platform clues, product schema, price/availability, cart, returns, shipping, contact and measurement signals.
3. Revenue queue: a priority score, evidence, a fixed offer and the required next approval.

### Input

```json
{
  "executionMode": "plan",
  "storeUrls": ["https://example.com"],
  "offerName": "CAPI2 Verified Commerce Audit",
  "offerPriceUsd": 49,
  "maxStores": 20
}
```

To run sources, explicitly supply both the sources and authorization:

```json
{
  "executionMode": "run_sources",
  "allowChildActorRuns": true,
  "maxChildRuns": 2,
  "maxSpendUsd": 2,
  "sources": [
    {
      "actorId": "apify/google-search-scraper",
      "input": { "queries": "shopify skincare belgium" },
      "maxItems": 20
    }
  ]
}
```

`APIFY_TOKEN` must be configured as an encrypted Actor secret before source runs. The actor caps each child run with `maxTotalChargeUsd`; treat this as a safety limit rather than a price guarantee from a third-party Actor.

### Monetization

Publish with Apify **Pay Per Event** pricing:

- `commerce-operator-report`: one completed operator report.
- `qualified-commerce-opportunity`: one evidence-backed, qualified store opportunity.

Charge only after validating cloud compute cost and completion rates. The suggested $49 offer is a sales offer shown to the buyer; it is not a claimed result.

### Safety boundary

The actor accepts public HTTP(S) sites only and rejects local/private hosts. It never calls CAPI2 paid endpoints, sends outreach, uses private accounts, or applies store/ad changes. Those actions require separate, transaction-specific authorization.

# Actor input Schema

## `executionMode` (type: `string`):

Plan evaluates supplied stores without paid source runs. Run sources may spend up to the configured cap and requires explicit authorization.

## `storeUrls` (type: `array`):

Known public e-commerce homepages or product-page domains to qualify.

## `sources` (type: `array`):

Optional Actor configurations. Each needs actorId, input and optionally maxItems. Sources must return public store URLs.

## `allowChildActorRuns` (type: `boolean`):

Required for run\_sources. This permits source Actor runs, capped by the spending limit.

## `maxChildRuns` (type: `integer`):

Maximum number of explicitly authorized source Actors to run.

## `maxSpendUsd` (type: `number`):

Safety cap passed to each source Actor. Verify a source's own pricing before enabling it.

## `maxStores` (type: `integer`):

Maximum number of public store domains to evaluate in this run.

## `offerName` (type: `string`):

Name of the reviewable audit offer included with qualified opportunities.

## `offerPriceUsd` (type: `number`):

Suggested fixed offer price; this is a pipeline value, not earned revenue.

## Actor input object example

```json
{
  "executionMode": "plan",
  "storeUrls": [],
  "sources": [],
  "allowChildActorRuns": false,
  "maxChildRuns": 3,
  "maxSpendUsd": 3,
  "maxStores": 20,
  "offerName": "CAPI2 Verified Commerce Audit",
  "offerPriceUsd": 49
}
```

# Actor output Schema

## `opportunities` (type: `string`):

Evidence-backed store checks and reviewable CAPI2 audit opportunities.

## `summary` (type: `string`):

Qualification counts, authorization state, cost caps and required next approval.

# 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("wintry_nutmeg/my-actor-1").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("wintry_nutmeg/my-actor-1").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 wintry_nutmeg/my-actor-1 --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,wintry_nutmeg/my-actor-1"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/k9jT3DEZqvvHPVfuw/builds/8RtLPUSeKSvejzfhM/openapi.json