# Crypto Token Rug Check — Honeypot & Security Scanner (`agent_services/crypto-rug-check`) Actor

Instant rug-pull risk scan for any token across 8 chains (Base, Ethereum, BSC, Solana & more). Honeypot simulation, ownership/mint checks, taxes, LP lock, holder concentration — one SAFE/WARN/DANGER verdict with a 0-100 risk score. Free data sources, no API keys needed.

- **URL**: https://apify.com/agent\_services/crypto-rug-check.md
- **Developed by:** [Riley Craig](https://apify.com/agent_services) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Crypto Token Rug Check — Honeypot & Security Scanner

Pre-trade safety scan for any token, on 8 chains, in one call. Paste a contract address, get back a **SAFE / WARN / DANGER verdict**, a **0–100 risk score**, and the itemized security checks that produced it — honeypot status, buy/sell tax, mintability, ownership, blacklist, holder concentration, LP lock, and live DEX liquidity.

Built for the call every trading bot, sniper, and listing reviewer should make **before** touching a token.

### Supported chains

Ethereum, Base, BNB Smart Chain, Polygon, Arbitrum, Optimism, Avalanche, **and Solana** (SPL-specific checks: mint/freeze/close authority, balance-mutable, transfer hooks/fees).

### What it checks

| Check | Source |
|---|---|
| Honeypot / cannot-buy / cannot-sell-all | GoPlus Security (+ Honeypot.is buy/sell **simulation** on deep scan) |
| Buy tax & sell tax (flagged at ≥10%, DANGER at extreme levels) | GoPlus + Honeypot.is simulation |
| Mintable / owner-can-reclaim / hidden owner / selfdestruct | GoPlus Security |
| Transfer pausable, blacklist, closed-source contract | GoPlus Security |
| Ownership renounced | GoPlus Security |
| Top-5 holder concentration (% of supply, tagged wallets) | GoPlus Security |
| LP lock/burn percentage | GoPlus Security |
| Live liquidity (top pair + total across all pairs), price, 24h volume/txns | DEXScreener |
| Solana: mint/freeze/close authority, balance-mutable, metadata-mutable, transfer fee | GoPlus Solana |

Every upstream failure is handled gracefully — you always get a result item, with an `upstreams` field telling you exactly which sources answered.

### Input

```json
{
  "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "chain": "base",
  "deepScan": true
}
````

- **tokenAddress** (required) — 0x… contract address on EVM chains, base58 mint on Solana.
- **chain** — `ethereum` | `base` | `bsc` | `polygon` | `arbitrum` | `optimism` | `avalanche` | `solana`. Default `base`.
- **deepScan** — adds a Honeypot.is buy/sell simulation cross-check (Ethereum, BSC, Base), the full list of DEX pairs with per-pair liquidity, and project social links.

### Output (real example — USDC on Base)

```json
{
  "address": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
  "chain": "8453",
  "token": { "name": "USD Coin", "symbol": "USDC" },
  "verdict": "SAFE",
  "risk_score": 0,
  "risk_reasons": [],
  "flags": [],
  "checks": {
    "is_honeypot": false, "cannot_buy": false, "cannot_sell_all": false,
    "buy_tax": 0, "sell_tax": 0, "is_open_source": true, "is_mintable": false,
    "ownership_renounced": false, "owner_can_reclaim": false,
    "transfer_pausable": false, "has_blacklist": false,
    "hidden_owner": false, "selfdestruct": false, "is_proxy": true,
    "holder_count": 9636468
  },
  "holder_concentration": { "available": true, "top5_holder_pct": 16.1, "risk": "DISTRIBUTED", "top_holders": ["..."] },
  "liquidity_lock": { "available": false },
  "market": {
    "available": true, "pair": "USDC/USDbC", "dex": "uniswap",
    "price_usd": 0.9999, "liquidity_usd": 907384.83,
    "total_liquidity_usd": 1470746.46, "pair_count": 21, "volume_24h": 208.07
  },
  "honeypot_simulation": { "available": true, "is_honeypot": false, "buy_tax_pct": 0, "sell_tax_pct": 0, "risk_level": "low" },
  "upstreams": { "goplus": "ok", "dexscreener": "ok", "honeypot_is": "ok" },
  "scanned_at": "2026-07-21T23:35:00.000Z"
}
```

And a rug in the wild (SafeMoon V1, BSC — deep scan):

```json
{
  "token": { "name": "SafeMoon", "symbol": "SAFEMOON" },
  "verdict": "DANGER",
  "risk_score": 100,
  "risk_reasons": ["OWNER_CAN_RECLAIM", "HIGH_BUY_TAX", "TOP5_HOLDERS_OVER_50PCT", "LP_MAJORITY_UNLOCKED", "EXTREME_TAX_IN_SIMULATION", "THIN_LIQUIDITY_UNDER_50K"],
  "honeypot_simulation": { "buy_tax_pct": 99.99 }
}
```

#### Verdict logic

- **DANGER** — honeypot / cannot-buy, failed buy/sell simulation, extreme (≥50%) simulated tax, or 3+ security flags / ≥15% sell tax.
- **WARN** — at least one security flag, heavy holder concentration, majority-unlocked LP, or clean security but thin (<$50k) liquidity (slippage/exit risk).
- **SAFE** — clean security audit and meaningful liquidity.
- **UNKNOWN** — no data from any source (usually a too-new or fake address).

The `risk_score` (0–100) is a weighted sum of every triggered issue, so you can set your own threshold instead of trusting the verdict.

### Use cases

- **Trading / sniping bots** — call via the Apify API before every buy; gate entries on `verdict !== "DANGER"` or `risk_score < 25`.
- **New-listing due diligence** — screen tokens before listing them on a DEX aggregator, launchpad, or community.
- **Portfolio monitoring** — schedule daily scans of held tokens; alert if a token's verdict degrades (owner un-renounces, LP unlocks, tax changes).
- **Research / datasets** — bulk-score trending tokens by chaining this with a DEXScreener trending scraper.

### Why this one (vs. other scanners on Apify)

- **Solana Token Trust Scanner** — Solana only. This Actor covers Solana **plus 7 EVM chains** at the same price point.
- **Base Token Risk Scanner** — Base only, on-chain reads without a security-audit source.
- **Token Honeypot Detector** — honeypot-focused; no holder-concentration, LP-lock, or liquidity-depth analysis.
- **Token Due Diligence Report** — similar scope, fewer chains, no buy/sell simulation cross-check.

This Actor fuses **three independent free sources** (GoPlus audit + DEXScreener liquidity + Honeypot.is simulation) so a single upstream's blind spot doesn't produce a false SAFE — and every result itemizes exactly which source said what.

### Honest limitations

- **A SAFE verdict is not a guarantee.** Scans are heuristic; a malicious dev can rug through paths no static audit catches (e.g., social exit, CEX liquidity, upgradeable proxy logic). Treat SAFE as "no known red flags right now."
- Results reflect the **moment of the scan** — taxes, ownership, and LP locks can change in one transaction. Re-scan before acting.
- Very new tokens (minutes old) may return `UNKNOWN` until GoPlus/DEXScreener index them.
- Honeypot.is simulation covers Ethereum, BSC, and Base only; Solana has no honeypot simulation (SPL authority checks are used instead).
- LP-lock data depends on GoPlus recognizing the locker; V3-style NFT positions may show as "unlocked."
- Not financial advice.

### Pricing (suggested monetization for the publisher)

Pay-per-event, in line with the category ($0.01–$0.02 per token across competing scanners):

- **Token scanned** (primary event): **$0.02** — charged only when a scan returns a result.
- **Actor start**: $0.001.

This matches the Solana Trust Scanner and Honeypot Detector price while covering 8 chains, which is the differentiation that justifies parity pricing rather than undercutting. (Apify pays the developer 80% of revenue, monthly.)

### API access & AI agents

Need this scan inside a bot or agent, per call, no account?

- **Pay-per-call API** — x402, USDC on Base, from $0.01/call: `GET https://store.agentexchange.work/crypto/security?address=YOUR_TOKEN_ADDRESS&chain=base` — same verdict JSON, plus 60+ other pay-per-call data endpoints. Discovery: https://store.agentexchange.work/.well-known/x402
- **MCP server** for Claude / Cursor / any MCP client: https://store.agentexchange.work/mcp
- **Free live samples** of every endpoint: https://store.agentexchange.work/samples

# Actor input Schema

## `tokenAddress` (type: `string`):

Token contract address to scan. EVM chains: 0x… contract address. Solana: base58 mint address.

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

Blockchain the token lives on.

## `deepScan` (type: `boolean`):

Adds a Honeypot.is buy/sell simulation cross-check (Ethereum, BSC, Base), full list of DEX pairs with per-pair liquidity, and project social links. Slightly slower.

## Actor input object example

```json
{
  "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "chain": "base",
  "deepScan": false
}
```

# 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 = {
    "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
};

