Skip to main content
Glama
IAcomunIA

CoinGecko MCP Server

by IAcomunIA

get_pools_onchain_trending_search

Read-only

Query trending cryptocurrency liquidity pools across all networks on GeckoTerminal to identify popular trading pairs and market movements.

Instructions

When using this tool, always use the jq_filter parameter to reduce the response size and improve performance.

Only omit if you're sure you don't need the data.

This endpoint allows you to query all the trending search pools across all networks on GeckoTerminal

Response Schema

{
  $ref: '#/$defs/trending_search_get_response',
  $defs: {
    trending_search_get_response: {
      type: 'object',
      properties: {
        data: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: {
                type: 'string'
              },
              attributes: {
                type: 'object',
                properties: {
                  address: {
                    type: 'string'
                  },
                  fdv_usd: {
                    type: 'string'
                  },
                  market_cap_usd: {
                    type: 'string'
                  },
                  name: {
                    type: 'string'
                  },
                  pool_created_at: {
                    type: 'string'
                  },
                  reserve_in_usd: {
                    type: 'string'
                  },
                  trending_rank: {
                    type: 'number'
                  },
                  volume_usd: {
                    type: 'object',
                    properties: {
                      h24: {
                        type: 'string'
                      }
                    }
                  }
                }
              },
              relationships: {
                type: 'object',
                properties: {
                  base_token: {
                    type: 'object',
                    properties: {
                      data: {
                        type: 'object',
                        properties: {
                          id: {
                            type: 'string'
                          },
                          type: {
                            type: 'string'
                          }
                        }
                      }
                    }
                  },
                  dex: {
                    type: 'object',
                    properties: {
                      data: {
                        type: 'object',
                        properties: {
                          id: {
                            type: 'string'
                          },
                          type: {
                            type: 'string'
                          }
                        }
                      }
                    }
                  },
                  network: {
                    type: 'object',
                    properties: {
                      data: {
                        type: 'object',
                        properties: {
                          id: {
                            type: 'string'
                          },
                          type: {
                            type: 'string'
                          }
                        }
                      }
                    }
                  },
                  quote_token: {
                    type: 'object',
                    properties: {
                      data: {
                        type: 'object',
                        properties: {
                          id: {
                            type: 'string'
                          },
                          type: {
                            type: 'string'
                          }
                        }
                      }
                    }
                  }
                }
              },
              type: {
                type: 'string'
              }
            }
          }
        },
        included: {
          type: 'array',
          items: {
            type: 'object',
            properties: {
              id: {
                type: 'string'
              },
              attributes: {
                type: 'object',
                properties: {
                  address: {
                    type: 'string'
                  },
                  coingecko_coin_id: {
                    type: 'string'
                  },
                  decimals: {
                    type: 'integer'
                  },
                  image_url: {
                    type: 'string'
                  },
                  name: {
                    type: 'string'
                  },
                  symbol: {
                    type: 'string'
                  }
                }
              },
              type: {
                type: 'string'
              }
            }
          }
        }
      }
    }
  }
}

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
includeNoattributes to include, comma-separated if more than one to include Available values: `base_token`, `quote_token`, `dex`, `network`
poolsNonumber of pools to return, maximum 10 Default value: 4
jq_filterNoA jq filter to apply to the response to include certain fields. Consult the output schema in the tool description to see the fields that are available. For example: to include only the `name` field in every object of a results array, you can provide ".results[].name". For more information, see the [jq documentation](https://jqlang.org/manual/).
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by mentioning performance considerations with 'jq_filter' and specifying the scope ('all networks'), which are useful behavioral traits not covered by annotations. However, it doesn't disclose other potential behaviors like rate limits, error handling, or data freshness, keeping it at an adequate but not comprehensive level.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is relatively concise with two main sentences, but it includes a large, embedded JSON output schema that disrupts flow and isn't part of the descriptive text. The first part is front-loaded with usage advice, but the schema inclusion adds unnecessary bulk, reducing overall efficiency. It could be more streamlined by referencing the schema separately.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (querying trending pools across networks) and the presence of annotations (readOnlyHint) and a detailed input schema, the description is mostly complete. It explains the purpose and offers performance tips. However, it lacks an output schema (the embedded JSON is in the description but not structured as an output schema field), so the agent must infer return values from the text, slightly reducing completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the input schema fully documents the three parameters ('include', 'pools', 'jq_filter'). The description doesn't add any parameter-specific semantics beyond what's in the schema, such as explaining 'include' options in more detail or giving examples for 'pools'. Thus, it meets the baseline for high schema coverage without extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'query all the trending search pools across all networks on GeckoTerminal'. It specifies the verb ('query') and resource ('trending search pools'), making it understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_search_trending' or 'get_pools_onchain_megafilter', which might offer similar functionality, so it doesn't reach the highest score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides some usage guidance by recommending the use of 'jq_filter' to reduce response size and improve performance, with a note to omit it only if unnecessary. This implies a context for performance optimization. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., compared to 'get_search_trending' or other pool-related tools), leaving the agent to infer usage from the purpose alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/IAcomunIA/MCP_firts'

If you have feedback or need assistance with the MCP directory API, please join our Discord server