# Scrape Trust Score — Data Quality, Recency & Honeypot Risk (`apricot_blackberry/scrape-trust-score`) Actor

Don't let your agent act on poisoned data. Score any scraped dataset for recency, decoy/honeypot risk, and verification — every record gets a trust score with evidence. Chains onto ANY actor via datasetId, fields auto-detected, MCP-ready.

- **URL**: https://apify.com/apricot\_blackberry/scrape-trust-score.md
- **Developed by:** [Creator Fusion](https://apify.com/apricot_blackberry) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 record scoreds

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

## Scrape Trust Score — know what your data is worth *before* you act on it

**Your scraper doesn't lie. Your data does.** Every dataset you pull is a mix of the real, the stale, and the planted — dead records, bought reviews, disposable emails, and honeypot rows dropped in to poison anyone scraping. Feed that to a sales team and you waste a week. Feed it to an **AI agent that acts automatically**, and you've automated a bad decision at scale.

**Scrape Trust Score is the quality gate between "scraped" and "acted on."** Point it at any dataset and every record comes back with a **trust score and the evidence behind it** — so you keep the gold and quarantine the garbage.

> One field to wire it up: pass a `datasetId` from *any* actor's run. Fields are auto-detected. That's it.

### The two questions nobody else answers

#### 🕒 "When was this last real?" — Recency

Stale data is a silent killer — the lead moved, the business closed, the page is gone. Trust Score gives every record a **recency score + `lastSeen`**, built from record timestamps, source freshness signals, and a live liveness re-check. No timestamp exposed? We flag `freshnessConfidence: low` and say so — we never invent a date.

#### 🪤 "Was this planted to poison me?" — Decoy / honeypot risk

Sites seed fake rows to trap scrapers, and AI now floods the web with plausible fakes. Trust Score gives every record a **`decoyRisk` 0–100 with a list of evidence** — non-resolving domains, dead links, disposable/no-MX emails, fake phone ranges, placeholder text, duplicate-farm clusters. It's a **calibrated score, not a coin-flip verdict**: a legit-but-unusual record (say, an email-only domain with no website) lands *mid-risk with reasons*, not a false "fake!" — so you can trust the flags you do get.

### What you get

Every record is returned **unchanged, plus a `_trust` block**:

```json
{
  "...your original fields...": "...",
  "_trust": {
    "trustScore": 88,
    "recencyScore": 74, "lastSeen": "2026-08-30T...", "freshnessConfidence": "ok",
    "decoyRisk": 10, "corroborationChecked": true,
    "flags": ["role-email"],
    "evidence": ["source URL live (200): https://acme.com", "email domain has working MX: acme.com"]
  }
}
```

Plus a dataset-level **SUMMARY** in the key-value store: `junkRate`, `decoySuspectPct`, `lowFreshnessPct`, `medianTrust`, `medianRecency`, and a flag breakdown — the one number that tells you how much of this scrape you can trust.

### Chain it onto anything (zero config)

- **After any Apify actor:** run your scrape, then run Trust Score with that run's `datasetId`. Fields auto-detect — emails, URLs, phones, timestamps — no mapping.
- **In one Zap / Make / n8n flow:** Scraper → Trust Score → Google Sheets, and filter to `trustScore >= 70`.
- **For AI agents (MCP):** the agent scores its own scraped data and gates on `decoyRisk` before it acts — exposed via the Apify MCP server.

### Pricing that matches the value

Cheap enough to sprinkle on **every** scrape: a tiny per-record fee for the fast signals, and a `deep-verify` event that only fires when you turn on live MX + URL corroboration — so you pay for deep verification only on the rows that need it.

### 🔗 Works with

- **Upstream:** [Data Source Finder](https://apify.com/apricot_blackberry/data-source-finder) finds *where* the data lives; a scraper pulls it; then you point Trust Score at the result.
- **Pairs with** [Contact Email Finder](https://apify.com/apricot_blackberry/contact-email-finder) and [YouTube Email Finder](https://apify.com/apricot_blackberry/youtube-email-finder) — enrich a list, then verify it here before outreach.

### Honest about the method

Trust Score uses public, generic verification heuristics — MX and liveness checks, disposable-domain and fake-pattern detection, duplicate clustering, timestamp analysis. It scores **risk with evidence**; it does not claim to read intent or prove a row was maliciously planted. Use the flags and evidence to decide — that's the point.

# Actor input Schema

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

The default dataset ID of any previous scrape. Trust Score reads it, scores every record, and returns each row with a `_trust` block added. This is the one-field way to chain onto any actor.

## `items` (type: `array`):

Alternative to datasetId: pass records directly. Any shape — fields are auto-detected.

## `deepVerify` (type: `boolean`):

Turn on the live corroboration pass: MX-check email domains and HEAD-check source URLs. The strongest 'is this real' signal. Billed per record only when on.

## `maxItems` (type: `integer`):

Cap records scored per run.

## `fieldMap` (type: `object`):

Optional. Override auto-detection, e.g. {"email":\["contactEmail"],"timestamp":\["postedAt"]}. Leave empty to auto-detect.

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

Optional, used only for deep URL liveness checks if a direct request is blocked.

## Actor input object example

```json
{
  "deepVerify": false,
  "maxItems": 5000
}
```

# Actor output Schema

## `scored` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("apricot_blackberry/scrape-trust-score").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("apricot_blackberry/scrape-trust-score").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 apricot_blackberry/scrape-trust-score --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apricot_blackberry/scrape-trust-score"
        }
    }
}

```

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/eqXffERJrfkHOsX1Q/builds/hoS8z2KaqEEYCPebO/openapi.json