// Run the Actor and wait for it to finish
const run = await client.actor("agent_services/crypto-rug-check").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 = { "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }

# Run the Actor and wait for it to finish
run = client.actor("agent_services/crypto-rug-check").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 '{
  "tokenAddress": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
}' |
apify call agent_services/crypto-rug-check --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=agent_services/crypto-rug-check",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Crypto Token Rug Check — Honeypot & Security Scanner",
        "description": "Instant rug-pull risk scan for any token across 8 chains (Base, Ethereum, BSC, Solana & more). Honeypot simulation, ownership/mint checks, taxes, LP lock, holder concentration — one SAFE/WARN/DANGER verdict with a 0-100 risk score. Free data sources, no API keys needed.",
        "version": "0.1",
        "x-build-id": "r6gBXVzAGnWxoKSSH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agent_services~crypto-rug-check/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agent_services-crypto-rug-check",
                "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/agent_services~crypto-rug-check/runs": {
            "post": {
                "operationId": "runs-sync-agent_services-crypto-rug-check",
                "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/agent_services~crypto-rug-check/run-sync": {
            "post": {
                "operationId": "run-sync-agent_services-crypto-rug-check",
                "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": [
                    "tokenAddress"
                ],
                "properties": {
                    "tokenAddress": {
                        "title": "Token address",
                        "type": "string",
                        "description": "Token contract address to scan. EVM chains: 0x… contract address. Solana: base58 mint address."
                    },
                    "chain": {
                        "title": "Chain",
                        "enum": [
                            "ethereum",
                            "base",
                            "bsc",
                            "polygon",
                            "arbitrum",
                            "optimism",
                            "avalanche",
                            "solana"
                        ],
                        "type": "string",
                        "description": "Blockchain the token lives on.",
                        "default": "base"
                    },
                    "deepScan": {
                        "title": "Deep scan",
                        "type": "boolean",
                        "description": "Adds a Honeypot.is buy/sell simulation cross-check (Ethereum, BSC, Base), full list of DEX pairs with per-pair liquidity, and project social links. Slightly slower.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```