# SEO & Marketing Framing Analyzer — No-AI, Evidence-Backed (`equ1n0x/seo-marketing-framing-analyzer`) Actor Extract on-page SEO signals and classify marketing persuasion framing (urgency, scarcity, social proof, authority, benefit, risk-reversal) — deterministic, no LLM, every result backed by a verbatim evidence quote. Plus multimodal scraping and custom-lens classification. - **URL**: https://apify.com/equ1n0x/seo-marketing-framing-analyzer.md - **Developed by:** [Noah Davidson](https://apify.com/equ1n0x) (community) - **Categories:** SEO tools, Lead generation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $7.00 / 1,000 page processeds 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 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. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 ## SEO & Marketing Framing Analyzer — deterministic, no-AI, evidence-backed **In plain words:** every page on the internet is trying to move you — *hurry, last chance, everyone's switching, experts agree.* This tool reads pages and shows you exactly **how** they're doing it, quoting the very sentence each time. No AI and no guessing: if it can't point to the actual words on the page, it says nothing at all. Marketers use it to study copy at scale; anyone can use it to see the machinery plainly. The rest of this page is the same promise in engineering terms. Extract on-page **SEO signals**, capture pages **multimodally**, and classify the **marketing framing** of web copy — with an engine that uses **no LLM**. That means: no model sits in the loop to drift, sample, or hallucinate — so there are **no invented fields**, every classification is backed by a **verbatim evidence quote**, and there's **no per-result AI cost** — so it stays fast and cheap at scale. (Two runs of the same URL can differ when the *page* changes or a dynamic page renders differently — that's the input moving, never the engine guessing.) Three jobs in one Actor — read a page's search-engine signals and its persuasion moves, scrape pages cleanly, or tag pages against your own labels: | Mode | What you get | |------|--------------| | **SEO + marketing framing** (`seo`) | Title, meta description/keywords/robots, canonical, Open Graph & Twitter cards, full heading tree, word count, image alt-text coverage, internal/external link counts, keyword density — **plus** a classification of the copy's persuasion framing (urgency, scarcity, social proof, authority, benefit-led, risk-reversal), each with the exact quote that evidences it. | | **Multimodal scrape** (`scrape`) | Clean, readable page text. Turn on **Multimodal** to also render the page and transcribe on-screen text (useful for JavaScript-heavy pages or text baked into images). | | **Classify against your own lens** (`code`) | Bring your own set of labels + trigger phrases and classify any list of pages against them. General-purpose, deterministic tagging with evidence quotes. | ### Why this Actor - **No model, no mood** — there's no LLM in the loop, so nothing is sampled, invented, or drifting; results are driven only by what's actually on the page. The engine adds no variance of its own — what can change between two runs of the same URL is the live page itself (a content update, or a dynamic render), never the engine's judgment. - **No hallucinated data** — a field is only emitted when it's actually present on the page, and every marketing-framing label carries the verbatim sentence that triggered it. Nothing is invented. - **Internally corroborated** — a classification ships only after it is independently cross-checked inside the engine; a weak or conflicting signal is **discarded, not reported**. When results arrive, they've already survived their own audit. In plain words: it double-checks itself before it speaks, and throws away what it isn't sure of. - **Your data never meets an AI provider** — the engine is LLM-free, so page content is processed entirely in-container and never sent to any third-party model. Privacy by construction, not policy. - **No per-result AI cost** — LLM-free also means runs stay cheap and fast even across thousands of pages. That's what keeps pay-per-event pricing low. - **Provenance on every row** — each result carries a tamper-evident `provenance` tag; with a secret set, tags are HMAC-signed so *you* can prove to a client which rows came from your audit, unaltered. - **Bring a proprietary lens, keep it proprietary** — ship your own classification framework encrypted (AES-256-GCM); it decrypts only in memory at runtime. Your methodology never sits in the clear. In plain words: your method stays your secret — even from us. ### Input What you tell it: which pages to read, and which of the three jobs to do: ```jsonc { "mode": "seo", // "seo" | "scrape" | "code" "startUrls": [{ "url": "https://example.com" }], "multimodal": false, // render + transcribe on-screen text "lensName": "marketing_seo_v1", // built-in framing lens (seo/code modes) "maxItems": 50, "timeoutSecs": 30 } ```` For the `code` mode you can pass your **own** lens instead: ```jsonc { "mode": "code", "startUrls": [{ "url": "https://example.com/pricing" }], "lensJson": { "matching_modes": { "pricing_signals": { "free_tier": { "lexical_markers": ["free plan", "free tier", "no credit card"] }, "enterprise": { "lexical_markers": ["contact sales", "custom pricing", "enterprise"] } } } } } ``` ### Output What comes back: everything found on each page, with every claim carrying the exact words that earned it. **`seo` mode** — one item per page: ```jsonc { "url": "https://example.com", "title": "Example — Get Started Today", "title_length": 30, "meta_description": "Try it free, cancel anytime.", "canonical": "https://example.com/", "og": { "title": "Example", "description": "...", "image": "https://.../og.png", "type": "website" }, "twitter": { "card": "summary_large_image", "title": "Example" }, "h1_count": 1, "word_count": 812, "images_total": 14, "images_with_alt": 11, "images_alt_coverage": 0.786, "links_internal": 42, "links_external": 9, "top_keywords": [{ "term": "pricing", "count": 12 }, { "term": "free", "count": 8 }], "marketing_framing": [ { "dimension": "persuasion_framing", "label": "risk_reversal", "evidence_quote": "Try it free, cancel anytime.", "review_needed": false }, { "dimension": "persuasion_framing", "label": "urgency", "evidence_quote": "Get started today.", "review_needed": false } ], "marketing_framing_counts": { "risk_reversal": 1, "urgency": 1 }, "provenance": "dove0:9f2c…" } ``` **`code` mode** — one item per classification, each with its evidence: ```jsonc { "dimension": "pricing_signals", "label": "free_tier", "evidence_quote": "Start on the free plan, no credit card required.", "source_url": "https://example.com/pricing", "source_title": "Pricing", "review_needed": false, "provenance": "dove0:1a7b…" } ``` ### Great for - **SEO audits** at scale — meta/heading/canonical/OG hygiene across a whole site or competitor set. - **Marketing & competitive intel** — see *how* competitors persuade (urgency vs. social proof vs. authority), backed by the exact copy. - **Content & CRO teams** — quantify persuasion framing on landing pages, reproducibly. - **Custom tagging pipelines** — the `code` mode is a deterministic, evidence-backed classifier for any label set you define. ### Deterministic vs. an AI analyzer — a structural difference, not a slogan Most tools that classify web copy at scale run on an LLM. That buys fluency — and it gives up three guarantees you can't get back, not because any vendor is careless, but because a probabilistic model *structurally* can't make them: - **Reproducibility.** Ask a model the same thing twice and the answer can drift. Ask this engine, and the same page yields the same result — no sampling, no temperature, nothing to drift. - **Evidence.** A model can return a confident label with nothing on the page behind it, and can't *prove* it didn't. Here, every label carries the verbatim sentence that triggered it, or it isn't emitted — a guess has no path onto your bill. - **Privacy.** A model has to send your content off to judge it. This engine is LLM-free, so your pages never leave the container and never reach any AI provider. None of that calls an AI tool dishonest. It's the difference between what a probabilistic method can *offer* and what a deterministic one can *guarantee* — and we'd rather you check it than take our word. Run the same audit twice and diff the output. Trace any label to its quoted sentence. Watch the network and see nothing leave. The difference isn't a claim you have to trust; it's one you can verify from where you sit. ### Pricing You pay only for what verifiably happened, and the bill is one number you can work out before you run: a small fixed **run fee** plus a flat **per-page** price. Two meters: | Meter | When it fires | Price | |-------|---------------|-------| | **run-started** | Once per run — boot, integrity self-check, browser spin-up (the fixed startup cost, priced as itself) | $3.00 / 1,000 | | **page-processed** | Once per page fetched and fully analyzed — SEO signals *and* its marketing-framing classifications, each with a verbatim evidence quote | $7.00 / 1,000 | That's the whole meter — no per-result charge you can't predict. Your total is `run-started + (pages × page-processed)`, so a page costs the same whether it yields six framing labels or none. The **$7.00 / 1,000** figure Apify shows in the header is your per-page price — the real driver of the bill — on top of a one-time **$3.00 / 1,000** run fee that rounds to nothing on any real run. Because the engine is LLM-free, that per-page price buys a full scrape, SEO audit, and evidence-backed framing analysis for well under a cent. #### What a real run costs Concrete, and knowable before you press run: - **Quick 3-page check** — 1 run + 3 pages ≈ **$0.02** - **100-page SEO audit** — 1 run + 100 pages ≈ **$0.70** - **1,000-page audit** — 1 run + 1,000 pages ≈ **$7.00** A page the engine abstains on — nothing it can quote — costs exactly the same as any other: you're paying for the read, not for findings, so a guess can never appear on your bill and ambiguous copy never inflates it. #### How this price was derived Priced by derivation, not by market — no reference to anyone else's prices. The formula: **measured cost ÷ platform share + a stated stewardship wage.** From a real measured run (2026-07-22): 2 pages + 4 classifications cost $0.0078 total — a marginal page cost of roughly $0.002–0.003. After the platform's ~20% share, cost-recovery is about $0.003 a page; the rest of the $0.007 is an openly-stated stewardship wage for building and keeping an engine that reads meaning without guessing. Classifications aren't metered separately — they cost ~nothing to emit, so the work, and the price, is the page. The launch is priced once as itself, so a 3-page check and a 3,000-page audit each pay the true shape of their own cost — no cross-subsidy. And one thing you are *never* charged for: a guess — the engine abstains on ambiguous copy rather than inventing a classification to bill you for. When the meters change, the price is re-derived and this section updated. ### The honesty contract (what it will and won't do) **What you can rely on:** every classification is evidence-quoted, internally corroborated, and free of model drift — no LLM sits in the loop to hallucinate or change its mind between runs, so the analysis is driven entirely by the page in front of it. When a page hasn't changed, a re-run reproduces it; when it has, what you see is the page's change, never the engine's mood. On ambiguous phrasing it **abstains rather than guesses** — so when it *does* speak, the label has already survived cross-examination. Precision over recall is a capability, not an apology: it is the one guarantee AI-based analyzers structurally cannot make. **The true limits, stated plainly:** - It classifies by what is actually on the page. Framing that lives purely in tone, imagery, or implication — with no words to quote — is reported as nothing, on purpose. It stays silent rather than guess. - `multimodal` mode renders each page (slower); reserve it for JavaScript-heavy pages or text baked into images — where it will read what non-rendering scrapers can't see at all. - Respect each target site's terms of service and robots policy when scraping. ### Servicing of terms We flipped the label on purpose: not terms that govern the service — a service that keeps its terms. Here they are, short enough to actually read: **your data stays yours** (processed in-container, never retained after the run, never sold, never trained on, never shown to any AI provider); **no rights are claimed** over your inputs or outputs beyond mechanically running the job you asked for; **you pay only for receipted events — never for a guess**; **you can leave anytime with nothing held**. We ask one term back: don't point this tool at taking — respect the grounds you aim it at. ### Support Questions or a custom lens for your use case? Open an issue on the Actor's Issues tab. # Actor input Schema ## `mode` (type: `string`): SEO + marketing framing = on-page SEO signals plus persuasion-framing classification. Multimodal scrape = clean text (+ optional on-screen text transcription). Classify against a lens = tag pages against your own labels. ## `startUrls` (type: `array`): The URLs to process. Paste a list, upload a file, or link another Actor's output. ## `urls` (type: `array`): Alternative to the field above: a plain list of URL strings. ## `multimodal` (type: `boolean`): Renders each page and reads text from the rendered view — useful for JavaScript-heavy pages or text baked into images. Slower; leave off for standard HTML pages. ## `lensName` (type: `string`): Which built-in lens to classify against (SEO and Classify modes). ## `lensJson` (type: `object`): Bring your own labels: { "matching\_modes": { "": { "