# Shopify SEO & Performance Auditor (`trovevault/shopify-seo-performance-auditor`) Actor

Audits public Shopify stores for prioritized technical SEO, canonical, duplicate-content, structured-data, image, Lighthouse, and third-party bloat findings.

- **URL**: https://apify.com/trovevault/shopify-seo-performance-auditor.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** SEO tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 findings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Shopify SEO & Performance Auditor

Turn a Shopify storefront into a prioritized SEO and performance backlog. This Actor samples important store templates, checks Shopify-specific URL behavior, runs mobile Lighthouse, and returns consolidated findings with `severity`, `affectedPages`, `evidence`, `recommendedFix`, `estimatedEffort`, and `confidence`.

No Shopify admin access is required. Use it for onboarding, QA, and monitoring.

### What does this Shopify SEO audit check?

- Canonical tags on product variants and collection-scoped product URLs
- Collection pagination, crawl directives, sitemap coverage, and response errors
- Missing, duplicate, short, or long titles and meta descriptions
- Duplicate sampled content and heading problems
- Missing image alt text
- Missing or conflicting Product JSON-LD
- Mobile Lighthouse performance, lab LCP, CLS, Total Blocking Time, and page weight
- JavaScript and third-party transfer weight with cautious provider attribution
- Origin-level CrUX LCP, CLS, and INP when the Actor operator configures field-data access

The output includes `healthScore`, A–F `grade`, category scores, and a ranked action list. It does not estimate rankings, traffic, revenue, or conversion loss.

### Who uses this Shopify performance checker?

- **Agencies** scope client work from prioritized evidence.
- **Merchants** identify technical issues before hiring specialists.
- **Consultants** compare theme or app releases.
- **CRO teams** isolate page-weight and third-party script risks.

### How does the audit work?

The Actor confirms Shopify signals, reads `robots.txt` and XML sitemaps, and samples home, product, collection, content, and policy pages. Separate requests validate variant, collection-product, and pagination behavior.

A five-page quick audit measures Lighthouse on the homepage. Larger audits measure up to three templates: homepage, product, and collection. Coverage, Lighthouse measurements, CrUX availability, and soft failures are stored in `RUN_SUMMARY`.

### How do I run the Actor?

1. Open the Actor in Apify Console.
2. Add one or more public Shopify storefront homepages.
3. Keep **Pages per Store** at `5` for a quick test or use `25` for broader triage.
4. Run the Actor and open **Prioritized Shopify Audit Findings**.
5. Use `priority` for action order and `sampleUrls` to verify each finding.

Example input:

```json
{
  "startUrls": [{ "url": "https://www.deathwishcoffee.com" }],
  "maxPagesPerStore": 25,
  "runId": "client-audit-2026-08"
}
```

### What input does the Shopify auditor accept?

| Field | Required | Behavior |
|---|---:|---|
| `startUrls` | Yes | One to ten public Shopify storefront URLs; homepage URLs provide the best discovery path. |
| `maxPagesPerStore` | No | Representative pages per store, `5`–`500`; default `25`. Five pages use one Lighthouse target; larger runs use up to three. |
| `proxyConfiguration` | No | Leave disabled for open stores; enable Apify Proxy for permitted access-denied, rate-limited, or regional cases. |
| `datasetId` | No | Existing dataset that receives a copy of every finding in addition to the default run dataset. |
| `runId` | No | Client, project, or workflow identifier copied into every finding and `RUN_SUMMARY`. |

### What data does it return?

Each dataset row is one consolidated finding, sorted by priority:

```json
{
  "recordType": "finding",
  "storeUrl": "https://www.deathwishcoffee.com/",
  "healthScore": 84,
  "grade": "B",
  "categoryScores": {
    "technical_seo": 100, "crawlability": 91, "content": 87,
    "images": 97, "structured_data": 100, "performance": 53,
    "third_party_bloat": 67
  },
  "priority": 6,
  "category": "performance",
  "severity": "high",
  "issueCode": "LOW_LIGHTHOUSE_PERFORMANCE",
  "issue": "Representative pages have a weak mobile Lighthouse performance score",
  "affectedPages": 1,
  "affectedPercent": 20,
  "sampleUrls": ["https://www.deathwishcoffee.com/"],
  "pageTypes": ["homepage"],
  "evidence": "Mobile Lighthouse performance score: 13/100.",
  "recommendedFix": "Prioritize the largest Lighthouse opportunities on representative templates, then retest under the same conditions.",
  "estimatedEffort": "medium",
  "confidence": "high",
  "metricValue": 13,
  "metricUnit": "score",
  "runId": "client-audit-2026-08"
}
```

`healthScore` is derived from weighted `categoryScores`. Use `issueCode` for dashboards, `priority` for action order, and `affectedPages` with `sampleUrls` for validation. `affectedPercent` covers only the sampled pages. Numeric findings add `metricValue` and `metricUnit`.

### How can I integrate the audit?

Start an asynchronous run with the Apify API:

```bash
curl "https://api.apify.com/v2/acts/TroveVault~shopify-seo-performance-auditor/runs" \
  -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.deathwishcoffee.com"}],
    "maxPagesPerStore": 5,
    "runId": "client-audit-2026-08"
  }'
```

