# Token Honeypot & Rug-Pull Check (`vetagent/token-honeypot-rug-pull-check`) Actor

Before you or your AI agent buy a token, check whether you could still sell it: sell simulation and taxes on Ethereum, BSC and Base, mint and freeze authority on Solana, plus liquidity depth, pair age and impersonation. One fail-closed verdict per token.

- **URL**: https://apify.com/vetagent/token-honeypot-rug-pull-check.md
- **Developed by:** [jake gu](https://apify.com/vetagent) (community)
- **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/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Token Honeypot & Rug-Pull Check

Check a token before you, your trading bot or your AI agent buys it, and answer the question
that matters first: **could you still sell it?**

This Actor sends each address to [VetAgent](https://vetagent.dev), a free pre-trade check, and
returns one row per token with a `low`, `medium`, `high` or `unknown` verdict and every signal
behind it. Use it for batch checks, scheduled runs, or to wire a pre-trade check into Make,
Zapier or a webhook through Apify's integrations.

### What it checks

| Check | Chains |
|---|---|
| Buy/sell simulation (honeypot), buy/sell/transfer tax | Ethereum, BSC, Base |
| Mint and freeze authority, top-10 holder concentration | Solana |
| Liquidity depth, counted only for reserves held in independently priced assets | Ethereum, BSC, Base, Arbitrum, Optimism, Polygon, Avalanche, Solana |
| Pair age, 24h turnover across the token's pools | Every chain |
| Same-ticker impersonation within one chain | Every chain |
| Owner powers in the bytecode (blacklist, tax change, pause, mint): disclosed, never scored | Ethereum, BSC, Base |

On a chain the sell simulator does not cover, the answer says so and comes back `unknown`
rather than pretending the check ran.

### How to read the verdict

- **`low`**: no fatal signal in the checks that ran. The exit was open when the token was
  checked; that does not mean nobody can close it later.
- **`medium`**: real signals, none fatal. Read them before acting.
- **`high`**: do not proceed without review.
- **`unknown`**: a critical check could not run. **Never treat it as a green light.**
  `nextAction` says whether to `retry` (a data source failed) or `abstain` (nothing can see
  the token).

If this Actor cannot get an answer at all (an invalid address, or a call that still failed
after retries), the row still comes back `unknown`, with `verdictSource` set to `actor` and the
reason in `error`. A failure can never be read as low risk.

### Input

```json
{
    "tokens": ["0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"],
    "chainHint": "base",
    "verboseEvidence": false
}
```

- `tokens`: EVM (`0x...`) or Solana mint addresses, up to 100 per run.
- `chainHint`: `auto`, `ethereum`, `bsc`, `base`, `arbitrum`, `polygon`, `optimism`,
  `avalanche` or `solana`. The same address can exist on several chains; with `auto`, each
  answer covers the chain holding the most liquidity and names it.
- `verboseEvidence`: also return raw upstream fields such as reserves.

### Output

One dataset row per token. A real row for USDC on Base from this Actor's own test run on
2026-09-16, with two of its four signals and the `evidence` object left out:

```json
{
    "token": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "chain": "base",
    "dex": "geckoterminal",
    "liquidityUsd": 124555000,
    "riskLevel": "low",
    "confidence": "high",
    "driver": null,
    "recommendation": "Low risk: sellable and liquid when checked, no fatal signal. The exit was open when we looked; that is not the same as it cannot be closed. **Owner powers unchecked**: bytecode unreadable (rpc 429). A gap on our side, not a clean result.",
    "nextAction": null,
    "checkedAt": "2026-09-16T10:53:21Z",
    "signals": [
        {"severity": "ok", "name": "Liquidity is adequate", "message": "Main pair holds $124,554,916.", "category": "liquidity"},
        {"severity": "ok", "name": "Established pair", "message": "Main pair has existed for 1033 days.", "category": "freshness"}
    ],
    "verdictSource": "vetagent",
    "error": null
}
```

Note what that recommendation does: one check (owner powers in the bytecode) could not run
on the day, and the answer says so instead of passing over it. `dex` names the DEX when
VetAgent's primary source does, and says `geckoterminal` when the pool was read through its
fallback source.

### How accurate is it?

VetAgent publishes its own measured error rates, including the ones that make it look worst,
with the benchmark that reproduces them: [vetagent.dev/method](https://vetagent.dev/method).
No figures are copied here, because they change every time the benchmark is re-run.

### For AI agents: connect over MCP instead

An agent that speaks MCP does not need this Actor. Point it at `https://vetagent.dev/mcp`
(Streamable HTTP, no key) and it gets `assess_token_risk`, `get_token_liquidity` and
`find_new_hot_pools` directly. See [vetagent.dev/api](https://vetagent.dev/api).

### Limits and cost

- Up to 100 addresses per run; any beyond that are skipped, and the log says how many.
- VetAgent allows about 60 calls a minute per caller. The Actor paces itself and waits when
  it is asked to.
- VetAgent is free and needs no API key. Runs use your Apify platform usage like any Actor.

### Privacy

Each address goes in the body of an HTTPS POST to `https://vetagent.dev/assess`, never in a
URL. VetAgent does not log the token addresses it is asked about. The Actor sends no Apify
user id, token or run id; it sends a client name, which is how VetAgent tells its own test
traffic from real use. Runs of the prefilled example, which Apify's daily health check uses,
and runs by this Actor's author are labelled as VetAgent's own.

### Not investment advice

Read-only analysis. It executes no trades and gives no investment advice.

### Source

- This Actor (MIT): [github.com/jakegu1/vetagent-apify-actor](https://github.com/jakegu1/vetagent-apify-actor)
- The engine and its benchmark: [github.com/jakegu1/vetagent](https://github.com/jakegu1/vetagent)
- Questions or problems: hello@vetagent.dev, or an issue on either repository

# Actor input Schema

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

Contract addresses to check, one per line: an EVM address (0x followed by 40 hex characters) or a Solana mint address. Up to 100 per run; any beyond that are skipped and the log says how many.

## `chainHint` (type: `string`):

Which chain the addresses are on. The same address can exist on several chains; with Auto, each answer covers the chain holding the most liquidity and names it in the chain field.

## `verboseEvidence` (type: `boolean`):

Also return raw upstream fields such as reserves and the pair address. Off by default: the slim evidence already carries what is needed to read the verdict.

## Actor input object example

```json
{
  "tokens": [
    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
  ],
  "chainHint": "auto",
  "verboseEvidence": false
}
```

# Actor output Schema

## `results` (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 = {
    "tokens": [
        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vetagent/token-honeypot-rug-pull-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 = { "tokens": ["0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vetagent/token-honeypot-rug-pull-check"
        }
    }
}
```

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/UoBkJfMNKoR2F1guc/builds/TPf3VIrs2Nd9GLqOg/openapi.json