Get Token Price

Integrate seamlessly with CoinVera’s REST endpoints by authenticating with your x-api-key, either as a query parameter or in the request header.

Authentication

Query Parameter Append your API key to the URL:
```
?x-api-key=<YOUR_API_KEY>
```
HTTP Header Include the header in your request:
```
x-api-key: <YOUR_API_KEY>
```

Single-Token Price Requests

Replace <TOKEN_MINT> and <YOUR_API_KEY> with your token’s mint address and your CoinVera API key.

Endpoint

URL Example

Auto-Detect (Low-Latency)

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

PumpFun

GET https://api.coinvera.io/api/v1/pumpfun?ca=<TOKEN_MINT>&x-api-key=<YOUR_API_KEY>

Meteora

GET https://api.coinvera.io/api/v1/meteora?ca=<TOKEN_MINT>&x-api-key=<YOUR_API_KEY>

Raydium (All Pools)

GET https://api.coinvera.io/api/v1/raydium?ca=<TOKEN_MINT>&x-api-key=<YOUR_API_KEY>

Moonshot

GET https://api.coinvera.io/api/v1/moonshot?ca=<TOKEN_MINT>&x-api-key=<YOUR_API_KEY>

Using HTTP Headers

GET /api/v1/price?ca=<TOKEN_MINT> HTTP/1.1
Host: api.coinvera.io
x-api-key: <YOUR_API_KEY>

(Swap /price for /pumpfun, /raydium, etc., as needed.)

Multi-Token Price Requests

Fetch prices for multiple tokens in one call by passing a comma-separated list of mint addresses:

GET https://api.coinvera.io/api/v1/price?ca=<MINT1>,<MINT2>,<MINT3>&x-api-key=<YOUR_API_KEY>

Code Examples

Fetch a single token’s price per request—see the code examples below.

const fetch = require('node-fetch');

const x_api_key = "<YOUR-API-KEY>"; // <-- Replace with your actual API key

const tokenAddresses = [
    "<MINT-ADDRESS>"
];

async function getPrice(ca) {
    try {
        const url = `https://api.coinvera.io/api/v1/price?ca=${ca}`;
        const result = await fetch(url, {
            headers: {
                "Content-Type": "application/json",
                "x-api-key": x_api_key,
            }
        });
        const data = await result.json();
        return { ca, ...data };
    } catch (err) {
        return { ca, error: err.message };
    }
}

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

getPricesForAllTokens();

import requests

x_api_key = "<YOUR-API-KEY>"  # Replace with your actual API key

token_addresses = [
    "<MINT-ADDRESS>"
]

def get_price(ca):
    url = f"https://api.coinvera.io/api/v1/price?ca={ca}"
    headers = {
        "Content-Type": "application/json",
        "x-api-key": x_api_key
    }
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # raises HTTPError for bad responses
        data = response.json()
        return {'ca': ca, **data}
    except requests.exceptions.RequestException as err:
        return {'ca': ca, 'error': str(err)}

def get_prices_for_all_tokens():
    results = [get_price(ca) for ca in token_addresses]
    for res in results:
        if 'error' in res:
            print(f"Error for {res['ca']}: {res['error']}")
        else:
            print(f"Token: {res['ca']}")
            print(res)
            print('-------------------------')

if __name__ == "__main__":
    get_prices_for_all_tokens()

package main

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

const xAPIKey = "<YOUR-API-KEY>" // Replace with your actual API key

var tokenAddresses = []string{
    "<MINT-ADDRESS>",
}

type APIResponse struct {
    CA     string                 `json:"ca"`
    Data   map[string]interface{} `json:"data,omitempty"`
    Error  string                 `json:"error,omitempty"`
}

func getPrice(ca string) APIResponse {
    url := fmt.Sprintf("https://api.coinvera.io/api/v1/price?ca=%s", ca)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-api-key", xAPIKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    var data map[string]interface{}
    if err := json.Unmarshal(body, &data); err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    return APIResponse{CA: ca, Data: data}
}

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

    for _, ca := range tokenAddresses {
        wg.Add(1)
        go func(ca string) {
            defer wg.Done()
            results <- getPrice(ca)
        }(ca)
    }

    wg.Wait()
    close(results)

    for res := range results {
        if res.Error != "" {
            fmt.Printf("Error for %s: %s\n", res.CA, res.Error)
        } else {
            fmt.Printf("Token: %s\n", res.CA)
            fmt.Printf("%v\n", res.Data)
            fmt.Println("-------------------------")
        }
    }
}

