Skip to main content
Glama

getCryptoMetadata

Retrieve static metadata for cryptocurrencies, including logos, descriptions, and official website URLs.

Instructions

Returns all static metadata for one or more cryptocurrencies including logo, description, and website URLs.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
symbolNo
idNo
slugNo
addressNo
auxNo
skip_invalidNo

Implementation Reference

  • index.js:183-206 (registration)
    Registration of the 'getCryptoMetadata' MCP tool on the server via server.tool(). Defines name, description, schema, and handler.
    server.tool("getCryptoMetadata",
      "Returns all static metadata for one or more cryptocurrencies including logo, description, and website URLs.",
      {
        symbol: z.string().optional(),
        id: z.string().optional(),
        slug: z.string().optional(),
        address: z.string().optional(),
        aux: z.string().optional(),
        skip_invalid: z.boolean().optional()
      },
      async ({ symbol, id, slug, address, aux, skip_invalid }) => {
        return handleEndpoint(async () => {
          const data = await makeApiRequest(apiKey, '/v2/cryptocurrency/info', {
            symbol,
            id,
            slug,
            address,
            aux,
            skip_invalid
          })
          return formatResponse(data)
        })
      }
    )
  • Handler function for getCryptoMetadata. Calls the CoinMarketCap /v2/cryptocurrency/info API with optional parameters and formats the response.
    async ({ symbol, id, slug, address, aux, skip_invalid }) => {
      return handleEndpoint(async () => {
        const data = await makeApiRequest(apiKey, '/v2/cryptocurrency/info', {
          symbol,
          id,
          slug,
          address,
          aux,
          skip_invalid
        })
        return formatResponse(data)
      })
    }
  • Zod schema defining input validation for getCryptoMetadata: symbol, id, slug, address, aux (all optional strings) and skip_invalid (optional boolean).
    {
      symbol: z.string().optional(),
      id: z.string().optional(),
      slug: z.string().optional(),
      address: z.string().optional(),
      aux: z.string().optional(),
      skip_invalid: z.boolean().optional()
    },
  • Generic wrapper that executes the API call and formats errors. Used by the getCryptoMetadata handler.
    async function handleEndpoint(apiCall) {
      try {
        return await apiCall()
      } catch (error) {
        return formatErrorResponse(error.message, error.status || 403)
      }
    }
  • Formats API response data into the MCP text content format. Used by the getCryptoMetadata handler.
    // Helper function to format successful API responses
    function formatResponse(data) {
      return {
        content: [{
          type: "text",
          text: JSON.stringify(data)
        }]
      }
    }
Behavior2/5

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

No annotations are provided, so the description must fully disclose behavioral traits. It only implies read-only access by stating 'static metadata', but does not mention rate limits, authentication, or how multiple symbols are handled. Insufficient for a tool with no annotation support.

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

Conciseness4/5

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

The description is a single efficient sentence that is front-loaded. It contains no wasted words, though it could benefit from additional detail without being verbose.

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

Completeness2/5

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

Given the tool has 6 parameters, no output schema, and no annotations, the description is too sparse. It does not explain return format, parameter usage, or behavioral nuances, making it incomplete for an agent to use effectively.

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

Parameters1/5

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

Schema description coverage is 0%, meaning the description adds no information about the six parameters (symbol, id, slug, address, aux, skip_invalid). The description fails to compensate for this gap, leaving their semantics entirely unclear.

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 it returns static metadata including logo, description, and URLs. The verb 'returns' and resource 'static metadata for one or more cryptocurrencies' are specific. However, it doesn't differentiate from sibling tools like cryptoCurrencyMap which also return metadata-like information.

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

Usage Guidelines2/5

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

No guidance on when to use this tool versus alternatives (e.g., cryptoCurrencyMap, cryptoQuotesLatest). No context about prerequisites or exclusions, leaving the agent to guess.

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/shinzo-labs/coinmarketcap-mcp'

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