# DexScreener Pair Security — Holders, Locks, Audit, Honeypot (`logiover/dexscreener-pair-security-scraper`) Actor

Deep DEX pair data not in DexScreener's public API — security audit (honeypot, verified, renounced, mint/burn/blacklist), LP locks (UNCX, % locked), holder distribution, CoinGecko + CoinMarketCap metadata. Bulk pairs across all chains. For rugpull detection, due diligence, safety apps.

- **URL**: https://apify.com/logiover/dexscreener-pair-security-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Business, Developer tools, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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

## DexScreener Pair Security Scraper — Honeypot, Rugpull, Audit & LP Lock Detection

![DexScreener Pair Security — Holders, Locks, Audit, Honeypot](https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/GjS6nQ8qauOdq9KGy-actor-30ipxRNMyR690RlOn-oYzIjDcFfw-unnamed.png)

**The unique deep-data export for DEX pairs — security audit, honeypot detection, contract verification, liquidity locks, holder distribution and authoritative CoinGecko + CoinMarketCap metadata that DexScreener's public REST API does NOT expose.** Bulk-resolve hundreds — or thousands — of DEX pair addresses across Solana, Ethereum, Base, BSC, Polygon, Arbitrum, Avalanche and 30+ chains in one run.

Built for **rugpull detection systems, due-diligence dashboards, retail wallet safety apps, security firms, audit pipelines, on-chain forensics, KYT / KYC platforms and trading-bot safety filters**.

🟢 No API key. No login. Built-in Cloudflare bypass via Apify Residential proxy + TLS fingerprint rotation.

---

### 🚀 Why this scraper

DexScreener's public REST API (`api.dexscreener.com`) is excellent for price, liquidity, volume and basic pair identity — but it deliberately omits the deeper signals that actually answer "is this token safe to trade?":

- **Honeypot detection** — can users sell, or is there a sell tax that traps buyers?
- **Contract verification** — is the source code published, or is it opaque?
- **Ownership renunciation** — does the deployer still have admin keys?
- **Mint / burn / blacklist capabilities** — can the owner mint unlimited supply, burn user balances, or block specific addresses from selling?
- **Hidden owner / proxy contracts** — is real control obscured behind upgradeability?
- **Liquidity locks** — is LP actually locked (UNCX, Team Finance, Onlymoons, Pinksale, etc.), and for what percentage?
- **Holder distribution** — how many holders, how concentrated at the top?
- **Authoritative metadata** — what does CoinGecko / CoinMarketCap actually say about this token's identity?

DexScreener's frontend pair page renders all of this from an **internal endpoint** (`io.dexscreener.com/dex/pair-details/v4`) that uses Quickintel for EVM audit, on-chain lock data for liquidity locks, and direct CoinGecko + CoinMarketCap integrations. This scraper accesses that same endpoint at scale, bypassing Cloudflare via Apify Residential proxy and got-scraping's TLS fingerprint rotation.

The output is the only commercial-grade source of these signals outside DexScreener's own UI.

---

### ✨ Key features

| Feature | What it gives you |
|---|---|
| 🛡️ **Quickintel security audit** | Honeypot, verified, renounced, mint, burn, blacklist, multi-blacklist, whitelist, hidden owner, proxy, external contract risk, obfuscated address risk |
| 🔒 **Liquidity lock data** | UNCX, Team Finance, Onlymoons, Pinksale and other lockers with exact percentage locked + lock contract URL |
| 👥 **Holder distribution** | Total holder count + top holders array, LP holder count |
| 📖 **CoinGecko metadata** | Categories, official description, ID, URL |
| 📊 **CoinMarketCap metadata** | Tags, websites, Twitter, launch date, CMC ID |
| 📝 **DexScreener-managed metadata** | Verified name, description, social links, creation timestamp |
| 💰 **Supply data** | Total, circulating, max supply from authoritative sources |
| ☁️ **Cloudflare bypass built-in** | Apify Residential proxy + got-scraping TLS fingerprint rotation |
| 🗃️ **40+ flat columns** | No nested JSON, ready for spreadsheets and BI tools |
| 🔓 **No API key, no login** | Works out of the box |

---

### 🎯 Built for these use cases

#### 1. Rugpull / honeypot detection systems
Flag tokens where `isHoneypot=true`, `canMint=true`, `canBlacklist=true`, `lpLockTotalPercentage < 100`, or `holdersCount < 100` with concentrated top holders. Schedule the actor over your token universe and pipe red-flag tokens into your alert system.

