# AI Search Visibility & GEO Audit + Coding Agent Fix Prompt (`eliai/snoffle-report`) Actor

AI search visibility and GEO audit for one product page: can AI read it, do buyers asking Google and AI find it, and who they find instead. Returns the score and a handoff prompt your coding agent runs to apply every fix. $9 per complete report, free quick check, no report no charge.

- **URL**: https://apify.com/eliai/snoffle-report.md
- **Developed by:** [Broke to Built](https://apify.com/eliai) (community)
- **Categories:** SEO tools, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$9,000.00 / 1,000 snoffle 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?

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

## Snoffle: AI search visibility and GEO audit that hands your coding agent the fixes

Snoffle checks one product page and returns a work order your coding agent can run. It reads the
page the way an AI assistant does, asks Google and an AI assistant the questions a buyer would ask,
checks whether other sites mention the product, then asks an AI buyer's agent whether it would buy.
The record it returns ends in **`handoff`**: a prompt you pass straight to Claude Code, Cursor,
Lovable, Bolt or Replit, with every fix in order and a check for each one.

Built for agents and for the solo makers who run them: an agent can call it through the Apify API
or Apify's MCP server, read two fields, and hand the rest to a coding agent without a human in the
loop.

### The agent loop

1. Your agent runs Snoffle on a URL (one call, about 90 seconds).
2. It reads `scores.overall` and `verdict.decision` to decide whether the page needs work.
3. It passes `handoff` to a coding agent, which applies the fixes and verifies each one.
4. After the deploy, it runs Snoffle again with `"fresh": true` to measure the change.

### Two different problems, told apart

A crawler check answers "can AI read the page". Snoffle reports that, and the harder problem
behind it, as separate scores:

- **AI can't read you** (`scores.readiness` is low): robots.txt blocks AI crawlers, the offer only
  appears after scripts run, the price or the buy path is missing, no llms.txt or JSON-LD. These
  are fixes on your own site, and `handoff` covers them.
- **AI reads you but doesn't pick you** (`readiness` is high, `found` is low): the page is fine,
  but buyers asking Google and an AI assistant are shown other products. The record names those
  products (`foundInstead`) and, where Snoffle could judge them, what they have that you don't
  (`strengths`).

Snoffle's own Store listing was the second kind on 2026-11-06: readiness 94, found 18 (example
below).

### The Snoffle score

`scores.overall` is the Snoffle score, 0-100: how likely buyers and AI assistants are to find the
product. It is a measure of visibility, not a forecast of revenue. It has three parts:

- **AI can read it** (`scores.readiness`): can an AI tool read the page, the offer, the price and
  the files without running scripts.
- **Buyers find it** (`scores.found`): does the product come up when buyers ask Google and an AI
  assistant their questions. A search for the product's own name is reported on its own line and
  does not count here.
- **Others mention it** (`scores.traction`): do other sites mention it.

While buyers don't find it and nobody mentions it, the Snoffle score is capped at 40: a site can
be perfectly readable and still sell nothing if nobody can find it.

**On a phone** (`scores.visitors`) is reported separately: what a person on a phone gets, from
Google PageSpeed Insights (mobile). It is never part of the Snoffle score.

### What one report contains

| Field | What it is |
|---|---|
| `url` | The page that was checked |
| `product` | The product name Snoffle read from the page |
| `mode` | How the report was made: `full` or `judged` (a charged report is never `rules`) |
| `scores.overall` | The Snoffle score, 0-100 (above) |
| `scores.readiness` | AI can read it, 0-100 |
| `scores.found` | Buyers find it, 0-100 (`null` if it could not be measured) |
| `scores.traction` | Others mention it, 0-100 (`null` if it could not be measured) |
| `scores.visitors` | On a phone, 0-100 (`null` if it could not be measured) |
| `scores.projectedOverall` | The Snoffle score after every listed fix, capped at 40 while buyers don't find it and nobody mentions it |
| `scores.pillars` | Internal detail behind `readiness`; read the three parts above instead |
| `verdict.decision` | What the buyer's agent decided: `buy`, `recommend_to_human` or `skip` |
| `verdict.headline` | One sentence on why |
| `verdict.blockers`, `verdict.scamFlags` | What stopped it, and anything that looked unsafe |
| `topFixes` | The fixes worth the most points: `title`, `gain` (points), `evidence` (what Snoffle saw) |
| `fixesTotal` | How many fixes the full report lists |
| `allFixes` | Every fix, ranked: `title`, `impact`, `effort` (minutes, hours or days), `gain`, `evidence` |
| `foundInstead` | The products buyers are shown instead of you: `name`, `url`, `timesShown`, `strengths` |
| `buyerQuestions` | The searches Snoffle asked as a buyer |
| `honestCall` | Whether it is worth pushing (`worth`), `why`, the `angle`, and the `firstPage` to write |
| `nameCheck` | Products whose name clashes with yours, and `suggestions` for a clearer name |
| `money` | What the gap costs you, in plain dollars |
| `understood` | What an AI understood: what it is, who it is for, the price and how to buy, each with `clear` |
| `contradictions`, `phoneProblems`, `nextStep` | Where your pages disagree, what breaks on a phone, and the one thing to do first |
| `verdict.reasons`, `verdict.wouldChangeMind` | Why the buyer's agent decided, and what would change its mind |
| `handoff` | The paste-ready prompt for your coding agent, every fix in order, each with a check |
| `reportUrl` | The full report as JSON: every check, its evidence, the search results, rivals |
| `checkedAt` | When the check ran |
| `fromCache` | `true` when this is your own saved report from the last 12 hours (not charged); see Repeat runs |
| `charged` | `true` on a paid report, `false` on a run that was not charged |

