# E-Com Checkout Auditor (`solutionssmart/e-com-checkout-auditor`) Actor

Checkout monitoring Actor for Shopify-first e-commerce stores using Playwright and deterministic heuristics.

- **URL**: https://apify.com/solutionssmart/e-com-checkout-auditor.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** Developer tools, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## E-Com Checkout Auditor

### What does E-Com Checkout Auditor do?

E-Com Checkout Auditor is an Apify Actor for automated checkout monitoring on Shopify-based e-commerce stores. It simulates a complete customer journey from landing page through to checkout page without completing payment, automatically detecting and reporting issues that would prevent real customers from completing their purchases.

E-Com Checkout Auditor can audit:

- Product discovery from homepage, collection page, or direct product URL
- Add to Cart and Buy Now button functionality
- Cart state validation and item persistence
- Coupon code application and validation
- Checkout page accessibility and response times
- JavaScript console errors and page errors
- Failed network requests and HTTP errors
- Checkout performance metrics

### Why monitor e-commerce checkout flows?

Checkout issues are among the leading causes of cart abandonment. Even small friction points—broken buttons, missing coupons, or slow load times—can result in significant revenue loss. E-Com Checkout Auditor continuously monitors your checkout experience to catch these issues before your customers do.

Here are some of the ways you could use this Actor:

- Prevent revenue loss from broken add-to-cart flows
- Monitor checkout page performance across different traffic sources
- Validate coupon campaigns are working correctly
- Detect JavaScript errors affecting customer experience
- Track checkout availability after site deployments or updates
- Identify geo-specific checkout issues with proxy support

### How to use E-Com Checkout Auditor

Using E-Com Checkout Auditor is straightforward. Follow these steps to audit your checkout flow:

1. Click on **Try for free** or open the Actor
2. Enter your store's target URL (e.g., `https://example-store.com`)
3. Optionally provide a coupon code to test discount application
4. Configure timeout, proxy settings, and screenshot preferences
5. Click **Run**
6. When complete, preview or download your audit report from the Dataset tab

### Input configuration

