# Token Due Diligence Report – Crypto Rug & Risk Scan (`logiover/token-due-diligence-report`) Actor
Token rug pull checker & honeypot scanner. Bulk scan contract addresses, export risk data to CSV/JSON. No API key or wallet, Ethereum, BSC, Base, Solana & more.
- **URL**: https://apify.com/logiover/token-due-diligence-report.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
$0.02 / token data scraped
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.
- **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
## Token Due Diligence Report — Crypto Rug Pull & Honeypot Risk Scanner (No API Key)
    
Paste a token contract address and get a full **crypto due diligence** report in seconds. **Token Due Diligence Report** is an all-in-one **rug pull checker**, **honeypot checker** and **token risk / contract safety scanner** that merges live DEX market health with smart-contract security signals into one decision-ready row: **verdict, 0–100 risk score, honeypot flag, buy/sell tax, mintable & ownership checks, liquidity, 24h volume, FDV, holder concentration and LP lock**. Works across Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche, Solana and more. **No API key, no wallet, no login, read-only.**
> ### 🏆 Why this token risk scanner?
>
> **40+ signals per token** · **bulk-screen a whole watchlist per run** · direct on-chain + DEX data (no wallet, no signing) · transparent 0–100 score with named red flags · export to JSON / CSV / Excel. The unofficial **on-chain due-diligence API alternative** that fuses DEX market data with contract-security checks for pre-buy safety and memecoin sniping.
***
### ✨ What this Actor does / Key features
- 🚦 **One verdict, zero black box** — every token gets a `verdict` (LOW / MEDIUM / HIGH / CRITICAL) and a transparent `riskScore` from 0–100, with each deduction listed as a named flag in `riskFlags`.
- 🍯 **Honeypot detection** — the `honeypot` flag answers the only question that matters — *can you actually sell?* — plus cannot-sell-all, pausable transfers and trading-cooldown checks.
- 💸 **Tax & fee checks** — `buyTaxPct` and `sellTaxPct` expose hidden fees that quietly eat your position.
- 🔐 **Contract-security signals** — `mintable` supply, `ownerRenounced`, open-source / verified, hidden owner, self-destruct and take-back-ownership backdoors.
- 📊 **Live market health** — `priceUsd`, `liquidityUsd`, `volume24hUsd`, `fdvUsd`, market cap, 24h price change, buy/sell counts, DEX name, pair age and a chart link.
- 👛 **Holder concentration** — `holderCount` and `topHolderPct` reveal whether one wallet can crash the price.
- 🔒 **LP lock / burn** — see whether liquidity can be pulled from under you.
- 🌐 **Multi-chain, auto-detected** — major EVM chains plus Solana, with smart handling of fork-address mix-ups (e.g. PulseChain copies of Ethereum addresses).
- 📥 **Bulk + API** — paste many addresses and screen them all in one run; export CSV / JSON / Excel or call it via the Apify API.
- ⚡ **Zero friction** — no API key, no wallet connect, no login. Paste address → report.
### 🚀 Quick start (3 steps)
1. **Configure** — paste one or more **token contract addresses** into `tokens`. Optionally set `chain` (only if the same address exists on multiple chains) and `maxResults` to cap a large run.
2. **Run** — click **Start**. The Actor resolves each token, pulls DEX market data and contract-security signals, then scores it.
3. **Get your data** — open the **Output** tab, read the verdict and red flags, and export to **JSON, CSV, Excel, XML or JSONL** — or pull it via the Apify API.
### 📥 Input
Give the Actor at least one contract address in `tokens`. Everything else is optional — the chain auto-detects.
#### Example — single-token pre-buy safety check
```json
{
"tokens": ["0x6982508145454ce325ddbe47a25d4ec3d2311933"]
}
```
#### Example — bulk watchlist screening across chains
```json
{
"tokens": [
"0x6982508145454ce325ddbe47a25d4ec3d2311933",
"0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE",
"0x912CE59144191C1204E64559FE8253a0e49E6548"
],
"maxResults": 100
}
```
#### Example — force a chain to disambiguate a fork address
```json
{
"tokens": ["0x6982508145454ce325ddbe47a25d4ec3d2311933"],
"chain": "ethereum"
}
```
| Field | Type | Description |
|-------|------|-------------|
| `tokens` | array | One or more token contract addresses (Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche, Solana, …). Each address produces its own report. **Required.** |
| `chain` | string | Force a specific chain when the same address exists on multiple chains: `ethereum`, `bsc`, `base`, `polygon`, `arbitrum`, `optimism`, `avalanche` or `solana`. Leave blank to auto-detect. |
| `maxResults` | integer | Stop after this many reports. `0` = no limit. |
> **Tip:** leave `chain` blank for normal use — the Actor auto-detects it from the contract. Only set it to resolve fork-address mix-ups (for example when a PulseChain copy shares an Ethereum address) so the report grades the token on the chain you actually intend to trade.
### 📤 Output
One row per token — a full due-diligence report fusing verdict, market and security signals, exportable to JSON, CSV, Excel, XML or JSONL. Here is a trimmed sample record:
```json
{
"symbol": "PEPE",
"chain": "ethereum",
"verdict": "LOW RISK",
"riskScore": 100,
"riskFlags": [],
"priceUsd": 0.000003342,
"liquidityUsd": 23446182,
"volume24hUsd": 277661,
"fdvUsd": 1383034713,
"honeypot": false,
"buyTaxPct": 0,
"sellTaxPct": 0,
"mintable": false,
"ownerRenounced": true,
"holderCount": 558134,
"topHolderPct": 13.34
}
```
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `symbol` | Token ticker symbol |
| `chain` | Detected (or forced) chain, e.g. `ethereum`, `bsc`, `solana` |
| `verdict` | Plain-English verdict: LOW / MEDIUM / HIGH / CRITICAL risk |
| `riskScore` | Transparent 0–100 score (higher = safer) |
| `riskFlags` | Array of the exact red flags that fired — every score deduction, named |
| `priceUsd` | Current token price in USD |
| `liquidityUsd` | Pool liquidity in USD |
| `volume24hUsd` | 24-hour trading volume in USD |
| `fdvUsd` | Fully diluted valuation (and market cap) in USD |
| 24h price change / buy & sell counts | Recent price movement and trade activity |
| DEX / pair age / chart link | Which DEX, how old the pair is, and a link to the chart |
| `honeypot` | Whether the token can actually be sold (honeypot detection) |
| cannot-sell-all / pausable / trading-cooldown | Additional sell-restriction signals |
| `buyTaxPct` / `sellTaxPct` | Buy and sell tax percentages |
| `mintable` | Whether supply can be minted (dump risk) |
| `ownerRenounced` | Whether contract ownership is renounced |
| open-source / verified | Whether the contract source is public/verified |
| hidden owner / self-destruct / take-back-ownership | Backdoor and centralized-control signals |
| `holderCount` | Number of holders |
| `topHolderPct` | Percentage held by the top wallet(s) — concentration risk |
| LP locked / burned | Whether liquidity is locked or burned |
#### How the risk score works
The score starts at 100 and subtracts points for each red flag found — and every deduction is listed in `riskFlags`, so the verdict is fully explainable and never a black box:
| Signal | Why it matters |
|---|---|
| Honeypot / cannot-sell | You can buy but never sell — total loss |
| High buy/sell tax | Hidden fees that eat your position |
| Mintable supply | Team can print tokens and dump |
| Owner not renounced / take-back ownership | Centralized control / backdoors |
| Not open-source | Unauditable contract |
| Top-holder concentration | One wallet can crash the price |
| Low liquidity / brand-new pair | Easy to rug, hard to exit |
| LP not locked/burned | Liquidity can be pulled |
### 💡 Use cases
- **Pre-buy safety checks** — dodge honeypots and high-tax traps before you ape in.
- **Memecoin sniping** — screen new launches fast and filter the obvious rugs.
- **Bulk watchlist screening** — vet a whole token list or alpha-group feed in one run.
- **Trading bots & dashboards** — pull a risk score via the Apify API straight into your pipeline.
- **Analysts & funds** — standardized, repeatable due diligence across chains.
- **Alpha / signal groups** — auto-generate token risk cards for your community.
- **Portfolio risk reviews** — re-check tokens you already hold and catch a contract that turned malicious.
### 👥 Who uses it
Retail traders & memecoin snipers · crypto trading-bot builders · alpha & signal-group admins · on-chain analysts & research desks · DeFi funds & treasuries · portfolio-risk teams · Telegram/Discord community managers.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay per token report, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up to bulk watchlist runs. See the **Pricing** tab on this page for the current rate.
### ❓ Frequently Asked Questions
**Is it legal to run token due diligence with this Actor?**
Yes. The Actor reads only publicly available on-chain and DEX market data — nothing is transacted, signed or private. You are responsible for how you use the resulting risk signals, and it is not financial advice.
**Does this rely on a public API — is it an API alternative?**
It is an aggregation layer over public on-chain and DEX market data sources, giving you a single decision-ready report instead of stitching together several dashboards and block explorers by hand. You get standardized rug/honeypot risk data without managing any provider API keys yourself.
**Do I need an API key, wallet or login?**
No. It is completely key-free, wallet-free and read-only — nothing is ever transacted or signed, so there is zero ban or drain risk. You only need an Apify account.
**Which chains are supported?**
Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche, Fantom, zkSync, Linea, Scroll and more EVM chains, plus Solana. The chain is auto-detected from the contract, and you can also force it with `chain`.
**How is the risk score calculated?**
It starts at 100 and subtracts points for each red flag — honeypots, taxes, mint/owner risks, holder concentration, liquidity, pair age and LP status. Each penalty is named in `riskFlags`, so the verdict is fully explainable.
**Can I bulk-check a whole token list for rug pulls?**
Yes. Paste many contract addresses in one run and each token gets its own honeypot and rug-pull check with a 0–100 score and named red flags — ideal for watchlist screening and bot pipelines via the API.
**How much data can I get?**
You can screen a large watchlist in a single run — each address becomes its own report row. Use `maxResults` to cap very large lists, and split enormous lists across multiple runs.
**How do I export token risk data to CSV or JSON?**
Every token report is a dataset row, so you can export the full risk data to CSV, JSON, Excel, XML or JSONL straight from the run page or via the Apify API.
#### How do I check if a token is a honeypot before buying?
Paste the contract address and the report returns a `honeypot` flag plus `buyTaxPct` and `sellTaxPct`, so you know whether you can actually sell — and at what cost — before you ape in.
#### How do I bulk-scan a whole token watchlist for rug pulls?
Add many contract addresses at once and each token gets its own 0–100 risk score and named red flags in `riskFlags`, ideal for screening an alpha-group feed in one run.
#### Does the token risk scanner work on Solana and Base?
Yes. It auto-detects the chain and covers Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche and Solana, so you can vet tokens across networks.
#### Is this financial advice?
No. It is an automated risk-signal report built from public on-chain and market data. Always do your own research (DYOR) before buying, holding or selling.
### 🔗 More crypto & Web3 scrapers by logiover
Building a full on-chain intelligence stack? Pair this due-diligence scanner with the rest of the crypto suite:
| Actor | What it does |
|---|---|
| [DexScreener Pair Security Scraper](https://apify.com/logiover/dexscreener-pair-security-scraper) | Per-pair security & audit signals |
| [DexScreener Boosted Tokens Scraper](https://apify.com/logiover/dexscreener-boosted-tokens-scraper) | Trending / boosted token discovery |
| [DexScreener Search Pairs Scraper](https://apify.com/logiover/dexscreener-search-pairs-scraper) | Search DEX pairs by query |
| [DexScreener Token Pairs Scraper](https://apify.com/logiover/dexscreener-token-pairs-scraper) | All pairs for a given token |
| [GMGN Token Rugcheck Analytics](https://apify.com/logiover/gmgn-token-rugcheck-analytics) | GMGN-sourced rug & safety analytics |
| [GMGN New Token Launch Detector](https://apify.com/logiover/gmgn-new-token-launch-detector) | Catch brand-new token launches |
| [GMGN Smart Money Buy Signals](https://apify.com/logiover/gmgn-smart-money-buy-signals) | Smart-money buy signals |
| [GMGN Token Holders Intelligence](https://apify.com/logiover/gmgn-token-holders-intelligence) | Holder distribution & concentration |
| [GMGN Trending Memecoin Scanner](https://apify.com/logiover/gmgn-trending-memecoin-scanner) | Trending memecoin scanner |
| [CoinGecko Coins Market Scraper](https://apify.com/logiover/coingecko-coins-market-scraper) | Market data for thousands of coins |
| [Binance Spot Market Scraper](https://apify.com/logiover/binance-spot-market-scraper) | Binance spot market snapshots |
| [Polymarket Events & Odds AI Scraper](https://apify.com/logiover/polymarket-events-odds-ai-scraper) | Prediction-market events & odds |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to re-screen your watchlist every hour or every day and catch a token that turns malicious. Export results to JSON, CSV or Excel, sync to Google Sheets, or push risk scores to your trading bot, dashboard, database and webhooks through the Apify API. Connect it to **Make, n8n or Zapier** to fire an alert the moment a held token's verdict drops to HIGH or CRITICAL.
### ⭐ Support & feedback
Found a bug or need an extra signal or chain? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves your bag, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor reads only publicly available on-chain and DEX market data and is intended for legitimate research and risk-screening use. You are responsible for complying with applicable laws and the terms of the underlying data sources. **This is not financial advice** — it is an automated risk-signal report. Always do your own research (DYOR) before making any trading decision.
***
### 📝 Changelog
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Fixed the run Output link from `{{links.apiDefaultDatasetUrl}}` to `{{links.apiDefaultDatasetUrl}}/items` so the results table opens the dataset items endpoint.
#### 2026-08-01 — Health-check remediation
- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Fixed the run Output link from `{{links.apiDefaultDatasetUrl}}` to `{{links.apiDefaultDatasetUrl}}/items` so the results table opens the dataset items endpoint.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.
#### 2026-07-06
- ✨ README overhaul: richer output sample with a full field reference, ready-to-run example scenarios, crypto-suite cross-promo links, and a clearer 3-step quick-start.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
#### 2026-06-15
- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.
#### 2026-06-07
- Docs: added coverage for token risk data CSV/JSON export, no-API-key/no-login scraping, and bulk honeypot list checks.
***
*Reads public on-chain and market data only. Not financial advice.*
# Actor input Schema
## `tokens` (type: `array`):
Paste one or more token contract addresses (Ethereum, BSC, Base, Polygon, Arbitrum, Solana, …). The chain is auto-detected. Leave EMPTY to run a due-diligence report on a set of popular default tokens.
## `chain` (type: `string`):
Force a specific chain if the same address exists on multiple chains. Leave on Auto-detect for most cases.
## `maxResults` (type: `integer`):
Stop after this many reports. Caps the run so it stays fast & cheap (0 = no limit).
## Actor input object example
```json
{
"tokens": [
"0x6982508145454ce325ddbe47a25d4ec3d2311933"
],
"chain": "",
"maxResults": 100
}
```
# Actor output Schema
## `results` (type: `string`):
Dataset of token due-diligence reports: verdict, risk score, market & security signals.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"tokens": [
"0x6982508145454ce325ddbe47a25d4ec3d2311933"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/token-due-diligence-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "tokens": ["0x6982508145454ce325ddbe47a25d4ec3d2311933"] }
# Run the Actor and wait for it to finish
run = client.actor("logiover/token-due-diligence-report").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"tokens": [
"0x6982508145454ce325ddbe47a25d4ec3d2311933"
]
}' |
apify call logiover/token-due-diligence-report --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/token-due-diligence-report",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/actors/ebDzUPyMLaVqNkBIm/builds/4Xry9ctcxET9eeZtB/openapi.json