#### A real example (this listing)

We ran Snoffle on this Actor's own Store listing, `https://apify.com/eliai/snoffle-report`, on
2026-11-06, before we applied its fixes:

- `scores.overall` **40**: `readiness` **94**, `found` **18**, `traction` **8**
- `verdict.decision` **skip**: "The listing reads well (94/100), but store search doesn't find it:
  found 18/100 for the searches buyers type."
- Top fix: rank for "ai search visibility checker" in Apify Store search, **+33 points**, evidence
  "Apify Store search: not in the 85 results it returned."
- 7 fixes in total, and a `handoff` prompt that starts:
  `You are improving the Apify Store listing of eliai/snoffle-report ... so buyers and AI agents searching the Apify Store find it and choose it.`

This README's first heading and the prefilled input are those fixes, applied. The prefilled input
returns that record for free (see Input).

### Why it is worth running

- **It answers with evidence, not opinion.** Every fix says what Snoffle saw on your page, for
  example "/robots.txt answers 200 with the homepage HTML, so crawlers get no rules."
- **Your coding agent does the work.** The `handoff` prompt gives it each change in order, with
  the file to create and a command to verify it.
- **It checks the buying step too.** It looks at whether an agent can see a price, a way to buy and
  a path that works without a login, and it reads your llms.txt, robots.txt, sitemap, JSON-LD and
  agent card.

### Why $9, when a page check costs cents

A cents-per-page checker gives you a list of problems. Snoffle gives you the finished work order:
the searches buyers actually type and whether you came up, a buyer's-agent verdict on whether it
would buy, and a `handoff` prompt your coding agent runs to fix everything, each step with its own
check. You pay once, only when that full report is in hand.

### Need a cheap check on many URLs?

Snoffle is one deep report per run. For screening, use one of these first and run Snoffle on the
pages that matter:

- **The free check** on this Actor (`"quick": true`, see Input): scores and top problems in a few
  seconds, $0, 3 a day per Apify account.