```json
{
  "target_url": "https://example-store.com",
  "coupon_code": "TEST10",
  "store_password": "demo-password",
  "timeout_seconds": 30,
  "headless": true,
  "use_proxy": false,
  "proxy_country": "US",
  "proxy_groups": ["RESIDENTIAL"],
  "proxy_session_id": "checkout_auditor",
  "retry_without_proxy": true,
  "take_screenshot_on_failure": true
}
````

**Key parameters:**

- `target_url` - The root URL of your e-commerce store (required)
- `coupon_code` - Optional coupon code to validate during checkout
- `store_password` - Password for password-protected stores
- `timeout_seconds` - Maximum time to wait for each phase (default: 30)
- `headless` - Run browser in headless mode (default: true)
- `use_proxy` - Enable proxy rotation (default: false)
- `proxy_country` - Country code for geo-targeting (e.g., "US", "GB")
- `proxy_groups` - Optional Apify proxy groups such as `RESIDENTIAL`, selected from a form multiselect or entered manually
- `proxy_session_id` - Optional sticky proxy session identifier
- `retry_without_proxy` - Retry once without proxy if proxy-backed navigation or cart flow fails
- `take_screenshot_on_failure` - Capture screenshot on audit failure (default: true)

**Proxy recommendation:** For public demo stores and publicly accessible storefronts, start with `"use_proxy": false`. Enable proxy only when you need geo-targeting or when the target store blocks direct traffic.

### Results

The Actor pushes exactly one audit report per run to the default dataset.

**Successful audit example:**

```json
{
  "status": "success",
  "target_url": "https://example-store.com",
  "product_url": "https://example-store.com/products/example",
  "checkout_url": "https://example-store.com/checkouts/...",
  "phase_failed": null,
  "response_time_ms": 2450,
  "console_errors_count": 0,
  "page_errors_count": 0,
  "failed_requests_count": 0,
  "http_error_count": 0,
  "coupon_code": "TEST10",
  "coupon_applied": true,
  "screenshot_key": null,
  "errors": [],
  "network_errors": [],
  "console_errors": [],
  "timestamp": "2026-05-18T00:00:00Z"
}
```

**Failed audit example:**

```json
{
  "status": "failed",
  "phase_failed": "add_to_cart",
  "response_time_ms": null,
  "checkout_url": null,
  "screenshot_key": "failure-screenshot-1715999999.png",
  "errors": [
    "Add to Cart button was not found or not clickable."
  ]
}
```

### Tips for monitoring checkout flows

- **Test with real coupon codes** - Validate active promotions to catch discount engine issues early
- **Schedule regular audits** - Use Apify's scheduling feature to run audits during peak traffic hours
- **Monitor after deployments** - Run immediately after site updates to catch checkout regressions
- **Use screenshots on failure** - Enable screenshot capture to visually diagnose checkout issues
- **Test with passwords** - For pre-launch or private stores, provide the store password in input
- **Check response times** - Use the `response_time_ms` metric to identify performance bottlenecks

### How much will it cost to monitor with E-Com Checkout Auditor?

Apify gives you $5 in free usage credits every month on the [Apify Free plan](https://apify.com/pricing). A single checkout audit typically uses minimal credits, so you can run dozens of audits each month completely free!

For regular monitoring, we recommend the [$49/month Starter plan](https://apify.com/pricing), which gives you plenty of credits for daily or hourly checkout audits across multiple stores.

High-volume monitoring? The [Scale plan at $499/month](https://apify.com/pricing) supports continuous, real-time checkout monitoring across your entire e-commerce portfolio.

### Is it legal to monitor e-commerce checkouts?

E-Com Checkout Auditor simulates customer checkout flows on your own stores or stores where you have explicit permission to test. This is standard practice in e-commerce operations and QA.

However, if you're monitoring third-party stores, ensure you have proper authorization. Unauthorized testing or data collection may violate terms of service or applicable laws.

For more information on the legal aspects of web automation, see our blog post: [is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

## `target_url` (type: `string`):

Store homepage, collection page, or direct product page to audit.

## `coupon_code` (type: `string`):

Optional discount or promo code to validate during the checkout journey.

## `store_password` (type: `string`):

Optional storefront password for Shopify password-protected stores.

## `timeout_seconds` (type: `integer`):

Per-phase timeout used for page actions and waits.

## `headless` (type: `boolean`):

Run Chromium in headless mode.

## `use_proxy` (type: `boolean`):

Use Apify Proxy for the browser session.

## `proxy_country` (type: `string`):

Optional ISO country code used for Apify Proxy routing when proxy is enabled, for example US.

## `proxy_groups` (type: `array`):

Optional Apify Proxy groups when proxy is enabled. Pick suggested values or type your own group name if your account uses a different one.

## `proxy_session_id` (type: `string`):

Optional sticky proxy session identifier. Allowed characters: letters, numbers, underscore, dot, tilde.

## `retry_without_proxy` (type: `boolean`):

Retry once without proxy if a proxy-backed run fails in navigation, product detection, add to cart, or cart verification.

## `take_screenshot_on_failure` (type: `boolean`):

Store a failure screenshot in the default key-value store when the audit fails.

## Actor input object example

```json
{
  "target_url": "https://hydrogen-demo-store.myshopify.com/products/the-compare-at-price-snowboard",
  "coupon_code": "TEST10",
  "timeout_seconds": 30,
  "headless": true,
  "use_proxy": false,
  "proxy_country": "US",
  "proxy_groups": [
    "RESIDENTIAL"
  ],
  "proxy_session_id": "checkout_auditor",
  "retry_without_proxy": true,
  "take_screenshot_on_failure": true
}
```

# Actor output Schema

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

Structured checkout audit results stored in the default dataset as one item per run.

## `artifacts` (type: `string`):

Failure screenshots, page HTML snapshots, and selector metadata stored in the default key-value store.

# 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 = {
    "target_url": "https://hydrogen-demo-store.myshopify.com/products/the-compare-at-price-snowboard",
    "coupon_code": "TEST10",
    "proxy_country": "US",
    "proxy_groups": [
        "RESIDENTIAL"
    ],
    "proxy_session_id": "checkout_auditor"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/e-com-checkout-auditor").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 = {
    "target_url": "https://hydrogen-demo-store.myshopify.com/products/the-compare-at-price-snowboard",
    "coupon_code": "TEST10",
    "proxy_country": "US",
    "proxy_groups": ["RESIDENTIAL"],
    "proxy_session_id": "checkout_auditor",
}

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/e-com-checkout-auditor").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 '{
  "target_url": "https://hydrogen-demo-store.myshopify.com/products/the-compare-at-price-snowboard",
  "coupon_code": "TEST10",
  "proxy_country": "US",
  "proxy_groups": [
    "RESIDENTIAL"
  ],
  "proxy_session_id": "checkout_auditor"
}' |
apify call solutionssmart/e-com-checkout-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solutionssmart/e-com-checkout-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "E-Com Checkout Auditor",
        "description": "Checkout monitoring Actor for Shopify-first e-commerce stores using Playwright and deterministic heuristics.",
        "version": "0.1",
        "x-build-id": "EolrHXNY3o8TCVUd0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~e-com-checkout-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-e-com-checkout-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solutionssmart~e-com-checkout-auditor/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-e-com-checkout-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solutionssmart~e-com-checkout-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-e-com-checkout-auditor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "target_url"
                ],
                "properties": {
                    "target_url": {
                        "title": "Target URL",
                        "type": "string",
                        "description": "Store homepage, collection page, or direct product page to audit."
                    },
                    "coupon_code": {
                        "title": "Coupon Code",
                        "type": "string",
                        "description": "Optional discount or promo code to validate during the checkout journey."
                    },
                    "store_password": {
                        "title": "Store Password",
                        "type": "string",
                        "description": "Optional storefront password for Shopify password-protected stores."
                    },
                    "timeout_seconds": {
                        "title": "Timeout Seconds",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Per-phase timeout used for page actions and waits.",
                        "default": 30
                    },
                    "headless": {
                        "title": "Headless Browser",
                        "type": "boolean",
                        "description": "Run Chromium in headless mode.",
                        "default": true
                    },
                    "use_proxy": {
                        "title": "Use Proxy",
                        "type": "boolean",
                        "description": "Use Apify Proxy for the browser session.",
                        "default": false
                    },
                    "proxy_country": {
                        "title": "Proxy Country",
                        "type": "string",
                        "description": "Optional ISO country code used for Apify Proxy routing when proxy is enabled, for example US."
                    },
                    "proxy_groups": {
                        "title": "Proxy Groups",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional Apify Proxy groups when proxy is enabled. Pick suggested values or type your own group name if your account uses a different one.",
                        "items": {
                            "type": "string",
                            "enumSuggestedValues": [
                                "RESIDENTIAL",
                                "SHADER",
                                "GOOGLE_SERP"
                            ],
                            "enumTitles": [
                                "Residential",
                                "Shader",
                                "Google SERP"
                            ]
                        }
                    },
                    "proxy_session_id": {
                        "title": "Proxy Session ID",
                        "type": "string",
                        "description": "Optional sticky proxy session identifier. Allowed characters: letters, numbers, underscore, dot, tilde."
                    },
                    "retry_without_proxy": {
                        "title": "Retry Without Proxy",
                        "type": "boolean",
                        "description": "Retry once without proxy if a proxy-backed run fails in navigation, product detection, add to cart, or cart verification.",
                        "default": true
                    },
                    "take_screenshot_on_failure": {
                        "title": "Take Screenshot On Failure",
                        "type": "boolean",
                        "description": "Store a failure screenshot in the default key-value store when the audit fails.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```