Skip to main content
Glama

Holder Changes

holder_changes

Retrieve recent changes to token holder records since a given timestamp. Returns up to 100 results per query.

Instructions

Get recent changes to token holder data since a given timestamp. Cost: $0.02 per query. Source: On-chain token analytics.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
sinceYesISO 8601 timestamp to get changes since (e.g. 2026-03-01T00:00:00Z)
limitNoMaximum results (default 50)

Implementation Reference

  • The async handler function for the 'holder_changes' tool. Calls the API endpoint /api/v1/holders/changes with 'since' and 'limit' parameters, formats the response text with count summary and JSON data.
    async ({ since, limit }) => {
      const res = await apiGet<HolderQueryResponse>("/api/v1/holders/changes", {
        since,
        limit: limit ?? 50,
      });
    
      if (!res.ok) {
        return {
          content: [
            {
              type: "text" as const,
              text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
            },
          ],
          isError: true,
        };
      }
    
      const { count, data } = res.data;
      const warn = stalenessWarning(res);
      const summary = `${warn}Found ${count} holder change(s) since ${since}.`;
      const json = JSON.stringify(data, null, 2);
    
      return {
        content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
      };
    },
  • Input schema for holder_changes: 'since' (ISO 8601 timestamp, required) and 'limit' (integer 1-100, optional, default 50).
    inputSchema: {
      since: z
        .string()
        .describe("ISO 8601 timestamp to get changes since (e.g. 2026-03-01T00:00:00Z)"),
      limit: z
        .number()
        .int()
        .min(1)
        .max(100)
        .optional()
        .describe("Maximum results (default 50)"),
    },
  • Registration call: server.registerTool('holder_changes', ...) with title 'Holder Changes' and description about cost ($0.02) and source (on-chain token analytics).
    server.registerTool(
      "holder_changes",
      {
        title: "Holder Changes",
        description:
          "Get recent changes to token holder data since a given timestamp. " +
          "Cost: $0.02 per query. Source: On-chain token analytics.",
        inputSchema: {
          since: z
            .string()
            .describe("ISO 8601 timestamp to get changes since (e.g. 2026-03-01T00:00:00Z)"),
          limit: z
            .number()
            .int()
            .min(1)
            .max(100)
            .optional()
            .describe("Maximum results (default 50)"),
        },
      },
      async ({ since, limit }) => {
        const res = await apiGet<HolderQueryResponse>("/api/v1/holders/changes", {
          since,
          limit: limit ?? 50,
        });
    
        if (!res.ok) {
          return {
            content: [
              {
                type: "text" as const,
                text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
              },
            ],
            isError: true,
          };
        }
    
        const { count, data } = res.data;
        const warn = stalenessWarning(res);
        const summary = `${warn}Found ${count} holder change(s) since ${since}.`;
        const json = JSON.stringify(data, null, 2);
    
        return {
          content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
        };
      },
    );
  • The export function registerHolderTools(server) which is called from index.ts to register all holder tools including holder_changes.
    export function registerHolderTools(server: McpServer): void {
      // ── Query top holders ─────────────────────────────────────────────────
    
      server.registerTool(
        "query_holders",
        {
          title: "Query Top Holders",
          description:
            "Get the top holders for a token contract address. Returns wallet addresses, " +
            "balances, percentage of supply, and holder labels (exchange, whale, contract). " +
            "Cost: $0.04 per query. Source: On-chain token analytics.",
          inputSchema: {
            token: z
              .string()
              .describe("Token contract address (e.g. 0xdAC17F958D2ee523a2206206994597C13D831ec7)"),
            chain: z
              .enum(["ethereum", "arbitrum", "polygon", "base", "bsc"])
              .optional()
              .describe("Blockchain network (default: ethereum)"),
            limit: z
              .number()
              .int()
              .min(1)
              .max(100)
              .optional()
              .describe("Maximum results (default 25)"),
          },
        },
        async ({ token, chain, limit }) => {
          const res = await apiGet<HolderQueryResponse>(
            `/api/v1/holders/${encodeURIComponent(token)}`,
            {
              chain,
              limit: limit ?? 25,
            },
          );
    
          if (!res.ok) {
            return {
              content: [
                {
                  type: "text" as const,
                  text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
                },
              ],
              isError: true,
            };
          }
    
          const { count, data } = res.data;
          const warn = stalenessWarning(res);
          const summary = `${warn}Found ${count} holder(s) for token ${token}.`;
          const json = JSON.stringify(data, null, 2);
    
          return {
            content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
          };
        },
      );
    
      // ── Holder concentration ──────────────────────────────────────────────
    
      server.registerTool(
        "holder_concentration",
        {
          title: "Holder Concentration",
          description:
            "Get Gini coefficient and distribution metrics for a token. Shows concentration " +
            "risk, top-10/top-50 holder percentages, and supply distribution buckets. " +
            "Cost: $0.02 per query. Source: On-chain token analytics.",
          inputSchema: {
            token: z
              .string()
              .describe("Token contract address"),
            chain: z
              .enum(["ethereum", "arbitrum", "polygon", "base", "bsc"])
              .optional()
              .describe("Blockchain network (default: ethereum)"),
          },
        },
        async ({ token, chain }) => {
          const res = await apiGet<{ dataset: string; data: Record<string, unknown> }>(
            `/api/v1/holders/${encodeURIComponent(token)}/concentration`,
            { chain },
          );
    
          if (!res.ok) {
            return {
              content: [
                {
                  type: "text" as const,
                  text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
                },
              ],
              isError: true,
            };
          }
    
          const warn = stalenessWarning(res);
          return {
            content: [
              { type: "text" as const, text: `${warn}${JSON.stringify(res.data.data, null, 2)}` },
            ],
          };
        },
      );
    
      // ── Change feed ───────────────────────────────────────────────────────
    
      server.registerTool(
        "holder_changes",
        {
          title: "Holder Changes",
          description:
            "Get recent changes to token holder data since a given timestamp. " +
            "Cost: $0.02 per query. Source: On-chain token analytics.",
          inputSchema: {
            since: z
              .string()
              .describe("ISO 8601 timestamp to get changes since (e.g. 2026-03-01T00:00:00Z)"),
            limit: z
              .number()
              .int()
              .min(1)
              .max(100)
              .optional()
              .describe("Maximum results (default 50)"),
          },
        },
        async ({ since, limit }) => {
          const res = await apiGet<HolderQueryResponse>("/api/v1/holders/changes", {
            since,
            limit: limit ?? 50,
          });
    
          if (!res.ok) {
            return {
              content: [
                {
                  type: "text" as const,
                  text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
                },
              ],
              isError: true,
            };
          }
    
          const { count, data } = res.data;
          const warn = stalenessWarning(res);
          const summary = `${warn}Found ${count} holder change(s) since ${since}.`;
          const json = JSON.stringify(data, null, 2);
    
          return {
            content: [{ type: "text" as const, text: `${summary}\n\n${json}` }],
          };
        },
      );
    
      // ── Dataset stats ─────────────────────────────────────────────────────
    
      server.registerTool(
        "holder_stats",
        {
          title: "Holder Dataset Statistics",
          description:
            "Get statistics about the token holder dataset: total tokens tracked, " +
            "total holder records, chains covered, last updated. Free endpoint.",
          inputSchema: {},
        },
        async () => {
          const res = await apiGet<HolderStatsResponse>("/api/v1/holders/stats");
    
          if (!res.ok) {
            return {
              content: [
                {
                  type: "text" as const,
                  text: `API error (${res.status}): ${JSON.stringify(res.data)}`,
                },
              ],
              isError: true,
            };
          }
    
          return {
            content: [
              { type: "text" as const, text: JSON.stringify(res.data, null, 2) },
            ],
          };
        },
      );
  • The apiGet helper function used by the holder_changes handler to make HTTP GET requests to the Verilex API.
    export async function apiGet<T = unknown>(
      path: string,
      params?: Record<string, string | number | undefined>,
    ): Promise<ApiResponse<T>> {
      const url = buildUrl(path, params);
    
      const headers: Record<string, string> = {
        Accept: "application/json",
        "User-Agent": "verilex-mcp-server/0.1.0",
      };
    
      // Forward x402 payment token if present in env (for paid endpoints)
      const paymentToken = process.env.VERILEX_PAYMENT_TOKEN;
      if (paymentToken) {
        headers["X-Payment-Token"] = paymentToken;
      }
    
      const res = await fetch(url, { headers });
      const data = (await res.json()) as T;
    
      const stale = res.headers.get("X-Data-Stale");
      const lastUpdated = res.headers.get("X-Data-Last-Updated");
      const ageSeconds = res.headers.get("X-Data-Age-Seconds");
    
      return {
        ok: res.ok,
        status: res.status,
        data,
        stale: stale === "true",
        lastUpdated: lastUpdated ?? undefined,
        ageSeconds: ageSeconds ? Number(ageSeconds) : undefined,
      };
    }
Behavior2/5

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

No annotations provided, so description must disclose behavior. It only says it's a paid query and from on-chain analytics, but does not mention rate limits, authentication, or any side effects. For a read operation, minimal disclosure.

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

Conciseness5/5

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

Two sentences, front-loaded with the action and resource. Cost and source are useful and succinctly stated. No unnecessary words.

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?

No output schema, so description should hint at the response format. It does not mention what fields are in a 'change' or how results are structured. Incomplete for a tool that returns data.

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 coverage is 100%, so the description does not need to add much. It adds no extra meaning beyond the schema, which already describes 'since' and 'limit' with formats and defaults. Baseline 3 is appropriate.

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

Purpose5/5

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

Description clearly states 'Get recent changes to token holder data' with a specific time constraint ('since a given timestamp'). Differentiates from siblings like holder_concentration and holder_stats which focus on snapshots or aggregates.

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?

Description implies usage (when you need recent holder changes) and mentions cost and source, but does not explicitly state when to avoid this tool or list alternatives. No comparison with sibling tools.

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/carrierone/verilexdata-mcp'

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