#### 2. Trading-bot safety filter
Before opening a position, run a 1-pair lookup. If `auditProblem=true` or `isHoneypot=true`, skip the trade. Saves capital from obviously dangerous tokens.

#### 3. Retail wallet safety apps
Show users a risk indicator before they confirm a swap. "This token has minting enabled and unlocked liquidity — high risk."

#### 4. Security firm bulk audits
Run a daily sweep of trending tokens to generate intelligence reports for clients. "Top 50 DEX-traded tokens with mintable supply this week."

#### 5. Due diligence dashboards
Pre-trade or pre-investment audit reports for every position. Integrate the output into your compliance / OTC desk workflow.

#### 6. Anti-scam research
Catalog the patterns. Tokens with hidden owners + low holders + boosted on DexScreener within 24 hours of launch = textbook setup. Build the dataset, train the model.

#### 7. KYT / KYC enrichment
Wallet-screening platforms can use the audit signals to flag transactions involving high-risk tokens.

#### 8. On-chain forensics
Investigators correlating wallet activity with token risk profile. Did the suspect interact with known mintable / blacklist-capable tokens?

#### 9. Insurance & compliance reporting
Document the security posture of all tokens your protocol or fund touches. Audit trail.

---

### 📥 Inputs

| Field | Type | Required | Description |
|---|---|---|---|
| `pairs` | string[] | ✅ Yes | List of `chainId:pairAddress` entries. Example: `ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8`. Pair addresses are on-chain LP / pool addresses (visible in DexScreener pair URLs). |
| `useProxy` | boolean | No | Use Apify Residential proxy (default `true`). Strongly recommended for production. |
| `proxyGroups` | string[] | No | Apify proxy group names. Default `["RESIDENTIAL"]`. |
| `skipHolders` | boolean | No | Omit the full holders array (keep `holdersCount` only). Reduces output size. |
| `maxConcurrency` | int | No | Parallel requests (1–10). Default `3` (internal endpoint has stricter rate limits than public API). |

#### Example inputs

**Default — single pair full audit:**
```json
{
  "pairs": ["ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8"]
}
````

**Bulk audit — 100 pairs:**

```json
{
  "pairs": [
    "ethereum:0xabc...",
    "solana:def...",
    "base:0x123...",
    "..."
  ],
  "maxConcurrency": 3
}
```

**Lightweight (no full holder list):**

```json
{
  "pairs": ["ethereum:0x..."],
  "skipHolders": true
}
```

***

### 📤 Output (per pair)

```json
{
  "chainId": "ethereum",
  "pairAddress": "0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8",
  "tokenAddress": "0xcab254f1a32343f11ab41fbde90ecb410cde348a",
  "tokenName": "Froge",
  "tokenSymbol": "FROGE",
  "tokenDecimals": 18,
  "tokenCreatedAt": "2024-10-31T15:35:59.000Z",

  "contractVerified": true,
  "contractRenounced": true,
  "contractCreator": "0x34919f7dd781e5cdbda923392dbc627add997a8f",
  "isHoneypot": false,
  "auditProblem": true,
  "auditExtra": "Liquidity low or problem with the purchase!",
  "canMint": false,
  "canBurn": false,
  "canBlacklist": false,
  "canMultiBlacklist": false,
  "canWhitelist": false,
  "hiddenOwner": false,
  "isProxy": false,
  "hasExternalContractRisk": false,
  "hasObfuscatedAddressRisk": false,

  "lpLockTotalPercentage": 100,
  "lpLocks": [
    {
      "tag": "UNCX",
      "address": "1-0xfd235968e65b0990584585763f837a5b5330e6",
      "amount": "97360743942280095720036981",
      "percentage": 100,
      "url": "https://app.uncx.network/lockers/univ3/chain/1/address/0x5628f3bb..."
    }
  ],

  "totalSupply": 649675271791611.8,
  "circulatingSupply": 649675271791611.8,
  "maxSupply": null,

  "holdersCount": 4282,
  "holders": [/* top holders array */],
  "lpHoldersCount": 11,

  "cgId": "froge",
  "cgUrl": "https://www.coingecko.com/en/coins/froge",
  "cgCategories": ["Ethereum Ecosystem", "Meme"],

  "cmcId": 35139,
  "cmcName": "Froge",
  "cmcSymbol": "FROGE",
  "cmcTags": [{"name":"Memes","group":"CATEGORY"}],
  "cmcWebsites": ["https://froge.io/"],
  "cmcTwitter": ["https://twitter.com/frogetoken"],
  "cmcDateLaunched": "2024-01-28T00:00:00.000Z",

  "cmsName": "Froge",
  "cmsDescription": "...",
  "cmsLinks": [
    {"label":"Website","url":"https://froge.io/"},
    {"type":"twitter","url":"https://x.com/frogetoken"}
  ],

  "scrapedAt": "2026-05-16T08:42:00.000Z"
}
```

***

### 🚨 Risk-scoring guide — how audit fields map to danger

| Field | Risk meaning | Severity |
|---|---|---|
| `isHoneypot: true` | Users CANNOT sell. Hard rug. | 🔴 Critical |
| `auditProblem: true` | Liquidity issue or purchase restriction detected | 🟠 High |
| `canMint: true` | Owner can mint unlimited supply → dilution risk | 🔴 Critical |
| `canBurn: true` | Owner can burn user balances → asymmetric power | 🟠 High |
| `canBlacklist: true` | Owner can block specific addresses from trading | 🟠 High |
| `canMultiBlacklist: true` | Mass-blacklist capability | 🔴 Critical |
| `hiddenOwner: true` | Real ownership obscured | 🟠 High |
| `isProxy: true` | Upgradeable contract — owner can swap implementation | 🟠 High |
| `hasExternalContractRisk: true` | Calls external untrusted contracts | 🟡 Medium |
| `hasObfuscatedAddressRisk: true` | Suspicious addresses in contract | 🟡 Medium |
| `contractRenounced: false` | Owner still has admin keys | 🟡 Medium |
| `contractVerified: false` | Source code not published | 🟠 High |
| `lpLockTotalPercentage < 100` | Soft-rug risk | 🟡 Medium |
| `lpLockTotalPercentage < 50` | High soft-rug risk | 🔴 Critical |
| `holdersCount < 50` | Early/illiquid token | 🟡 Medium |
| `holdersCount < 100` + concentrated top | Whale-controlled | 🟠 High |

#### Composite risk score recipe

```pseudo
score = 0
if isHoneypot:                  score += 100
if canMint:                     score += 50
if canMultiBlacklist:           score += 50
if canBurn:                     score += 30
if canBlacklist:                score += 30
if hiddenOwner:                 score += 30
if isProxy:                     score += 20
if not contractVerified:        score += 25
if not contractRenounced:       score += 15
if lpLockTotalPercentage < 50:  score += 30
if lpLockTotalPercentage < 100: score += 10
if holdersCount < 100:          score += 15
if auditProblem:                score += 20

