# PageSpeed vs Competitors: Keyword In, App-Level Blame (`vncntlabs/pagespeed-vs-competitors`) Actor

The only Apify Store tool that takes a keyword in, audits the pages ranking for it, and names the apps that slow you down compared with the pages that outrank you. Lighthouse lab scores, Core Web Vitals, and an Ask-your-developer list. Bulk URL mode included. No API key needed.

- **URL**: https://apify.com/vncntlabs/pagespeed-vs-competitors.md
- **Developed by:** [VNCNT Labs](https://apify.com/vncntlabs) (community)
- **Categories:** SEO tools, Developer tools, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 page auditeds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## PageSpeed vs Competitors: Keyword In, Ranking Pages Audited, App-Level Blame

This is the only Apify Store tool that takes a keyword in, audits the pages ranking for it, and names the apps that slow you down compared with the pages that outrank you.

Enter a keyword and your URL. We find Google's top organic pages (default 5, max 10), run Lighthouse on each of them and on your page in the same run with the same device, and return a verdict like:

> Judge.me reviews costs you 410 ms of main-thread time and 180 KB, and 4 of the 5 faster pages don't load it.

The first row in the dataset is a per-keyword summary: that verdict, an **Ask your developer** list of the top 3 removable apps with estimated savings, and your scores versus the median of the pages that outrank you. Page rows follow, with performance / SEO / accessibility / best-practices scores, LCP, TBT, CLS, FCP, Speed Index, page weight, top fixes, and named third-party vendors.

A plain URL list mode is included for agencies and monitoring. It is not the pitch.

Failed audits, unresolved search results and empty keywords are **never charged**.

### Who it's for

- **Shopify, WooCommerce and Etsy-seller store owners:** find out whether a reviews app, a pixel or a marketing script is the reason you lose to faster pages for a buying keyword.
- **SEO and performance teams:** stop pasting 5–10 URLs into PageSpeed Insights one by one. The ranking pages are found and audited for you.
- **Agencies:** one run per client keyword, with a short list you can hand to a developer.

### What you get

- One **summary** row per keyword, first in the dataset: `verdict`, `askYourDeveloper`, your metrics vs the median of the pages that outrank you (`lcpGapMs`, `tbtGapMs`, `perfGap`), flagged vendors, and any failed or skipped results listed separately.
- One **page** row per audited URL: rank, scores (0–100), Core Web Vitals, page weight, request count, top 3 Lighthouse fixes, and named vendors (main-thread time and transfer size).
- Vendor names come from a maintained Shopify / Woo / Etsy-seller app map (Judge.me, Klaviyo, Hotjar, Meta Pixel and others) plus the open-source [third-party-web](https://github.com/patrickhulce/third-party-web) dataset (MIT license, © Patrick Hulce).
- A noise guard: a vendor is flagged only when it adds at least 150 ms of main-thread time or at least 100 KB **and** is missing from most of the faster pages. Smaller amounts are labeled "within lab noise". The numbers are always shown.

This is **lab data** from one Lighthouse run per page. Scores drift from run to run. Google ranks on field data; speed is one ranking factor, not the explanation. Not affiliated with Google or Lighthouse.

### Input

| Field | What it does |
| --- | --- |
| `keywords` | Google keywords to compare (up to 20). This is the main mode. |
| `yourUrl` | Your page, compared with the pages that outrank it. Recommended. |
| `topN` | How many organic results to audit, 1–10. Default 5. |
| `country` | Google country edition used to find the ranking pages. Default United States. |
| `language` | Optional language code (`en`, `de`, `fr`…). Defaults to the country's main language. |
| `device` | `mobile` (default) or `desktop`. Every page in the run is audited with the same device. |
| `urls` | Bulk URL mode: a plain list of pages to audit, with no keyword comparison. Ignored when `keywords` is set. Up to 50. |

```json
{
  "keywords": ["custom t shirt printing"],
  "yourUrl": "https://www.printful.com/",
  "topN": 3,
  "country": "United States",
  "device": "mobile"
}
```

The prefilled input (one keyword, top 3, mobile, plus your URL) is sized to finish well inside 5 minutes.

### Output

The first dataset row for each keyword is the summary. This one is from a real run on 12 Nov 2026 (America/New_York) for “custom t shirt printing” with `https://www.printful.com/` as the example URL, top 3, mobile, United States (run `A6r0UJgaAOyt3CKIt`). Lab scores drift; a later run will not match these numbers.

```json
{
  "type": "summary",
  "keyword": "custom t shirt printing",
  "verdict": "No single app cleared the lab-noise threshold (at least 150 ms of main-thread time or 100 KB, and missing from most faster pages). Your LCP is 4301 ms from the median of the pages that outrank you.",
  "askYourDeveloper": [],
  "yourUrl": "https://www.printful.com/",
  "yourPosition": null,
  "yourPerformance": 41,
  "medianPerformance": 50,
  "perfGap": -9,
  "yourLcpMs": 10422,
  "medianLcpMs": 6121,
  "lcpGapMs": 4301,
  "yourTbtMs": 803,
  "medianTbtMs": 846,
  "tbtGapMs": -43,
  "flaggedVendors": [],
  "failedAudits": [],
  "skippedResults": []
}
```

On that run Printful was not in the top 3, so all three ranking pages outranked it. Its vendors were named and labeled, but none were flagged: Google Tag Manager (35 ms, 198 KB, present on most faster pages), Riskified, Sift and CookieFirst (all within lab noise). Ranking Shopify and customizer apps were named too, including Zakeke, Code Black Belt and HulkApps.

When an app does clear the threshold and is missing from most faster pages, the verdict looks like: “Judge.me reviews costs you 410 ms of main-thread time and 180 KB, and 4 of the 5 faster pages don't load it.” That line is the shape of `askYourDeveloper` as well.

A page row includes `position`, `isYours`, `outranksYou`, `url`, `performance`, `seo`, `lcpMs`, `tbtMs`, `cls`, `pageWeightKB`, `topFixes` and `vendors` (each with `name`, `mainThreadMs`, `transferKB`, and a `flagLabel` on your page).

### How ranking URLs are resolved

Google often wraps organic links as `google.com/goto`. This Actor **never fetches Google** (or any page) from Apify. It uses DataForSEO's standard-priority Google organic SERP, which returns the resolved landing URL. If a result is still a goto wrapper, that row is skipped, not charged, and the reason is written on the row. Breadcrumb and domain fields are not used as the audit URL, because they do not reliably include the full path of the ranking page.

### Pricing

Pay per event, after Apify's start fee. Prices below are live.

| Event | Price | When it is charged |
| --- | --- | --- |
| Actor start | $0.005 | Once per run (Apify's platform fee) |
| `lighthouse-audit` | $0.01 | Each page Lighthouse successfully audited |
| `keyword-compared` | $0.02 | Each keyword whose results were fetched and at least one ranking page was audited |

Failed audits, unresolved results, empty keywords and summary rows are free.

A typical keyword run (top 5 ranking pages + your page) is $0.085 before Apify's share: $0.005 start + 6 × $0.01 + $0.02.

### Data and licensing

Ranking pages and Lighthouse reports come from DataForSEO's licensed SERP and On-Page Lighthouse APIs. Lighthouse is Apache-2.0 open source. Vendor names also use the [third-party-web](https://github.com/patrickhulce/third-party-web) dataset (MIT, © 2019 Patrick Hulce); the license is bundled in the Actor source. No personal data is collected. No Google API key is used.

### Limits

- Lab data, not Chrome UX Report field data.
- One Lighthouse run per page; repeat runs will not match to the point.
- Up to 20 keywords or 50 URLs per run; at most 10 ranking pages per keyword.
- Some sites (or interstitial / bot-challenge pages) cannot be audited; those rows are free.
- Lighthouse runs on DataForSEO's lab infrastructure, not from a city-level location. The country setting applies to the Google results.

Built by [VNCNT Labs](https://vncntlabs.com). Questions: hello@vncntlabs.com

# Actor input Schema

## `keywords` (type: `array`):

One Google keyword per line. We find the ranking pages, audit them with Lighthouse, and name the apps that slow your page down compared with the pages that outrank you. Up to 20 keywords per run.

## `yourUrl` (type: `string`):

The page you want compared with the pages that outrank it for each keyword. Leave empty to only audit the ranking pages.

## `topN` (type: `integer`):

How many organic results to audit, from 1 to 10. Default 5. The prefilled 3-page run is sized to finish well inside 5 minutes.

## `country` (type: `string`):

Google country edition used to find the ranking pages. Lighthouse itself is a lab run (same device for every page in the run), not a country-level field test.

## `language` (type: `string`):

Optional language code (en, de, fr, es…). Defaults to the country's main language.

## `device` (type: `string`):

Every page in the run is audited with the same device. Mobile is the default.

## `urls` (type: `array`):

Plain list of pages to audit, with no keyword comparison. Useful for agencies and monitoring, but not the main use of this Actor. Ignored when keywords are set. Up to 50 URLs.

## Actor input object example

```json
{
  "keywords": [
    "custom t shirt printing"
  ],
  "yourUrl": "https://www.printful.com/",
  "topN": 3,
  "country": "United States",
  "device": "mobile"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `pages` (type: `string`):

No description

## `all` (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 = {
    "keywords": [
        "custom t shirt printing"
    ],
    "yourUrl": "https://www.printful.com/",
    "topN": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/pagespeed-vs-competitors").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 = {
    "keywords": ["custom t shirt printing"],
    "yourUrl": "https://www.printful.com/",
    "topN": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/pagespeed-vs-competitors").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 '{
  "keywords": [
    "custom t shirt printing"
  ],
  "yourUrl": "https://www.printful.com/",
  "topN": 3
}' |
apify call vncntlabs/pagespeed-vs-competitors --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vncntlabs/pagespeed-vs-competitors"
        }
    }
}
```

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/S9aykV721fOPjdsgs/builds/bt1mptlb44Nrld83h/openapi.json