- **[AI Readability Checker](https://apify.com/eliai/ai-readability-checker)**, our crawler-access
  audit: robots.txt rules per AI crawler, llms.txt and the page as each bot sees it, $0.05 per site.
  It answers "can AI read it" only, not "do buyers find it".

### Input

```json
{ "url": "https://your-product.com/" }
```

One URL per run. A bare domain (`your-product.com`) works. Local addresses, IP addresses and
non-web URLs are refused before anything runs. The prefilled URL is this Actor's own listing: it
returns the real report of it above as a free sample record (`example: true`) without running a
check, so a first click on Start shows real output. Any form of example.com, example.org or
example.net returns the same free sample. Neither is charged.

Optional: `"fresh": true` runs a new check even if you checked the same URL in the last 12 hours
(use it after you deploy fixes). A fresh check is a new report and is charged.

Optional: `"quick": true` runs the **free check** instead, the same free check as on Snoffle's
own site: the scores, the headline and the top problems in plain words, from Snoffle's plain
rules, in a few seconds. It is free (`"free": true`, `"charged": false`), 3 a day per Apify
account. It has no buyer's-agent model, no Google search, no fix evidence and no `handoff`
prompt, so the full report can score differently. Use it to screen URLs, then run the full report
on the ones that matter.

### Use it from an AI agent

- **Apify API, start the run and fetch the record (the reliable way):**
  `POST https://api.apify.com/v2/acts/eliai~snoffle-report/runs?token=YOUR_TOKEN&timeout=360&waitForFinish=60`
  with body `{"url": "https://your-product.com/"}`. Poll
  `GET https://api.apify.com/v2/actor-runs/RUN_ID?waitForFinish=60` until `status` is
  `SUCCEEDED`, then read the record from
  `GET https://api.apify.com/v2/datasets/DEFAULT_DATASET_ID/items`.
- **Apify API, synchronous** (one call, returns the record):
  `POST https://api.apify.com/v2/acts/eliai~snoffle-report/run-sync-get-dataset-items?token=YOUR_TOKEN&timeout=360`.
  Apify's synchronous endpoints wait at most 300 seconds. A report usually takes about 90, but a
  slow one can run past that: the call then answers HTTP 408 while the run carries on, and is
  charged if it finishes. If that happens, fetch the run's dataset as above instead of starting a
  new run.
- **Apify MCP server**: add `eliai/snoffle-report` at `https://mcp.apify.com` and your agent can
  call it as a tool.
- Read `scores.overall` and `verdict.decision` first, then hand `handoff` to the coding agent.

### Pricing

Pay per event: **$9 per report**, the same price as one report on Snoffle's own site. You are
charged once, only after a complete report is in hand: the Snoffle score and all three scores it
is made of (`readiness`, `found`, `traction`), a verdict, the top fixes and `handoff`. If one of
those scores could not be measured, you get what was measured with `"incomplete": true`, and the
run is not charged. A repeat of the same URL by the same Apify user inside 12 hours is not charged.

**Free check: $0** (`"quick": true`), 3 a day per Apify account. Never charged.

**Not charged:** a bad or missing URL, a page Snoffle cannot load, a timeout, any error on
Snoffle's side, a report missing its top fixes, or a report made without Snoffle's buyer's-agent
model (when that model is unavailable Snoffle can only run its plain rules, which is not the full
report). Those runs end green with a record that says what went wrong and "This run was not
charged." If the run's maximum cost is set below $9, or its timeout is too short for a full
report, the Actor stops before checking anything.

**Repeat runs:** Snoffle keeps your report for a URL for 12 hours, for the same Apify user. If you
ask again for the same URL inside that window, you get the same report back with `fromCache: true`
(Snoffle's `cached` flag) and are not charged, so a retry after a client timeout costs nothing.
Another Apify user's run of the same URL never returns your report; they get their own. To have
your fixes counted, run with `"fresh": true` (charged), or run again once 12 hours have passed.

### Speed and limits

- A report takes about 90 seconds (a full run of this Actor on 2026-10-31: 81 s) and can take up
  to about 150 s when Google PageSpeed is slow. Set the run timeout to 360 seconds or more; the
  Actor refuses to start a check that the timeout could cut off.
- One URL per run. Snoffle checks the public page as a visitor sees it: no login, no form
  submissions, no payments.
- Search results and AI answers change from run to run, so `found` and `traction` can move on an
  unchanged site. Each record lists the exact questions it asked (`buyerQuestions`) and who came
  up instead (`foundInstead`), so you can see what a score is based on. Compare two runs by those
  fields, not by a few points of score.

### FAQ

**What does "Buyers find it" measure?** Snoffle writes the questions a buyer would ask about your
kind of product, asks Google and an AI assistant, and records whether your site appears. 0 means
it did not appear for any of them. Searching your product's name does not count: a buyer who
already knows the name is not the one you need to reach.

**Why is my projected score 40 or lower after every fix?** The fixes on your site raise "AI can
read it". "Buyers find it" and "Others mention it" are held at what was measured, and while both
are low the Snoffle score is capped at 40. Getting found and mentioned is what lifts it past that.

**Is this an SEO audit?** Partly. It covers what search engines and AI assistants need to read the
page (title, description, JSON-LD, robots.txt, sitemap, llms.txt), and adds what an AI buyer's agent
needs to buy: a clear offer, a price, a path that works.

**Who makes it?** Broke to Built. Questions: open an issue on this Actor's Issues tab.

### Changelog

- **0.7** (2026-11-16):
  - README and listing rewritten for agents: the agent loop up front, "AI can't read you" told apart
    from "AI reads you but doesn't pick you", and a plain note that search and AI answers vary
    between runs. The Snoffle score is described as visibility, not a revenue forecast.
  - New section pointing to cheaper screening: the free check, and our AI Readability Checker at
    $0.05 per site. Price, input and output are unchanged.
- **0.6** (2026-11-08):
  - One report is now $9 (was $29), the same as one report on Snoffle's own site.
  - The $0.49 quick check is gone: `"quick": true` is now the free check, the same as on
    Snoffle's site, free, 3 a day per Apify account.
  - A full report missing one of its scores (`readiness`, `found` or `traction`) is no longer
    charged. The record still shows what was measured, with `"incomplete": true` and the reason.
- **0.5** (2026-11-07):
  - 2026-11-08: a quick check missing one of its three scores is no longer charged. The record
    still shows what was measured, with `"incomplete": true` and the reason.
  - A paid report now carries the whole report in the record: every fix, who buyers find instead,
    the buyer questions, the honest call, a name check, the money line, what an AI understood, and
    the one next step. Before, the record held only the top 3 fixes.
  - New `quick` input: a $0.49 quick check (scores, verdict and fix titles from Snoffle's plain
    rules, no model, no `handoff`). The full report is unchanged.
- **0.3** (2026-11-06):
  - Snoffle checked its own listing and we applied the fixes: the title, description and this
    README now use the words buyers search (AI search visibility checker, product page SEO audit,
    AI agent readiness score), and say who it is for and why it costs $29.
  - The prefilled input is now this listing's URL, and its free sample is the real report Snoffle
    made of this listing on 2026-11-06, not a placeholder. example.com still returns it for free.
- **0.2** (2026-11-01):
  - Each Apify user gets their own 12-hour saved copy: the Actor sends your Apify user id to
    Snoffle, so another user's run of the same URL never returns your report, and yours is never
    theirs. New optional input `fresh` runs a new check inside the 12 hours.
  - `scores.grade` is no longer read: Snoffle deprecated it. The record carries it only while
    Snoffle still sends it, and the status line and the dataset view no longer show it. The
    record adds `scores.traction` (others mention it) and `scores.visitors` (on a phone).
  - `scores.projectedOverall` is now the Snoffle score after every listed fix, capped at 40 while
    buyers don't find it and nobody mentions it (it was a different, older score after the top 3 fixes only).
    The free sample record matched the example of that version.
  - Timeouts: the Actor waits up to 300 s for Snoffle, refuses to start (or to retry) with less
    than 330 s of run time left, and bounds every step after the answer, so a slow report is
    never cut off mid-run.
  - A report Snoffle made without its buyer's-agent model (`mode: "rules"`), or one missing its
    top fixes, is no longer charged. The record now carries `mode`. After a timeout the Actor no
    longer retries (that would start a second full check).
  - After the charge, the Actor tells Snoffle which run was charged and at what price, so
    Snoffle's books follow what Apify charged. Your record and your charge are unaffected by it.
  - A run that Apify restarts (a platform migration) after it already delivered and charged the
    report stops there instead of writing a second record.
  - Every form of example.com (www., any path) returns the free sample. The run's output links
    only the dataset; the full-report link is the record's `reportUrl`, set only when a report was
    produced.
- **0.1** (2026-10-31): first version. One report per run, charged only on a complete report.

# Actor input Schema

## `url` (type: `string`):

The public page of the product to check, usually its homepage or main product page. A bare domain works too. One report per run ($9); it takes about 90 seconds. The prefilled URL is this Actor's own listing: it returns a free sample, the real report Snoffle made of it, and is not charged.

## `quick` (type: `boolean`):

Turn on for the free check, the same as on Snoffle's own site: the scores, the headline and the top problems from Snoffle's plain rules, in a few seconds. Free, 3 a day per Apify account, never charged. No buyer's-agent model, no Google search and no coding-agent prompt. Leave off for the full report ($9).

## `fresh` (type: `boolean`):

Leave off and a repeat of a URL you checked in the last 12 hours returns your saved report, not charged. Turn on to run a new check now (after you deploy fixes); a fresh check is a new report and is charged ($9).

## Actor input object example

```json
{
  "url": "https://apify.com/eliai/snoffle-report",
  "quick": false,
  "fresh": false
}
```

# Actor output Schema

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

One record: scores, the buyer's-agent verdict, the top fixes and the coding-agent prompt. When a report was produced, its reportUrl field links the full report (every check Snoffle ran, with its evidence).

# 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 = {
    "url": "https://apify.com/eliai/snoffle-report"
};

// Run the Actor and wait for it to finish
const run = await client.actor("eliai/snoffle-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 = { "url": "https://apify.com/eliai/snoffle-report" }

# Run the Actor and wait for it to finish
run = client.actor("eliai/snoffle-report").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 '{
  "url": "https://apify.com/eliai/snoffle-report"
}' |
apify call eliai/snoffle-report --silent --output-dataset

```

## MCP server setup

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

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/HbMCgaX0pgONhsDxC/builds/Fw5KnJztOaY4oYVbB/openapi.json
