Telegram MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation2/5
Multiple tools have overlapping purposes that could cause confusion. For example, 'scrape_channel', 'scrape_channel_authenticated', and 'scrape_channel_full' all scrape channels with slight variations in authentication or output format, while 'api_scrape_channel' and 'scrape_channel' seem to do similar things via different methods. The 'get_channel_info' and 'api_get_channel_info' tools also appear redundant, differing mainly in authentication approach.
Naming Consistency3/5
The naming is mixed but somewhat readable. There are two main patterns: 'api_' prefix for API-based tools (e.g., 'api_get_channel_info') and no prefix for session-based tools (e.g., 'scrape_channel'), but this is inconsistently applied (e.g., 'telegram_api_login' vs. 'telegram_login'). Verbs like 'scrape', 'get', and 'login' are used repeatedly, but the lack of a uniform structure (e.g., mixing prefixes and suffixes) reduces clarity.
Tool Count3/5
With 15 tools, the count is borderline high for a Telegram-focused server, but not excessive. The domain involves channel/group scraping and authentication, which could justify multiple tools, but the overlap suggests redundancy rather than necessity. It feels heavy due to the duplication, but the scope is broad enough to warrant a moderate number of tools.
Completeness4/5
The tool set covers core Telegram operations well: authentication (login, logout, status), channel/group info retrieval, and scraping with various modes (e.g., date range, manual, full). However, there are minor gaps, such as no tools for sending messages, managing chats, or handling media beyond scraping, which might limit some agent workflows but are not critical for the scraping-focused purpose.
Average 3.3/5 across 15 of 15 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'using the API' but doesn't specify if this is a read-only operation, requires authentication, has rate limits, or what 'detailed information' entails. This leaves key behavioral traits undefined for an API-based tool.
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 directly states the tool's function. It is appropriately sized and front-loaded with the core purpose, though it could be slightly more structured by including key details like authentication needs.
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 complexity of interacting with a Telegram API and the lack of annotations and output schema, the description is incomplete. It doesn't cover authentication requirements, error handling, or the format of returned information, which are crucial for effective tool use in this context.
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?
The input schema has 100% description coverage, with the 'url' parameter clearly documented. The description adds no additional meaning beyond the schema, such as URL format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.
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 action ('Get detailed information') and resource ('about a Telegram channel'), making the purpose understandable. However, it doesn't distinguish this tool from sibling tools like 'get_channel_info' or 'api_scrape_channel', which appear to have similar functions, so it lacks sibling differentiation.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools related to Telegram channels (e.g., 'api_scrape_channel', 'scrape_channel', 'get_channel_info'), there is no indication of context, prerequisites, or exclusions, leaving usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'fast and efficient' as a behavioral trait, but doesn't disclose critical information like authentication requirements, rate limits, data format returned, error handling, or whether this is a read-only operation. For a scraping tool with no annotation coverage, this leaves significant behavioral gaps.
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?
The description is extremely concise - a single sentence that efficiently communicates the core functionality. Every word earns its place: 'scrape' (action), 'Telegram channel' (resource), 'using the API' (method), and 'fast and efficient' (performance characteristic).
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?
For a scraping tool with no annotations and no output schema, the description is insufficient. It doesn't explain what data is returned, authentication requirements, rate limits, or how it differs from sibling scraping tools. Given the complexity of web scraping operations and the lack of structured metadata, the description should provide more complete context.
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 all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema. With complete schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't need to.
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 action ('scrape') and resource ('Telegram channel'), and specifies the method ('using the API') with performance characteristics ('fast and efficient'). However, it doesn't explicitly differentiate from sibling tools like 'scrape_channel', 'scrape_channel_authenticated', or 'scrape_channel_full', which appear to offer similar functionality.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for scraping channels (e.g., 'scrape_channel', 'scrape_channel_authenticated', 'scrape_channel_full'), there's no indication of what makes this API-based approach preferable or when other methods might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While it indicates a search operation, it doesn't describe important behavioral aspects such as authentication requirements, rate limits, error handling, pagination, or what the search results look like. For a tool with no annotation coverage, this leaves significant gaps in understanding how it behaves.
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?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a straightforward search tool and front-loads the key information, making it easy to understand at a glance.
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 lack of annotations and output schema, the description is insufficiently complete. It doesn't address authentication needs, result format, error conditions, or how it differs from similar sibling tools. For a search operation in a context with multiple channel-related tools, more contextual information would be needed for effective use.
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?
The input schema has 100% description coverage, with clear documentation for all three parameters (url, query, limit). The description doesn't add any meaningful semantic context beyond what's already in the schema, such as URL format examples, query syntax, or practical usage tips. With high schema coverage, the baseline score of 3 is appropriate.
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 as 'Search for messages within a Telegram channel', which includes a specific verb ('Search') and resource ('messages within a Telegram channel'). However, it doesn't explicitly differentiate from sibling tools like 'scrape_channel' or 'scrape_date_range', which might have overlapping functionality for retrieving channel content.
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?
The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools like 'scrape_channel', 'scrape_channel_full', and 'scrape_date_range' that might retrieve channel content, there's no indication of when this search-specific tool is preferred or what its limitations are compared to others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'fast, efficient scraping' which hints at performance characteristics, but doesn't describe what the login actually does (e.g., establishes a session, returns authentication tokens, handles 2FA), what happens on failure, rate limits, or security implications. For a login tool with zero annotation coverage, this is insufficient.
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 communicates the core purpose. It's appropriately sized for a login tool, though it could be slightly more front-loaded by moving the purpose ('for fast, efficient scraping') to a separate sentence for better structure.
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?
For a login tool with no annotations and no output schema, the description is incomplete. It doesn't explain what successful login returns (e.g., session token, status), what authentication method is used, error handling, or how the login state integrates with other tools. Given the complexity of authentication and the lack of structured data, more context is needed.
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 schema already fully documents both parameters (api_id and api_hash). The description doesn't add any parameter-specific information beyond what's in the schema. The baseline of 3 is appropriate when the schema does all the parameter documentation work.
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 action ('Login to Telegram') and the method ('using API credentials'), and mentions the purpose ('for fast, efficient scraping'). It distinguishes from sibling 'telegram_login' by specifying the API method, but doesn't fully differentiate from all authentication-related siblings like 'telegram_auth_status' in terms of when to use each.
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?
The description provides no guidance on when to use this tool versus alternatives like 'telegram_login' or 'scrape_channel_authenticated'. It mentions the purpose ('for fast, efficient scraping') but doesn't specify prerequisites, timing, or exclusions for this login method compared to others available.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool authenticates to access restricted content, implying a write/mutation operation that may require user credentials or permissions, but it doesn't detail what authentication entails (e.g., OTP, password), potential side effects (e.g., session creation), rate limits, or error handling. This is a significant gap for an authentication tool with zero annotation coverage.
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?
The description is a single, efficient sentence that front-loads the core purpose ('Authenticate with Telegram Web') and adds the outcome ('to access restricted content'). There is no wasted verbiage or redundancy, making it highly concise and well-structured for quick understanding.
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 complexity of an authentication tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., what happens on success/failure, session management), usage context relative to siblings, and return values. While concise, it fails to provide sufficient context for safe and effective tool invocation by an agent.
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%, with the single parameter 'phone_number' documented as optional and in international format. The description adds no additional parameter semantics beyond what the schema provides, such as explaining when to provide the phone number or how it affects authentication. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
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 action ('Authenticate') and target ('Telegram Web'), with the purpose being to 'access restricted content'. It distinguishes from siblings like 'telegram_auth_status' (check status) and 'telegram_logout' (end session), though it doesn't explicitly name alternatives. However, it doesn't fully differentiate from 'telegram_api_login', which might serve a similar authentication purpose.
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?
The description provides no guidance on when to use this tool versus alternatives like 'telegram_api_login' or 'telegram_auth_status'. It mentions accessing restricted content, but doesn't specify prerequisites (e.g., whether prior login is needed) or exclusions (e.g., when not to use it if already authenticated). This leaves the agent with minimal context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'Clear Telegram authentication cookies' implies a destructive action that removes authentication state, but it doesn't disclose behavioral traits such as whether this logs the user out of all sessions, if it's reversible, what happens on failure, or if it requires specific permissions. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.
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?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and target, making it immediately understandable. Every word earns its place, and there's no unnecessary elaboration.
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's complexity (a mutation operation with no annotations and no output schema), the description is incomplete. It lacks details on what 'clear' means behaviorally (e.g., does it invalidate sessions, is it idempotent), what the expected outcome is, or any error conditions. For a tool that modifies authentication state, more context is needed to guide safe usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (since there are no parameters to describe). The description doesn't need to add parameter semantics, so a baseline of 4 is appropriate. It implicitly confirms no inputs are required, which aligns with the empty schema.
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 'Clear Telegram authentication cookies' clearly states the action (clear) and target (Telegram authentication cookies). It distinguishes from siblings like 'telegram_login' (establish authentication) and 'telegram_auth_status' (check authentication), though it doesn't explicitly mention these alternatives. The purpose is specific but could be slightly more precise about what 'clear' entails.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., must be logged in first), consequences (e.g., will log you out), or when it's appropriate (e.g., to reset authentication state). With siblings like 'api_logout' and 'telegram_login', explicit usage context is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'Disconnect' implies a state change, it doesn't specify whether this is reversible, what authentication is required, what side effects occur (e.g., session termination), or what happens on success/failure. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
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?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the essential action and resource, making it immediately understandable without any unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description provides the basic purpose but lacks important context. It doesn't explain what 'disconnect' entails operationally, what state changes occur, or what verification might be needed. Given the complexity (simple action) but absence of annotations, this is minimally adequate but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema description coverage is 100%, so there are no parameters to document. The description appropriately doesn't discuss parameters, earning a baseline score of 4 for this dimension since no parameter information is needed.
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 'Disconnect from Telegram API' clearly states the action (disconnect) and target resource (Telegram API), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'telegram_logout', but the verb+resource combination is specific enough for basic understanding.
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 is provided about when to use this tool versus alternatives like 'telegram_logout'. The description states what it does but offers no context about prerequisites (e.g., must be logged in first), timing considerations, or comparisons with similar tools in the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral context. It mentions authentication for accessing restricted content, which is useful, but lacks details on rate limits, pagination, error handling, or what 'scrape' entails (e.g., returns posts, metadata). For a tool with potential complexity (authentication, scraping), this is insufficient.
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?
The description is a single, efficient sentence that front-loads key information (action, target, authentication). There is no wasted verbiage, and it directly addresses the tool's core purpose without unnecessary details.
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's complexity (involving authentication and scraping), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., posts, errors), authentication requirements, or how it differs from similar tools. More context is needed for effective use.
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 schema fully documents both parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples beyond the schema's URL example, no clarification on 'max_posts' behavior). Baseline 3 is appropriate as the schema does the heavy lifting.
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 action ('scrape') and target ('Telegram channel') with the specific condition 'using authenticated session'. It distinguishes from the sibling 'scrape_channel' by mentioning authentication, but doesn't explicitly differentiate from other authenticated scraping tools like 'scrape_channel_full' or 'scrape_group'.
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 implies when to use this tool ('can access restricted content'), suggesting it's for channels requiring authentication. However, it doesn't provide explicit guidance on when to choose this over alternatives like 'scrape_channel' (unauthenticated) or 'scrape_channel_full', nor does it mention prerequisites like needing to be logged in first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions 'Opens browser' and 'login,' hinting at interactive behavior, but doesn't disclose critical traits like whether it's read-only, destructive, requires user input during runtime, rate limits, or error handling. For a tool with manual interaction and scraping, this leaves significant behavioral gaps.
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?
The description is a single, efficient sentence: 'Manual scraping mode: Opens browser for you to login and navigate to any channel, then scrapes it.' It's front-loaded with the key concept ('Manual scraping mode') and wastes no words, making it highly concise and well-structured.
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 complexity of a manual scraping tool with browser interaction and no annotations or output schema, the description is incomplete. It doesn't explain what 'scrapes' entails (e.g., data types returned, success/failure states), prerequisites, or behavioral details. This leaves the agent with insufficient information for reliable tool invocation.
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 schema already documents both parameters ('limit' and 'save_to_file') with clear descriptions. The tool description adds no parameter-specific information beyond what's in the schema, such as default values or usage context. Baseline 3 is appropriate as the schema handles the heavy lifting.
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: 'Opens browser for you to login and navigate to any channel, then scrapes it.' It specifies the verb ('scrapes') and resource ('any channel'), and distinguishes itself from siblings like 'api_scrape_channel' by emphasizing manual browser interaction. However, it doesn't explicitly differentiate from 'scrape_channel_authenticated' or 'scrape_channel_full' in terms of scope or depth.
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 implies usage context by mentioning 'Opens browser for you to login,' suggesting it's for manual authentication scenarios. It doesn't provide explicit when-to-use vs. when-not-to-use guidance or name alternatives like 'api_scrape_channel' for automated cases. The context is clear but lacks detailed exclusions or comparative advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Check') but does not reveal any behavioral traits, such as whether it requires network calls, returns a boolean or detailed status, has rate limits, or handles errors. This leaves significant gaps for a tool that interacts with an external service like Telegram.
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?
The description is a single, clear sentence with zero waste, front-loading the core purpose ('Check if authenticated with Telegram'). It is appropriately sized for a simple tool and earns its place by directly stating the action without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally complete but lacks depth. It covers the basic purpose but does not address behavioral aspects like return values or error handling, which are important for an authentication status check. With no output schema, the description should ideally hint at what is returned, but it does not, leaving room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add parameter details, which is appropriate, but it could have mentioned any implicit inputs (e.g., session context), though not required. Baseline is 4 as it adequately handles the lack of parameters without introducing confusion.
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 'Check if authenticated with Telegram' clearly states the verb ('Check') and resource ('authenticated with Telegram'), making the purpose specific and understandable. However, it does not explicitly differentiate from sibling tools like 'telegram_api_login' or 'telegram_logout', which handle authentication actions rather than status checking, so it lacks sibling differentiation for a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives, such as before performing authenticated operations like 'scrape_channel_authenticated' or after login attempts. It implies usage for checking authentication status but offers no explicit context, exclusions, or named alternatives, leaving the agent to infer based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions authentication dependency ('uses authenticated session if logged in'), which adds some context, but it lacks details on what 'scrape' entails (e.g., rate limits, data format, pagination, or potential side effects). For a scraping tool with no annotations, this leaves significant gaps in understanding its behavior.
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?
The description is two sentences, front-loaded with the core purpose and followed by an authentication note. Every sentence earns its place by providing essential information without redundancy or fluff. It's appropriately sized and well-structured for clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (scraping with date filtering), no annotations, and no output schema, the description is moderately complete. It covers the purpose and authentication context but lacks details on return values, error handling, or behavioral nuances. It's adequate as a minimum viable description but has clear gaps in providing a full operational picture.
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 schema already documents all parameters (url, date_from, date_to) with clear descriptions. The description doesn't add any meaning beyond what the schema provides, such as explaining parameter interactions or constraints. Baseline score of 3 is appropriate since the schema does the heavy lifting.
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 action ('scrape posts') and scope ('within a specific date range'), which is specific and actionable. It distinguishes from siblings like 'scrape_channel' or 'scrape_channel_full' by emphasizing the date-range filtering, though it doesn't explicitly name alternatives. The purpose is not vague or tautological.
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 implies usage context by mentioning 'uses authenticated session if logged in,' which suggests when authentication might be beneficial. However, it doesn't explicitly state when to use this tool versus alternatives like 'scrape_channel' or 'scrape_channel_authenticated,' nor does it provide exclusions or clear prerequisites. The guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It adds useful context about authentication ('Uses authenticated session if logged in'), which is a behavioral trait not in the schema. However, it doesn't disclose other potential behaviors like rate limits, error handling, or response format, leaving gaps.
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?
The description is very concise with two sentences that are front-loaded and waste no words. Each sentence adds value: the first defines the tool's purpose and scope, and the second clarifies authentication behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (single parameter, no output schema, no annotations), the description is moderately complete. It covers purpose and authentication but lacks details on output format, error cases, or how it differs from similar tools like 'api_get_channel_info,' which could be important for an agent.
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?
The schema description coverage is 100%, so the schema already documents the 'url' parameter fully. The description does not add any additional meaning or context about the parameter beyond what the schema provides, such as URL format examples or constraints.
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 action ('Get') and resource ('channel/group information'), specifying it excludes post scraping. It distinguishes from siblings like 'scrape_channel' by emphasizing the limited scope, though it doesn't explicitly name alternatives.
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 implies usage by stating 'without scraping posts,' suggesting this tool is for metadata retrieval rather than content extraction. However, it lacks explicit guidance on when to use this versus alternatives like 'api_get_channel_info' or other scraping tools, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions authentication behavior ('Uses authenticated session if logged in') and output format ('return posts in markdown format'), but lacks details on rate limits, error handling, or what happens if scraping fails, which are important for a scraping operation.
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?
The description is front-loaded with the core purpose in the first sentence and adds a useful behavioral note in the second. Both sentences earn their place by providing essential information without redundancy, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a scraping tool with no annotations and no output schema, the description covers the basic purpose and authentication context but lacks details on return values (beyond format), potential side effects, or error conditions. It is minimally adequate but has clear gaps in 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 schema fully documents all parameters. The description does not add any additional meaning beyond the schema, such as explaining how 'max_posts' interacts with pagination or the implications of 'include_reactions,' resulting in a baseline score of 3.
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?
The description clearly states the specific action ('scrape'), target resource ('Telegram channel'), and output format ('posts in markdown format'), distinguishing it from siblings like 'scrape_group' or 'get_channel_info' by specifying content extraction rather than metadata retrieval.
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 implies usage context with 'Uses authenticated session if logged in,' suggesting it can work with or without authentication, but it does not explicitly state when to use this tool versus alternatives like 'scrape_channel_authenticated' or 'scrape_channel_full,' leaving the distinction unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the authentication behavior and output format, but lacks details on rate limits, error handling, or what happens if not logged in. It adequately covers basic behavior but misses deeper operational context.
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?
The description is a single, efficient sentence with zero wasted words—it states the action, target, output, and authentication context directly, making it front-loaded and appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (scraping with authentication), no annotations, and no output schema, the description is minimally complete. It covers purpose and basic behavior but lacks details on output structure, errors, or performance limits, leaving gaps for an agent.
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 schema already fully documents both parameters. The description adds no additional parameter semantics beyond what the schema provides, meeting the baseline for high coverage.
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?
The description clearly states the specific action ('scrape'), target resource ('Telegram group'), and output format ('posts in markdown format'), distinguishing it from sibling tools like 'scrape_channel' or 'scrape_channel_authenticated' by specifying group scraping rather than channel scraping.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use it ('scrape a Telegram group') and mentions authentication behavior ('uses authenticated session if logged in'), but does not explicitly state when not to use it or name alternatives among the many sibling scraping tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and discloses key behavioral traits: it performs data extraction (scraping), saves to files (implied mutation/write operation), and mentions authentication dependency. However, it lacks details on rate limits, error handling, or file formats beyond 'MD and JSON'.
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?
The description is front-loaded with the core purpose in the first sentence, followed by authentication and return details in two additional concise sentences, with zero wasted words—every sentence earns its place efficiently.
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 (scraping and file saving) and lack of annotations or output schema, the description is mostly complete: it covers purpose, authentication, and output location. However, it could improve by detailing file paths, error cases, or performance constraints for full contextual understanding.
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 schema already documents both parameters fully. The description adds no additional meaning beyond what the schema provides, such as explaining URL format nuances or file-saving implications, meeting the baseline for high coverage.
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?
The description clearly states the specific action ('scrape ALL posts'), target resource ('from a Telegram channel'), and outcome ('save to file'), distinguishing it from siblings like 'scrape_channel' or 'scrape_date_range' by emphasizing comprehensive scraping and file saving.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context for usage by mentioning authentication ('Uses authenticated session if logged in'), but does not explicitly state when to use this tool versus alternatives like 'scrape_channel' or 'scrape_channel_authenticated', leaving some ambiguity in sibling differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![telegram-mcp-server MCP server](https://glama.ai/mcp/servers/DLHellMe/telegram-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/DLHellMe/telegram-mcp-server)

Score Badge

Copy to your README.md:

[![telegram-mcp-server MCP server](https://glama.ai/mcp/servers/DLHellMe/telegram-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/DLHellMe/telegram-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/DLHellMe/telegram-mcp-server'

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