if score >= 100: RISK = "CRITICAL — do not trade"
elif score >= 50: RISK = "HIGH — caution"
elif score >= 25: RISK = "MEDIUM — investigate"
else:             RISK = "LOW"
```

***

### ⚙️ How it works

1. **Parses** `chainId:pairAddress` entries
2. **For each pair**, fires a request to `io.dexscreener.com/dex/pair-details/v4/{chain}/{addr}` via **got-scraping** (TLS fingerprint rotation) + **Apify Residential proxy**
3. Bypasses Cloudflare via realistic browser fingerprint + proxy IP rotation
4. **Parses** the nested response (`cg`, `cmc`, `cms`, `qi`, `ll`, `holders`, `lpHolders`, `su`, `ta`)
5. **Flattens** 40+ fields into a single row
6. **Streams** results to the Apify Dataset

***

### ⚡ Performance & limits

| Workload | Time | Notes |
|---|---|---|
| 1 pair | ~3 seconds | Includes proxy connection setup |
| 10 pairs at concurrency 3 | ~12 seconds | Proxy rotation between requests |
| 100 pairs | ~2 minutes | Steady state |
| 1000 pairs | ~25 minutes | Plan for proxy quota |

The internal `pair-details/v4` endpoint is stricter than the public REST API. Recommended concurrency: **2–5**. Higher values increase Cloudflare block risk.

**Apify Residential proxy traffic counts against your Apify proxy data quota.** Each request uses ~50–200 KB depending on response size. 1000 pairs ≈ 100–200 MB of proxy bandwidth.

***

### 💰 Cost model

**Pay-Per-Result** — billed only on the actual pair rows saved. Plus Apify Residential proxy bandwidth.

***

### 🔄 Schedule for continuous monitoring

- **Daily** — refresh audit data for your watchlist of monitored tokens
- **On-demand via API** — single-pair lookup before every trade in your bot
- **Weekly** — bulk sweep of "trending" / "newly launched" tokens for security intelligence reports

***

### 🛠️ FAQ

**Is this scraping?**
We use the same HTTP endpoint that the official DexScreener frontend calls, with proper browser headers via residential proxy. No browser automation, no DOM scraping.

**Why is concurrency lower than other scrapers?**
The internal endpoint has stricter rate limits than the public REST API. Higher concurrency increases Cloudflare block risk and proxy spend.

**How fresh is the audit data?**
DexScreener refreshes audit signals (via Quickintel for EVM chains, on-chain monitors for liquidity locks, periodic syncs for CoinGecko/CoinMarketCap) typically within minutes of contract or supply changes.

**What if a chain isn't supported?**
Audit data depends on per-chain integration:

- **EVM chains** (Ethereum, BSC, Base, Polygon, Arbitrum, Avalanche, Optimism, Fantom) get the richest Quickintel audit.
- **Solana** gets a smaller subset (no Quickintel; relies on Solana-specific signals like supply analysis and metadata).
- **Other chains** (Sui, TON, Tron, Aptos, etc.) get even less audit detail.
- **All chains** get the LP lock data where applicable.

**What if a pair has no audit data?**
Audit fields return `null`. The row is still saved with whatever data is available (metadata, supply, holders).

**Does this work for newly launched tokens?**
Quickintel typically runs within 5–60 minutes of token creation. For very fresh tokens (< 5 min old), expect some audit fields to be `null` initially.

**Why is `useProxy=true` recommended?**
Without proxy, requests come from a single IP. Cloudflare flags repeated requests and starts returning 403s. The residential proxy rotates IPs across requests, mimicking organic traffic.

**Can I get holder addresses?**
Yes — when `skipHolders=false` (default), the `holders` array contains top holders by balance. Set `skipHolders=true` to omit this and just keep `holdersCount`.

**Can I batch?**
The internal endpoint doesn't support batched lookups. Each pair = 1 request. Use concurrency to parallelize.

**What about CoinGecko / CoinMarketCap rate limits?**
We use DexScreener's pre-cached version. No CG/CMC API key needed; no separate rate limit to worry about.

**Why does my Solana lookup return `holdersCount=null`?**
Solana holder analytics isn't integrated as deeply on DexScreener's side. Use Solscan or Helius API if you need detailed Solana holder data.

***

### 📚 Related scrapers in the DexScreener suite

| Scraper | Purpose |
|---|---|
| `dexscreener-token-pairs-scraper` | Token address → ALL pairs (multi-chain). |
| `dexscreener-search-pairs-scraper` | Free-text query → matching pairs. |
| `dexscreener-pair-watchlist-scraper` | Pair address → current data. |
| `dexscreener-boosted-tokens-scraper` | Currently boosted/promoted tokens + marketing spend. |
| **`dexscreener-pair-security-scraper`** | **You are here.** Deep audit, holders, locks, CG/CMC metadata. |

**Recommended workflow:** Use `dexscreener-boosted-tokens-scraper` or `dexscreener-token-pairs-scraper` to discover tokens, then feed their pair addresses into this scraper for security verdict before any action.

***

### 🔑 Keyword cloud

**Core:** dex honeypot detector, rugpull detector, token audit api, defi security scanner, liquidity lock checker, uncx lock checker, dex holder data, token holders api, contract audit api, dex risk api, dex due diligence, defi audit data, smart contract verification, mintable token detector, blacklist detector.

**Per check type:** honeypot api, contract renounced checker, contract verified api, mint function detector, burn function detector, blacklist function api, hidden owner detector, proxy contract detector, liquidity lock api, lp lock percentage checker, holder concentration api.

**Per chain:** ethereum token audit, solana token security, base chain audit, bsc honeypot detector, polygon rugpull check, arbitrum token audit, avalanche security scan.

**Per locker:** uncx lock data, team finance lock checker, onlymoons lock api, pinksale lock data, dxsale lock checker.

**Per audience:** rugpull prevention for traders, token security for wallets, defi safety for retail, security api for compliance, smart contract risk api, kyt token enrichment, defi forensics api, audit data for security firms.

**Per use case:** memecoin safety check, dex pair audit bulk, defi audit pipeline, anti scam research, security intelligence crypto, trading bot safety filter, due diligence dashboard, on-chain forensics data.

# Actor input Schema

## `pairs` (type: `array`):

List of DEX pair addresses to deep-analyze. Each entry MUST be `chainId:pairAddress`. Examples: 'solana:T5mZpKou42YF3ssrQyrxFJZDL4zvBKg8u1HxqBfDyoo', 'ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8'. Pair addresses are the on-chain LP/pool addresses. Returns: security audit (honeypot detection, contract verified, ownership renounced, mint/burn/blacklist capabilities), liquidity lock info (UNCX, Team Finance, percentage), holder distribution (count, top holders), CoinGecko/CoinMarketCap metadata, supply data.

## `useProxy` (type: `boolean`):

When enabled, requests are sent through Apify's residential proxy with TLS fingerprint rotation (got-scraping). Recommended for production runs to avoid Cloudflare blocks on the internal pair-details endpoint. Disable only for debugging.

## `proxyGroups` (type: `array`):

Apify proxy group names. Default is RESIDENTIAL — the most reliable for bypassing Cloudflare. You can specify multiple groups (e.g. \['RESIDENTIAL', 'BUYPROXIES94952']). Ignored if useProxy is false.

## `skipHolders` (type: `boolean`):

When enabled, omits the per-pair holder list array from output (keeps `holdersCount` only). Useful to reduce result size if you only need the count.

## `maxConcurrency` (type: `integer`):

Parallel requests. The internal endpoint is rate-limited harder than public APIs — recommended 2–5. Higher values increase Cloudflare block risk.

## Actor input object example

```json
{
  "pairs": [
    "ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8"
  ],
  "useProxy": true,
  "proxyGroups": [
    "RESIDENTIAL"
  ],
  "skipHolders": false,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `chainId` (type: `string`):

Chain ID

## `tokenSymbol` (type: `string`):

Token symbol

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

Token contract address

## `isHoneypot` (type: `string`):

true if honeypot detected

## `contractVerified` (type: `string`):

true if source verified

## `contractRenounced` (type: `string`):

true if ownership renounced

## `lpLockTotalPercentage` (type: `string`):

Total locked liquidity %

## `holdersCount` (type: `string`):

Total holder count

## `canMint` (type: `string`):

true if mint function exists

## `canBlacklist` (type: `string`):

true if blacklist function exists

## `scrapedAt` (type: `string`):

ISO 8601 timestamp

# 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 = {
    "pairs": [
        "ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/dexscreener-pair-security-scraper").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 = { "pairs": ["ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8"] }

# Run the Actor and wait for it to finish
run = client.actor("logiover/dexscreener-pair-security-scraper").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 '{
  "pairs": [
    "ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8"
  ]
}' |
apify call logiover/dexscreener-pair-security-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/dexscreener-pair-security-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DexScreener Pair Security — Holders, Locks, Audit, Honeypot",
        "description": "Deep DEX pair data not in DexScreener's public API — security audit (honeypot, verified, renounced, mint/burn/blacklist), LP locks (UNCX, % locked), holder distribution, CoinGecko + CoinMarketCap metadata. Bulk pairs across all chains. For rugpull detection, due diligence, safety apps.",
        "version": "1.0",
        "x-build-id": "OYZTTc1SohjwVJZAN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~dexscreener-pair-security-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-dexscreener-pair-security-scraper",
                "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~dexscreener-pair-security-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-dexscreener-pair-security-scraper",
                "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~dexscreener-pair-security-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-dexscreener-pair-security-scraper",
                "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": [
                    "pairs"
                ],
                "properties": {
                    "pairs": {
                        "title": "Pair Specifications",
                        "type": "array",
                        "description": "List of DEX pair addresses to deep-analyze. Each entry MUST be `chainId:pairAddress`. Examples: 'solana:T5mZpKou42YF3ssrQyrxFJZDL4zvBKg8u1HxqBfDyoo', 'ethereum:0x5628F3bb1f352f86Ea173184ffEe2E34b8fc2dc8'. Pair addresses are the on-chain LP/pool addresses. Returns: security audit (honeypot detection, contract verified, ownership renounced, mint/burn/blacklist capabilities), liquidity lock info (UNCX, Team Finance, percentage), holder distribution (count, top holders), CoinGecko/CoinMarketCap metadata, supply data.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "When enabled, requests are sent through Apify's residential proxy with TLS fingerprint rotation (got-scraping). Recommended for production runs to avoid Cloudflare blocks on the internal pair-details endpoint. Disable only for debugging.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Proxy Groups",
                        "type": "array",
                        "description": "Apify proxy group names. Default is RESIDENTIAL — the most reliable for bypassing Cloudflare. You can specify multiple groups (e.g. ['RESIDENTIAL', 'BUYPROXIES94952']). Ignored if useProxy is false.",
                        "default": [
                            "RESIDENTIAL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "skipHolders": {
                        "title": "Skip Holders Field",
                        "type": "boolean",
                        "description": "When enabled, omits the per-pair holder list array from output (keeps `holdersCount` only). Useful to reduce result size if you only need the count.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel requests. The internal endpoint is rate-limited harder than public APIs — recommended 2–5. Higher values increase Cloudflare block risk.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```