# Solana Token Trust Scanner: Rug and Honeypot Risk Score (`mrlarryjohnson/solana-token-trust-scanner`) Actor

Paste any Solana token mint, get a 0-100 trust score with evidence-backed flags: mint/freeze authority renounced, liquidity, can't-sell honeypot patterns, pump.fun bonding-curve status, deployer wallet. Every flag links to on-chain proof. Failed lookups are free, never faked.

- **URL**: https://apify.com/mrlarryjohnson/solana-token-trust-scanner.md
- **Developed by:** [Larry Johnson](https://apify.com/mrlarryjohnson) (community)
- **Categories:** AI, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 token scanneds

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

## Solana Token Trust Scanner

Paste a Solana token mint address. Get back a 0-100 trust score and a list of plain-language flags that tell you, with on-chain proof, whether the token has the classic rug and honeypot traps before you buy.

This is built for the way memecoins actually trade: someone drops a contract address in a Telegram group or you spot one trending on Dexscreener, and you have about ten seconds to decide. This scanner does the boring checks for you in that window, and it shows its work so you can verify every flag yourself on Solscan.

### What it checks (and where the data comes from)

| Check | What it tells you | Source |
| --- | --- | --- |
| Mint authority renounced? | If active, the deployer can print unlimited new supply and dilute you to zero | Solana RPC (on-chain) |
| Freeze authority renounced? | If active, the deployer can freeze your wallet so you can never sell. This is the classic honeypot. | Solana RPC (on-chain) |
| Liquidity and volume | How deep the pools are and whether anyone is actually trading. Thin liquidity is trivially rug-able. | Dexscreener |
| Buy / sell balance | Lots of buys and almost no sells over 24h is the signature of a token you can buy but not sell | Dexscreener |
| Pump.fun status | Whether it is still on a bonding curve (pre-graduation, higher risk) or has graduated to a real DEX, plus the deployer wallet | pump.fun |
| Holder concentration | What share of supply the top 10 wallets hold. High concentration means a few wallets can dump on you. | Optional, needs a free Helius key |

Every flag carries the evidence behind it. When the freeze authority is active, the flag includes the actual authority address so you can confirm it on Solscan. We do not hand you a black-box number and ask you to trust it.

### Input

```json
{
  "tokens": [
    "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  ]
}
````

- `tokens` (required): one or more Solana mint addresses. One per line in the editor, or an array via the API.
- `maxTokens` (optional): cap on how many to scan in a run. Default 5000.
- `heliusApiKey` (optional): a free key from helius.dev unlocks the holder-concentration check. Leave it blank and that one signal is reported as `unknown` instead of guessed.

### Output

One record per token:

```json
{
  "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "symbol": "USDC",
  "verdict": "critical-risk",
  "trustScore": 14,
  "freezeAuthorityActive": true,
  "mintAuthorityActive": true,
  "liquidityUsd": 11275423.09,
  "volume24h": 9545593.77,
  "graduated": null,
  "top10HolderPct": null,
  "flags": [
    {"level": "critical", "msg": "Freeze authority is ACTIVE (7dGbd...rar). The deployer can freeze your tokens so you can never sell (honeypot vector)."},
    {"level": "high", "msg": "Mint authority is ACTIVE (BJE5M...ruG). Supply can be inflated at will."}
  ],
  "dexscreenerUrl": "https://dexscreener.com/solana/...",
  "checkedAt": "2026-06-14T20:30:00+00:00"
}
```

`verdict` is one of `low-risk`, `medium-risk`, `high-risk`, `critical-risk`, plus the housekeeping values `invalid-address`, `not-found`, `unknown`, and `no-input`.

### How the trust score works

The score starts at a neutral 50 and moves up or down as each signal comes in. A renounced freeze and mint authority push it up. An active freeze authority is treated as an automatic critical risk, because it is the one trap that can lock your funds completely. Thin liquidity, a one-sided buy/sell ratio, and a token still sitting on the bonding curve push it down. Deep liquidity and a pool that has survived a long time push it up. The full breakdown lives in the `flags` list on every record, so you can see exactly which checks moved the number and why.

A high score is not a green light to ape. It means the obvious on-chain traps are not present. It cannot tell you the team will not soft-rug, that a large holder will not dump, or that the chart will go up. Treat it as a fast filter that removes the clearly dangerous tokens, not as a promise that the rest are safe.

### What it cannot see (stated plainly)

- Holder concentration needs a Helius key. Without one, that signal is reported as `unknown`, never assumed to be fine.
- Top-holder accounts can include the liquidity pool itself, so a high concentration number is a prompt to look closer, not a verdict on its own.
- We do not detect every flavor of malicious code (transfer hooks, exotic Token-2022 extensions). When a token uses the Token-2022 program we flag it so you know to look.
- This is information, not financial advice. Memecoins are high risk by nature. You are responsible for your own trades.

### Billing

You pay per token that gets a real verdict. If our data sources are unreachable and we cannot assess a token, that row comes back as `unknown` and you are not charged for it. We bill for answers, never for our own failures. An empty input run is also free.

### Use it from an AI agent

The same scan logic is built to run as a tool an AI agent can call (Claude, Cursor, n8n and similar). An agent watching new launches can scan a contract and act on the structured `score` and `flags` without a human in the loop.

# Actor input Schema

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

Solana token mint addresses to scan. One per line in the editor (or pass an array / a comma- or newline-separated string via API). Paste the contract address you see on pump.fun, Dexscreener, or in a Telegram call.

## `maxTokens` (type: `integer`):

Safety cap on how many tokens one run will scan.

## `heliusApiKey` (type: `string`):

Optional. A free Helius key (helius.dev) unlocks the holder-concentration module (top-10 holders' share of supply), the one safety signal with no free public source. Leave blank to skip it; that signal is then honestly reported as 'unknown' rather than guessed.

## Actor input object example

```json
{
  "tokens": [
    "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  ],
  "maxTokens": 5000
}
```

# Actor output Schema

## `results` (type: `string`):

All token scan records produced by this run as JSON items.

# 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": [
        "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrlarryjohnson/solana-token-trust-scanner").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": [
        "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mrlarryjohnson/solana-token-trust-scanner").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": [
    "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  ]
}' |
apify call mrlarryjohnson/solana-token-trust-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mrlarryjohnson/solana-token-trust-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Solana Token Trust Scanner: Rug and Honeypot Risk Score",
        "description": "Paste any Solana token mint, get a 0-100 trust score with evidence-backed flags: mint/freeze authority renounced, liquidity, can't-sell honeypot patterns, pump.fun bonding-curve status, deployer wallet. Every flag links to on-chain proof. Failed lookups are free, never faked.",
        "version": "0.1",
        "x-build-id": "yXUTW3oc24ldVxggU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mrlarryjohnson~solana-token-trust-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mrlarryjohnson-solana-token-trust-scanner",
                "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/mrlarryjohnson~solana-token-trust-scanner/runs": {
            "post": {
                "operationId": "runs-sync-mrlarryjohnson-solana-token-trust-scanner",
                "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/mrlarryjohnson~solana-token-trust-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-mrlarryjohnson-solana-token-trust-scanner",
                "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 mint addresses",
                        "type": "array",
                        "description": "Solana token mint addresses to scan. One per line in the editor (or pass an array / a comma- or newline-separated string via API). Paste the contract address you see on pump.fun, Dexscreener, or in a Telegram call.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTokens": {
                        "title": "Max tokens per run",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Safety cap on how many tokens one run will scan.",
                        "default": 5000
                    },
                    "heliusApiKey": {
                        "title": "Helius API key (optional)",
                        "type": "string",
                        "description": "Optional. A free Helius key (helius.dev) unlocks the holder-concentration module (top-10 holders' share of supply), the one safety signal with no free public source. Leave blank to skip it; that signal is then honestly reported as 'unknown' rather than guessed."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```