# Revenue Journey Assessment (`alabrida_dev/revenue-journey-assessment`) Actor

Scores a business website across five revenue-journey stages, with the evidence behind every score. Website-only: no entity-listing or SERP lookups.

- **URL**: https://apify.com/alabrida\_dev/revenue-journey-assessment.md
- **Developed by:** [Richard Norwood](https://apify.com/alabrida_dev) (community)
- **Categories:**
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$49.95 / website scan

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

## Revenue Journey Assessment

Give it a website. It returns a scored, evidence-backed read of how that business turns a
stranger into a repeat customer — and where the journey leaks.

Scored checks across five stages — awareness, consideration, decision, conversion, retention —
each with the evidence that produced the score and a plain-language recommendation when it comes
back low. No account, no API key, no setup.

### What you get

One row per run, in the default dataset. The headline numbers:

| Field | What it is |
|---|---|
| `overall_score` | 0–10, the five stages weighted for this kind of business |
| `awareness_score` … `retention_score` | 0–10 per stage |
| `weakest_stage` / `strongest_stage` | where to spend the next hour, and what already works |
| `business_class` | detected from the site: `local`, `professional_services`, `ecommerce`, `saas`, `content_creator`, `influencer` |
| `naics_code` / `naics_title` | the industry the site reads as |
| `assessment_detail` | every check: score, evidence, and recommendation |

The full row shape is published in the actor's dataset schema — see the **Storage** tab on any run.

#### The evidence, not just the number

Every check carries what it actually saw:

```json
{
  "label": "Booking / Demo / Consultation CTA",
  "stage": "decision",
  "score": 0,
  "max": 3,
  "evidence": "No booking, demo, or consultation CTA detected",
  "recommendation": "A prospect just decided they want to work with you, but there is no booking mechanism on your site. They will book with whoever makes it easiest.",
  "needs_review": true,
  "review_reason": "Crawl degraded — this hub-derived zero may be a false negative"
}
```

A score you cannot check is a score you cannot act on, so the evidence ships with it.

### Scored on what a website can show

Stage weights follow the business class. A local service business is scored heavily on awareness
and conversion; a SaaS on decision. The same site scores differently depending on what it is,
which is the point.

**This actor reads the website and nothing else.** No Google Business Profile, no Google Maps,
no Bing listing, no search-rank lookup.

That is a scope boundary, not a gap in the crawl, and the scoring respects it: the checks that
need those sources are **not in the rubric here at all**. They are not scored zero and quietly
averaged in — a business with a strong Google presence is not penalised for a lookup this actor
never makes. You are reading a website audit, scored out of what a website can tell you.

If you need Google Business Profile, review, and SERP scoring alongside this, that is a different
product — see [richardnorwood.com](https://richardnorwood.com).

### Honest about a bad crawl

A slow, blocked or single-page crawl produces weak readings, and the run says so rather than
reporting them as findings. `assessment_detail.audit.crawl_quality` carries the status and the
reason:

```json
{
  "status": "degraded",
  "reasons": ["Only the homepage was crawled — sub-page signals (forms, case studies, pricing) may be missing"],
  "pages_crawled": 1,
  "ttfb_ms": 1561
}
```

and every affected check is flagged `needs_review: true` with the reason attached. A zero that
means *"we could not see"* is never presented as a zero that means *"it is not there."*

### Input

Only `businessUrl` is required.

```json
{
  "businessUrl": "https://www.example.com",
  "brandName": "Example Co",
  "businessClass": "local"
}
```

| Field | Notes |
|---|---|
| `businessUrl` | **Required.** Must start with `http://` or `https://` |
| `brandName` | Optional. Defaults to the name detected on the site |
| `businessClass` | Optional override. Leave it out and the classifier decides |
| `proxy` | Defaults to Apify residential proxy, US |
| `maxConcurrency` | Default 5 |
| `maxRequestRetries` | Default 3 |

A run takes roughly one to three minutes depending on how many pages the site exposes.

### Getting the results

The run's **Output** tab links straight to the row. Via API:

```
https://api.apify.com/v2/datasets/<defaultDatasetId>/items
```

Or `?format=csv` for a flat export — `assessment_detail` is a nested object, so JSON is the
richer read.

# Actor input Schema

## `businessUrl` (type: `string`):

The homepage to assess. Everything else is optional.

## `brandName` (type: `string`):

Optional. Defaults to the name on the entity listing, falling back to the page title.

## `businessClass` (type: `string`):

Optional. Forces the rubric weighting instead of letting the classifier decide. Set this only when the classifier gets it wrong — it changes every stage score.

## `proxy` (type: `object`):

The website crawl runs on residential exits by default; the entity listings route to datacenter. Turn Apify Proxy off to run direct.

## `maxConcurrency` (type: `integer`):

Parallel requests. The site crawl is small — raising this mostly raises the odds of being rate-limited.

## `maxRequestRetries` (type: `integer`):

How many times a failed page fetch is retried before the URL is recorded as unreachable. Higher values cost run time; 0 means one attempt and no retry.

## Actor input object example

```json
{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 5,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `assessment` (type: `string`):

The scored row: five revenue-journey stage scores, the overall score, crawl quality, and the evidence behind each score. Exactly one item per run.

# 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("alabrida_dev/revenue-journey-assessment").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("alabrida_dev/revenue-journey-assessment").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 alabrida_dev/revenue-journey-assessment --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alabrida_dev/revenue-journey-assessment"
        }
    }
}

```

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/m7QW2vgktysEDPDXK/builds/YQ1dJa3u5OhjAFkCp/openapi.json