Or use the official Apify JavaScript client:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('TroveVault/shopify-seo-performance-auditor').call({
  startUrls: [{ url: 'https://www.deathwishcoffee.com' }],
  maxPagesPerStore: 5,
  runId: 'client-audit-2026-08',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Download results in Apify formats. `RUN_SUMMARY` contains coverage and measurements. Schedules rerun inputs; `datasetId` appends to a shared dataset. Apify MCP can start the Actor and inspect results. Nothing is written to Shopify.

### How should Lighthouse and Core Web Vitals be interpreted?

Lighthouse provides laboratory measurements: lab LCP, CLS, and Total Blocking Time are not real-user Core Web Vitals. With sufficient Chrome UX Report coverage and configured field access, `RUN_SUMMARY.fieldCoreWebVitals` can include origin-level p75 LCP, CLS, and INP. Otherwise it records why field data is unavailable.

### What are the limitations?

- Only public storefront evidence is audited. Admin settings, unpublished themes, analytics, Search Console, conversion data, and server-side integrations are unavailable.
- Protected stores can return partial rows. Headless storefronts may be reported as unsupported.
- Exact duplicate detection is conservative; near-duplicate copy still requires specialist review.
- Lighthouse varies with experiments, geolocation, network conditions, and third parties. Compare runs under similar conditions.
- Third-party attribution identifies a provider, not definitive responsibility for a specific app or theme block.
- Scores prioritize investigation; they do not predict rankings, traffic, revenue, or conversion uplift. The Actor never modifies the store.

### How do I troubleshoot a run?

| Issue | Likely cause | Solution |
|---|---|---|
| Site reported as non-Shopify | The public HTML lacks reliable Shopify signals | Submit the public homepage; fully headless builds may remain unsupported. |
| HTTP 403, 429, or access page | Datacenter traffic is blocked or rate-limited | Enable Apify Proxy, reduce the run to five pages, and retry using permitted locations. |
| Lighthouse unavailable but SEO rows exist | Chrome failed or the page did not stabilize | Check `RUN_SUMMARY.lighthouse.reason`, retain the usable SEO findings, and retry with default memory. |
| No field Core Web Vitals | CrUX access is absent or the origin lacks eligible samples | Use Lighthouse for diagnostics and Search Console when you control the store. |
| Run takes too long | The page sample or number of stores is large | Test one store with five pages, then split large batches across runs. |

### Shopify SEO Auditor FAQ

**Can it audit several stores?** Yes. One run accepts up to ten and soft-fails individual targets.

**Can it monitor changes?** Yes. Schedule runs and use `runId` or `datasetId` for a shared history.

**Does it need Shopify credentials?** No. Never submit credentials, customer data, or private previews.

**Is it legal to audit public stores?** Use the Actor for authorized audits or legitimate public research, respect applicable terms and laws, and avoid personal data. This documentation is not legal advice.

### Support

Open an issue from the Actor page with the run ID, storefront URL, and finding. Never include credentials, customer data, API tokens, or private previews.

# Actor input Schema

## `startUrls` (type: `array`):

One to ten public Shopify storefront homepages to audit. Examples: https://www.deathwishcoffee.com and https://shop.example.com. The actor deduplicates URLs and samples public templates without Shopify admin access.

## `maxPagesPerStore` (type: `integer`):

Maximum representative pages audited per store, from 5 to 500. The five-page quick audit measures Lighthouse on the homepage; larger audits measure up to three templates. Default: 25 pages.

## `proxyConfiguration` (type: `object`):

Controls network access. Leave disabled for open stores. Enable Apify Proxy only when a storefront returns access-denied, rate-limit, or region-specific responses. Default: disabled.

## `datasetId` (type: `string`):

Existing Apify dataset ID that receives a copy of every finding row, in addition to the run's default dataset. Example: a shared monthly-monitoring dataset. If omitted, only the default dataset is written.

## `runId` (type: `string`):

Client, project, or workflow identifier copied into every output row and RUN\_SUMMARY. Examples: client-acme or audit-2026-08. If omitted, the field is not added to rows.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.deathwishcoffee.com",
      "label": "Public Shopify storefront"
    }
  ],
  "maxPagesPerStore": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.deathwishcoffee.com",
            "label": "Public Shopify storefront"
        }
    ],
    "maxPagesPerStore": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/shopify-seo-performance-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 = {
    "startUrls": [{
            "url": "https://www.deathwishcoffee.com",
            "label": "Public Shopify storefront",
        }],
    "maxPagesPerStore": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/shopify-seo-performance-auditor").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 '{
  "startUrls": [
    {
      "url": "https://www.deathwishcoffee.com",
      "label": "Public Shopify storefront"
    }
  ],
  "maxPagesPerStore": 5
}' |
apify call trovevault/shopify-seo-performance-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,trovevault/shopify-seo-performance-auditor"
        }
    }
}

```

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/2cqsiO95EPkIxnLAV/builds/BvrnvA3j9zIXLLp1Q/openapi.json