# Get Price By Pool

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**

{% tabs %}
{% tab title="Nodejs" %}

```javascript
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();
```

{% endtab %}

{% tab title="Pythong" %}

```python
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())
```

{% endtab %}

{% tab title="Go" %}

```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()
}
```

{% endtab %}
{% endtabs %}

**Example Response**

```json
{
  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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.coinvera.io/integration/solana/get-price-by-pool.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.