func main() {
    getPricesForAllTokens()
}

Example Response

{
  ca: '',
  dex: '',
  priceInSol: ,
  priceInUsd: ,
  marketCap: 
}

Fetch multiple tokens’ prices in a single request—example below.

const fetch = require('node-fetch');

const x_api_key = ""; // <-- Replace with your actual API key

const tokenAddresses = [
    "mint-1",
    "mint-2"
];

async function getPrice(ca) {
    try {
        const url = `https://api.coinvera.io/api/v1/price?ca=${ca}`;
        const result = await fetch(url, {
            headers: {
                "Content-Type": "application/json",
                "x-api-key": x_api_key,
            }
        });
        const data = await result.json();
        return { ca, ...data };
    } catch (err) {
        return { ca, error: err.message };
    }
}

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

getPricesForAllTokens();

import requests

x_api_key = "<YOUR-API-KEY>"  # Replace with your actual API key

token_addresses = [
    "<MINT-ADDRESS-1>",
    "<MINT-ADDRESS-2>"
]

def get_price(ca):
    url = f"https://api.coinvera.io/api/v1/price?ca={ca}"
    headers = {
        "Content-Type": "application/json",
        "x-api-key": x_api_key
    }
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()  # raises HTTPError for bad responses
        data = response.json()
        return {'ca': ca, **data}
    except requests.exceptions.RequestException as err:
        return {'ca': ca, 'error': str(err)}

def get_prices_for_all_tokens():
    results = [get_price(ca) for ca in token_addresses]
    for res in results:
        if 'error' in res:
            print(f"Error for {res['ca']}: {res['error']}")
        else:
            print(f"Token: {res['ca']}")
            print(res)
            print('-------------------------')

if __name__ == "__main__":
    get_prices_for_all_tokens()

package main

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

const xAPIKey = "<YOUR-API-KEY>" // Replace with your actual API key

var tokenAddresses = []string{
    "<MINT-ADDRESS-1>",
    "<MINT-ADDRESS-2>"
}

type APIResponse struct {
    CA     string                 `json:"ca"`
    Data   map[string]interface{} `json:"data,omitempty"`
    Error  string                 `json:"error,omitempty"`
}

func getPrice(ca string) APIResponse {
    url := fmt.Sprintf("https://api.coinvera.io/api/v1/price?ca=%s", ca)

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("x-api-key", xAPIKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    var data map[string]interface{}
    if err := json.Unmarshal(body, &data); err != nil {
        return APIResponse{CA: ca, Error: err.Error()}
    }

    return APIResponse{CA: ca, Data: data}
}

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

    for _, ca := range tokenAddresses {
        wg.Add(1)
        go func(ca string) {
            defer wg.Done()
            results <- getPrice(ca)
        }(ca)
    }

    wg.Wait()
    close(results)

    for res := range results {
        if res.Error != "" {
            fmt.Printf("Error for %s: %s\n", res.CA, res.Error)
        } else {
            fmt.Printf("Token: %s\n", res.CA)
            fmt.Printf("%v\n", res.Data)
            fmt.Println("-------------------------")
        }
    }
}

func main() {
    getPricesForAllTokens()
}

Example Response

[
  {
    ca: '',
    dex: '',
    priceInSol: ,
    priceInUsd: ,
    marketCap: ,
    success: true
  },
  {
    ca: '',
    dex: '',
    priceInSol: ,
    priceInUsd: ,
    marketCap: ,
    success: true
  }
]

Tip: Experiment with different endpoints to find the lowest-latency feed for your use case. If you have questions, see our API Reference or reach out on our community channels.

PrevioussimulateTransaction NextGet Price By Pool

Last updated 8 months ago

hashtagAuthentication

hashtagSingle-Token Price Requests

hashtagMulti-Token Price Requests

Authentication

Single-Token Price Requests

Multi-Token Price Requests