Pricing

from $5.00 / 1,000 results

Try for free

Go to Apify Store

Dexscreener Scraper

Try for free

Dexscreener scraper — search any keyword, token or pair, paste a Dexscreener URL, or pull live boost/profile feeds, and get clean per-pair rows: price, liquidity, FDV, market cap, 24h/6h/1h volume and change, buy/sell counts. Every chain, from Dexscreener's public API. No proxy. JSON or CSV out.

Pricing

from $5.00 / 1,000 results

Rating

4.5

(2)

Developer

Muhamed Didovic

Actor stats

Bookmarked

Total users

Monthly active users

18 hours ago

Last modified

Categories

Automation

Agents

You can access the Dexscreener Scraper programmatically from your own applications by using the Apify API. You can also choose the language preference from below. To use the Apify API, you’ll need an Apify account and your API token, found in API & Integrations in Apify Console.

Python

JavaScript

CLI

OpenAPI

HTTP

MCP

{
  "openapi": "3.0.1",
  "info": {
    "version": "0.0",
    "x-build-id": "gfSnuAXYpi5f1YiQ1"
  },
  "servers": [
    {
      "url": "https://api.apify.com/v2"
    }
  ],
  "paths": {
    "/acts/memo23~dexscreener-scraper/run-sync-get-dataset-items": {
      "post": {
        "operationId": "run-sync-get-dataset-items-memo23-dexscreener-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/memo23~dexscreener-scraper/runs": {
      "post": {
        "operationId": "runs-sync-memo23-dexscreener-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/memo23~dexscreener-scraper/run-sync": {
      "post": {
        "operationId": "run-sync-memo23-dexscreener-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",
        "properties": {
          "searchQueries": {
            "title": "Search queries",
            "type": "array",
            "description": "Keywords, symbols or names to search (e.g. <code>SOL</code>, <code>PEPE</code>, <code>USDC/SOL</code>). Each query returns its matching pairs.",
            "items": {
              "type": "string"
            }
          },
          "urlsOrAddresses": {
            "title": "URLs, pair or token addresses",
            "type": "array",
            "description": "Dexscreener pair URLs (e.g. <code>https://dexscreener.com/solana/&lt;pairAddress&gt;</code>), bare <code>chain/pairAddress</code>, or token contract addresses. Token addresses return every pool trading that token.",
            "items": {
              "type": "string"
            }
          },
          "discoveryMode": {
            "title": "Discovery mode",
            "enum": [
              "none",
              "latestProfiles",
              "latestBoosts",
              "topBoosts"
            ],
            "type": "string",
            "description": "Instead of (or in addition to) queries, pull a live discovery feed: the latest token profiles, the latest boosted tokens, or the most-boosted tokens right now.",
            "default": "none"
          },
          "chainFilter": {
            "title": "Chain filter",
            "type": "string",
            "description": "Optional. Keep only pairs on this chain (e.g. <code>solana</code>, <code>ethereum</code>, <code>base</code>, <code>bsc</code>). Leave empty for all chains."
          },
          "maxItems": {
            "title": "Max pairs",
            "minimum": 1,
            "type": "integer",
            "description": "Maximum number of pairs to return across all inputs.",
            "default": 1000
          },
          "proxy": {
            "title": "Proxy configuration (optional)",
            "type": "object",
            "description": "Optional. Dexscreener's public API is generous and usually needs no proxy; set this only if you hit rate limits."
          }
        }
      },
      "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
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Dexscreener Scraper OpenAPI definition

OpenAPI is a standard for designing and describing RESTful APIs, allowing developers to define API structure, endpoints, and data formats in a machine-readable way. It simplifies API development, integration, and documentation.

OpenAPI is effective when used with AI agents and GPTs by standardizing how these systems interact with various APIs, for reliable integrations and efficient communication.

By defining machine-readable API specifications, OpenAPI allows AI models like GPTs to understand and use varied data sources, improving accuracy. This accelerates development, reduces errors, and provides context-aware responses, making OpenAPI a core component for AI applications.

You can download the OpenAPI definitions for Dexscreener Scraper from the options below:

OpenAPI.json

If you’d like to learn more about how OpenAPI powers GPTs, read our blog post.

You can also check out our other API clients:

Dexscreener Scraper API in Python

Dexscreener Scraper API in JavaScript

Dexscreener Scraper API through CLI

Dexscreener Scraper API

Dexscreener Scraper

quarterly_jingo/dexscreener-scraper

Petey Boy

Dexscreener Realtime Monitor

khadinakbar/dexscreener-realtime-monitor

Monitor live Dexscreener DEX pairs — price, 5m/1h/6h/24h change, volume, liquidity, FDV, market cap across Solana, Ethereum, Base, BSC and 100+ chains. Watchlist alerts, new-pair & trending discovery. HTTP-only, MCP-ready.

Khadin Akbar

DexScreener Crypto Scraper | Token Data API

parsebird/dexscreener-crypto-scraper

Extract DexScreener token data: prices, liquidity, market cap, volume, transactions, FDV, pair URLs, socials. Filter, schedule, use API, export JSON, CSV, Excel.

ParseBird

Dexscreener Pair Scraper

crypto-scraper/dexscreener-pair-scraper

A powerful scraper that scrapes real-time data for any token pair from DexScreener. Get prices, liquidity, volume, transaction data, contract addresses, and social links in a clean JSON format.

Crypto Scraper

DexScreener DEX Pairs, Liquidity & Volume Scraper

scrapers_lat/dexscreener-pairs-scraper

Scrape on-chain DEX trading pairs with live USD price, liquidity, 24h/6h/1h volume, price-change momentum, buy and sell counts, market cap, FDV and token socials. Search any token by symbol, name or contract address and filter by chain. Export to JSON, CSV or Excel.

Scrapers Lat

DexScreener Crypto Token & Pair Scraper

fortuitous_pirate/dexscreener-scraper

Scrape DexScreener crypto data: token name & symbol, price USD, liquidity, 24h volume, price change, market cap, chain, pair address and DEX URL. Ideal for crypto market research, token monitoring, DEX analytics and trading signals.

Fortuitous Pirate

Dexscreener Scraper - DEX Token Prices, Liquidity & Volume

feedforge/dexscreener-scraper

Scrape DEX trading pairs from Dexscreener. Prices, liquidity, market cap, 24h volume and transaction counts as JSON or CSV.

Dominik

DexScreener Scraper — DEX Pairs, Prices & Token Data

bovi/dexscreener-scraper

Scrape Dexscreener DEX market data — token pairs, USD/native price, liquidity, 24h volume, FDV, market cap across all chains. Search, pair, token and trending-profile modes. Public API, no key. Each record has parse_confidence.