Get Price By Pool

Fetch precise, real-time Solana token prices from any liquidity pool by specifying the token mint and pool ID, all via a single CoinVera REST endpoint.

Retrieve the real-time price of a specific token from any supported DEX pool. This is ideal when you need precision pricing or want to target a particular liquidity pool for lowest latency.

Endpoint

GET https://api.coinvera.io/api/v1/price

Authentication Include your API key in the request header:

x-api-key: <YOUR_API_KEY>

Query Parameters

• ca (string, required) — The token’s mint address.

• poolId (string, required) — The identifier of the liquidity pool you want to query.

Direct URL Example

https://api.coinvera.io/api/v1/price?ca=<TOKEN_MINT>&poolId=<POOL_ID>&x-api-key=<YOUR_API_KEY>

Code Examples

Nodejs

const axios = require('axios');

const x_api_key = "";

// Add your token addresses and pool IDs here
const tokens = [
    {
        ca: "",
        poolId: ""
    },
];

async function getPrice(ca, poolId) {
    try {
        const url = `https://api.coinvera.io/api/v1/price?x-api-key=${x_api_key}&ca=${ca}&poolId=${poolId}`;
        const response = await axios.get(url);
        return { ca, poolId, ...response.data };
    } catch (err) {
        return { ca, poolId, error: err.message };
    }
}

async function getPricesForAllTokens() {
    const results = await Promise.all(tokens.map(token => getPrice(token.ca, token.poolId)));
    results.forEach(res => {
        if (res.error) {
            console.log(`Error for CA: ${res.ca}, Pool: ${res.poolId}: ${res.error}`);
        } else {
            console.log(`Token: ${res.ca}, Pool: ${res.poolId}`);
            console.log(res);
            console.log('-------------------------');
        }
    });
}

getPricesForAllTokens();

Pythong

import requests
import asyncio
import aiohttp
import json

x_api_key = ""

# Add your token addresses and pool IDs here
tokens = [
    {
        "ca": "",
        "poolId": ""
    },
]

async def get_price(session, ca, pool_id):
    try:
        url = f"https://api.coinvera.io/api/v1/price?x-api-key={x_api_key}&ca={ca}&poolId={pool_id}"
        async with session.get(url) as response:
            data = await response.json()
            return {"ca": ca, "poolId": pool_id, **data}
    except Exception as err:
        return {"ca": ca, "poolId": pool_id, "error": str(err)}

async def get_prices_for_all_tokens():
    async with aiohttp.ClientSession() as session:
        tasks = [get_price(session, token["ca"], token["poolId"]) for token in tokens]
        results = await asyncio.gather(*tasks)
        
        for res in results:
            if "error" in res:
                print(f"Error for CA: {res['ca']}, Pool: {res['poolId']}: {res['error']}")
            else:
                print(f"Token: {res['ca']}, Pool: {res['poolId']}")
                print(json.dumps(res, indent=2))
                print("-------------------------")

# Run the async function
asyncio.run(get_prices_for_all_tokens())

Go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"sync"
)

const xAPIKey = ""

type Token struct {
	CA     string `json:"ca"`
	PoolID string `json:"poolId"`
}

type PriceResult struct {
	CA     string      `json:"ca"`
	PoolID string      `json:"poolId"`
	Data   interface{} `json:"data,omitempty"`
	Error  string      `json:"error,omitempty"`
}

var tokens = []Token{
	{
		CA:     "",
		PoolID: "",
	},
}

func getPrice(token Token, wg *sync.WaitGroup, results chan<- PriceResult) {
	defer wg.Done()

	url := fmt.Sprintf("https://api.coinvera.io/api/v1/price?x-api-key=%s&ca=%s&poolId=%s", 
		xAPIKey, token.CA, token.PoolID)

	resp, err := http.Get(url)
	if err != nil {
		results <- PriceResult{
			CA:     token.CA,
			PoolID: token.PoolID,
			Error:  err.Error(),
		}
		return
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		results <- PriceResult{
			CA:     token.CA,
			PoolID: token.PoolID,
			Error:  err.Error(),
		}
		return
	}

	var data interface{}
	if err := json.Unmarshal(body, &data); err != nil {
		results <- PriceResult{
			CA:     token.CA,
			PoolID: token.PoolID,
			Error:  err.Error(),
		}
		return
	}

	results <- PriceResult{
		CA:     token.CA,
		PoolID: token.PoolID,
		Data:   data,
	}
}

func getPricesForAllTokens() {
	var wg sync.WaitGroup
	results := make(chan PriceResult, len(tokens))

	for _, token := range tokens {
		wg.Add(1)
		go getPrice(token, &wg, results)
	}

	go func() {
		wg.Wait()
		close(results)
	}()

	for result := range results {
		if result.Error != "" {
			fmt.Printf("Error for CA: %s, Pool: %s: %s\n", result.CA, result.PoolID, result.Error)
		} else {
			fmt.Printf("Token: %s, Pool: %s\n", result.CA, result.PoolID)
			jsonData, _ := json.MarshalIndent(result.Data, "", "  ")
			fmt.Println(string(jsonData))
			fmt.Println("-------------------------")
		}
	}
}

func main() {
	getPricesForAllTokens()
}

Example Response

{
  ca: '53JxiSEdahWu8FXnkeUbpoS2o2wXumc8ThzviBX7pump',
  poolId: '24hgLhdNLgPmJeUNAQMHJEBdbuZRBknRuaP1trTiBkD4',
  dex: 'pumpfun amm',
  liquidity: '33810.474998006444',
  priceInSol: '0.0000006679153339642684',
  priceInUsd: '0.00010054593656529703'
}

---

Tip: Omitting poolId will trigger auto-detection across all pools for that token. Specify poolId when you need data from one exact pool.