# Token Due Diligence – Crypto Rug & Risk Report (`logiover/token-due-diligence-report`) Actor

One-click crypto due diligence. Paste a token contract address and get a full DD report: rug/honeypot risk score, buy/sell tax, mintable & ownership checks, liquidity, 24h volume, FDV, holder concentration and LP lock — no API key, no 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, NaN 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## 🛡️ Token Due Diligence – Crypto Rug & Honeypot Checker

**Paste a token contract address → get a full due-diligence report in seconds.**
No API key, no wallet, no login. One click, one decision-ready report with a clear risk score and verdict.

This Actor is an all-in-one **crypto due diligence**, **rug pull checker**, **honeypot checker**, and **token safety / contract risk scanner**. It merges live **market health** with **smart-contract security** signals into one report and grades it with a transparent **0–100 risk score** and a plain verdict: **LOW / MEDIUM / HIGH / CRITICAL risk**. Built for traders, snipers, degens, analysts, and anyone who wants to **check a token before they buy**.

> Looking for a **honeypot checker**, **rug pull detector**, **token scam checker**, **buy/sell tax checker**, **liquidity checker**, or **bulk token screener** across Ethereum, BSC, Base, Solana and more? Paste the addresses and export clean JSON / CSV / Excel.

---

### ✅ What each report includes

**Verdict & score**
- `verdict` — LOW / MEDIUM / HIGH / CRITICAL risk
- `riskScore` — transparent 0–100 (higher = safer)
- `riskFlags` — the exact red flags that fired (no black box)

**Market (live)**
- Price, **liquidity (USD)**, **24h volume**, **FDV**, market cap
- 24h price change, buy/sell counts, DEX, **pair age**, chart link

**Security / rug signals**
- **Honeypot** (can you actually sell?), **cannot-sell-all**, pausable transfers, trading cooldown
- **Buy / sell tax**
- **Mintable** supply, **ownership renounced?**, **open-source / verified?**, hidden owner, self-destruct, take-back-ownership
- **Holder count** + **top-holder concentration**
- **LP locked / burned**

---

### 🎯 Best for

- **Pre-buy safety checks** — dodge honeypots and high-tax traps before you ape in
- **Memecoin snipers** — screen new launches fast, filter the obvious rugs
- **Bulk watchlist screening** — vet a whole token list or alpha-group feed at once
- **Trading bots & dashboards** — pull a risk score via the API into your pipeline
- **Analysts & funds** — standardized, repeatable DD across chains
- **Alpha / signal groups** — auto-generate token risk cards for your community
- **Portfolio risk reviews** — re-check tokens you already hold

---

### ⚡ Why this one

- **Zero friction** — no API key, no wallet connect, no login. Paste address → report.
- **Two-source truth** — combines **live market data** with **contract-security signals**, not just one side.
- **Transparent scoring** — every penalty appears as a named flag, so you see *exactly why*.
- **Multi-chain, auto-detected** — Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche, Fantom, zkSync, Linea, Scroll, Solana and more.
- **Smart chain handling** — avoids fork-address mix-ups (e.g. PulseChain copies) so you get the right token.
- **Bulk + API** — screen many tokens per run; export CSV/Excel/JSON or call via the Apify API.

---

### 🛠 How to use

1. Paste one or more **token contract addresses**.
2. (Optional) Set **Chain** if the same address exists on multiple chains — otherwise it auto-detects.
3. Run and read the **verdict + risk flags**, or export the dataset.

#### Example input
```json
{ "tokens": ["0x6982508145454ce325ddbe47a25d4ec3d2311933"] }
````

***

### 📤 Output

```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
}
```

***

### 🧠 How the risk score works

It starts at **100** and subtracts points for each red flag found:

| 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 |

Every deduction is listed in `riskFlags` — the score is fully explainable, never a black box.

***

### 🆚 How it compares

**vs. single-purpose honeypot checkers** — those only check sell-ability. This adds taxes, mint/owner risks, holder concentration, liquidity, age and LP status, then scores it all in one verdict.

**vs. block explorers** — explorers show raw data; this interprets it into a buy/avoid decision and runs in bulk via API.

**vs. paid DD dashboards** — same core signals, on pay-per-result Apify pricing, with CSV/Excel/JSON export and no subscription.

***

### ❓ FAQ

**Which chains are supported?**
Ethereum, BSC, Base, Polygon, Arbitrum, Optimism, Avalanche, Fantom, zkSync, Linea, Scroll and more EVM chains, plus Solana. Auto-detected from the contract; you can also force it.

**How is the risk score calculated?**
Start at 100, subtract for each red flag — all listed in `riskFlags`. Fully explainable.

**Does it need a key or wallet?**
No — completely key-free and read-only. Nothing is ever transacted.

**Can I bulk-check tokens?**
Yes — paste many addresses; each produces its own report. Great for watchlists and bot pipelines via the API.

**Is this financial advice?**
No. It's an automated risk-signal report from public on-chain + market data. Always DYOR.

***

### 💰 Pricing

Pay-per-result: you're charged **per token report**. No subscription. Failed/empty lookups aren't charged.

***

#### Keywords

crypto due diligence, token rug checker, rug pull detector, honeypot checker, token scam checker, token safety check, contract risk scanner, token audit tool, check token before buying, is this token a scam, buy tax checker, sell tax checker, liquidity checker, holder concentration checker, can i sell this token, ethereum token checker, bsc token checker, base token checker, solana token checker, memecoin safety check, token risk score, bulk token screener, defi token analysis, smart contract risk.

# Actor input Schema

## `tokens` (type: `array`):

Paste one or more token contract addresses (Ethereum, BSC, Base, Polygon, Arbitrum, Solana, …). The chain is auto-detected.

## `chain` (type: `string`):

Force a specific chain if the same address exists on multiple chains. Leave blank to auto-detect.

## `maxResults` (type: `integer`):

Stop after this many reports (0 = no limit).

## Actor input object example

```json
{
  "tokens": [
    "0x6982508145454ce325ddbe47a25d4ec3d2311933"
  ],
  "chain": "",
  "maxResults": 0
}
```

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# 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 <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Token Due Diligence – Crypto Rug & Risk Report",
        "description": "One-click crypto due diligence. Paste a token contract address and get a full DD report: rug/honeypot risk score, buy/sell tax, mintable & ownership checks, liquidity, 24h volume, FDV, holder concentration and LP lock — no API key, no wallet. Ethereum, BSC, Base, Solana & more.",
        "version": "1.0",
        "x-build-id": "rnFCBPV7eCs5ijb6s"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~token-due-diligence-report/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-token-due-diligence-report",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/logiover~token-due-diligence-report/runs": {
            "post": {
                "operationId": "runs-sync-logiover-token-due-diligence-report",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/logiover~token-due-diligence-report/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-token-due-diligence-report",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "tokens"
                ],
                "properties": {
                    "tokens": {
                        "title": "Token contract addresses",
                        "type": "array",
                        "description": "Paste one or more token contract addresses (Ethereum, BSC, Base, Polygon, Arbitrum, Solana, …). The chain is auto-detected.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "chain": {
                        "title": "Chain (optional)",
                        "enum": [
                            "",
                            "ethereum",
                            "bsc",
                            "base",
                            "polygon",
                            "arbitrum",
                            "optimism",
                            "avalanche",
                            "solana"
                        ],
                        "type": "string",
                        "description": "Force a specific chain if the same address exists on multiple chains. Leave blank to auto-detect.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many reports (0 = no limit).",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```