mcp-tmobile
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-tmobilecheck my upgrade eligibility"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@striderlabs/mcp-tmobile
MCP (Model Context Protocol) server for T-Mobile telecom account management. Automates T-Mobile account interactions using Playwright browser automation via Browserbase.
Tools
Tool | Description |
| Get current plan, balance, and usage summary |
| Get detailed data/call/text usage breakdown |
| Initiate a one-time payment |
| View past bills and payment history |
| Check device upgrade eligibility for account lines |
Related MCP server: Playwright Plus Python MCP
Setup
Install
npm install @striderlabs/mcp-tmobileEnvironment Variables
# Required: T-Mobile credentials
export TMOBILE_USERNAME="your-email@example.com"
export TMOBILE_PASSWORD="your-password"
# Optional: Browserbase CDP URL for cloud browser automation
export BROWSERBASE_CDP_URL="wss://connect.browserbase.com?apiKey=your-key"If BROWSERBASE_CDP_URL is set, the server connects to a Browserbase cloud browser. Otherwise, a local Chromium instance is launched.
Credentials can also be passed directly as tool arguments instead of environment variables.
Usage with Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"tmobile": {
"command": "node",
"args": ["/path/to/node_modules/@striderlabs/mcp-tmobile/dist/index.js"],
"env": {
"TMOBILE_USERNAME": "your-email@example.com",
"TMOBILE_PASSWORD": "your-password",
"BROWSERBASE_CDP_URL": "wss://connect.browserbase.com?apiKey=your-key"
}
}
}
}Usage with MCP CLI
# Run directly
TMOBILE_USERNAME=user@example.com TMOBILE_PASSWORD=pass npx @striderlabs/mcp-tmobile
# With Browserbase
BROWSERBASE_CDP_URL=wss://... npx @striderlabs/mcp-tmobileTool Examples
Get Account Overview
{
"tool": "get_account_overview",
"arguments": {}
}Get Usage Details
{
"tool": "get_usage_details",
"arguments": {
"line": "+15551234567"
}
}Pay Bill
{
"tool": "pay_bill",
"arguments": {
"amount": 85.00
}
}Get Bill History
{
"tool": "get_bill_history",
"arguments": {
"months": 3
}
}Check Upgrade Eligibility
{
"tool": "check_upgrade_eligibility",
"arguments": {}
}Browser Automation
This server uses Playwright to automate the T-Mobile account portal (account.t-mobile.com). The browser session is reused across tool calls within the same server process — login happens once and the session persists.
Browserbase Integration
Connect via Browserbase for cloud-based browser automation:
export BROWSERBASE_CDP_URL="wss://connect.browserbase.com?apiKey=YOUR_API_KEY&enableProxy=true"The server connects using Playwright's chromium.connectOverCDP().
Security Notes
Credentials are never logged or stored beyond the current session
Use environment variables rather than passing credentials in tool arguments when possible
The
pay_billtool navigates to the payment page and returns details for review — it does not auto-confirm payments
Development
git clone <repo>
cd mcp-tmobile
npm install
npm run build
npm startAvailable Tools
5 toolscheck_upgrade_eligibilityB
Check T-Mobile device upgrade eligibility for lines on the account.
| Name | Required | Description | Default |
|---|---|---|---|
| line | No | Specific phone number/line to check (optional, checks all lines) | |
| password | No | T-Mobile password (optional if env var set) | |
| username | No | T-Mobile username/email (optional if env var set) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, but it only says 'Check' and does not disclose what the tool returns, whether it makes an external network call, whether authentication is required despite optional credentials, or whether any state changes occur.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler. It immediately communicates the verb, target, and scope, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-style tool with fully optional, documented parameters, the description is adequate but has gaps: no output schema and no mention of what the response looks like or what conditions might affect eligibility. It is serviceable but not rich enough for full autonomy in ambiguous situations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the parameters are already well documented in the input schema. The description adds the context that eligibility applies to 'lines on the account,' but it does not add meaning beyond the schema's parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Check') and a clear resource ('T-Mobile device upgrade eligibility for lines on the account'). It is distinct from the sibling tools, which cover overview, usage, payments, and billing, though it does not explicitly contrast itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use case is implied by the description: call this when upgrade eligibility is needed. However, there is no explicit guidance about when not to use it, prerequisites for authentication, or how it relates to the sibling account tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_account_overviewB
Get T-Mobile account overview including current plan, balance, and usage summary. Requires login credentials.
| Name | Required | Description | Default |
|---|---|---|---|
| password | No | T-Mobile password (optional if TMOBILE_PASSWORD env var is set) | |
| username | No | T-Mobile username/email (optional if TMOBILE_USERNAME env var is set) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the burden of behavioral disclosure. It states authentication is required ('Requires login credentials'), which is useful. However, it doesn't disclose side effects, read-only nature, external login redirect behavior, session handling, or errors with bad credentials.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence plus a short auth note, which is efficient and front-loads the main purpose. It earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-oriented overview tool with 2 simple params and no output schema, the description is reasonably adequate. Missing details: whether usage summary is current-month, whether return values include recent charges, and what happens if credentials are missing. Could be more complete given the auth-sensitive nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes both parameters well with 100% coverage. The description adds the requirement that they are login-related but doesn't clarify precedence if both username and env var are set, or format expectations beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as retrieving a T-Mobile account overview with plan, balance, and usage summary. The verb 'Get' plus the resource 'T-Mobile account overview' gives a specific purpose, though it doesn't explicitly distinguish it from get_usage_details, which could theoretically overlap.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is the account-level overview tool, and sibling tools like get_bill_history or get_usage_details exist for more specific data. However, there's no explicit 'when to use this vs. alternatives' guidance or exclusions stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_bill_historyB
View past T-Mobile bills and payment history.
| Name | Required | Description | Default |
|---|---|---|---|
| months | No | Number of months of history to retrieve (default: 6) | |
| password | No | T-Mobile password (optional if env var set) | |
| username | No | T-Mobile username/email (optional if env var set) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description alone must convey behavioral traits. 'View' signals a read-only operation, but the description does not disclose authentication requirements, that external T-Mobile credentials are used, login failure behavior, or any response/pagination characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler, repetition, or irrelevant detail. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description leaves the agent without information about the return value shape, pagination/volume, or the authentication flow implied by the username/password parameters. For a three-parameter tool that accesses an external T-Mobile account, this is a meaningful gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema describes all three parameters (months, username, password) at 100% coverage, so the description does not need to add parameter details. The tool description itself adds no parameter meaning beyond the schema, matching the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('View') and a clear resource ('past T-Mobile bills and payment history'), which tells the agent what the tool retrieves. It is distinguishable from siblings like pay_bill, but it does not explicitly call out sibling tools to reinforce the boundary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The wording implies this is for read-only historical billing/payment access. It contrasts with pay_bill or get_usage_details, but there is no explicit statement of when to choose this tool or when an alternative is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_usage_detailsC
Get detailed T-Mobile data, call, and text usage breakdown for the current billing period.
| Name | Required | Description | Default |
|---|---|---|---|
| line | No | Specific phone number/line to check (optional, defaults to all lines) | |
| password | No | T-Mobile password (optional if env var set) | |
| username | No | T-Mobile username/email (optional if env var set) |
TDQS
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, but it only states the action without explaining side effects, authentication requirements, or whether results are cached or live. The presence of password and username parameters hints at auth needs, but the description itself does not disclose this or any other behavioral trait.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. It immediately states what the tool does and scopes it to the current billing period, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description needs to explain the return format and any operational context. It does neither, leaving the agent uncertain about what 'detailed usage breakdown' contains, whether credentials are actually required, and how this relates to the account overview sibling. For a tool with optional auth parameters, this is a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 three parameters. The description adds no extra parameter-level detail, such as format requirements or interactions between the optional credentials and the line parameter. Baseline 3 applies because the schema handles parameter documentation adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies a specific verb ('Get') and resource (T-Mobile data/call/text usage breakdown for the current billing period), so an agent can understand the tool's core function. It does not explicitly contrast with sibling tools like get_account_overview or pay_bill, but the resource is distinct enough that the purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 get_account_overview. There is no mention of prerequisites, fallback options, or conditions that would make this the right choice. The usage context must be inferred entirely from the tool name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pay_billA
Initiate a one-time bill payment for T-Mobile account. Returns payment details for review before confirmation.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | Payment amount in USD (optional, defaults to full balance due) | |
| password | No | T-Mobile password (optional if env var set) | |
| username | No | T-Mobile username/email (optional if env var set) | |
| payment_method | No | Payment method to use (optional, uses default saved method) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavior itself, and it does add a useful trait: the payment is not confirmed yet, only review details are returned. However, it does not clarify what happens after review, whether this call actually charges the account, or if a separate confirmation step exists. This leaves meaningful ambiguity for a financial operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero filler: the first states the action and target, the second provides the key return behavior. Information is front-loaded and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a financial action with 4 optional parameters and no output schema, the description is under-specified. It introduces a review-before-confirmation flow but doesn't explain how to proceed after review, how optional parameters interact, or what a successful response looks like. An agent would be uncertain about the full workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for all 4 parameters, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema, but it doesn't need to since each parameter is already documented. No gaps to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Initiate') and resource ('one-time bill payment for T-Mobile account'), clearly distinguishing it from sibling read-only tools like get_usage_details and check_upgrade_eligibility. The added detail about returning payment details for review further clarifies its unique role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the use case explicit: this is the tool for initiating a payment, in contrast to the sibling tools that all retrieve information. It doesn't explicitly name alternatives or exclusions, but the intended context is clear enough for an agent to select it over the getters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v1.0.0- First observed
check_upgrade_eligibility - First observed
get_account_overview - First observed
get_bill_history - First observed
get_usage_details - First observed
pay_bill
TDQS
Each tool maps to a distinct account action, but get_account_overview and get_usage_details overlap somewhat because the overview includes a usage summary; the 'summary vs. detailed breakdown' distinction keeps them separable.
All tools use consistent snake_case verb_noun naming: get_* for read operations and pay_bill/check_upgrade_eligibility for actions. This creates a predictable pattern with no style mixing.
Five tools is a well-scoped set for a personal T-Mobile account management server, covering billing, usage, and upgrade information without bloat or an overly thin surface.
Core account management flows—overview, usage, bill payment, and upgrade eligibility—are present. Minor gaps include no explicit payment confirmation step or autopay/plan management, but these are workable for the apparent scope.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
Stealth web automation for AI agents. Login, signup, navigate, screenshot.
Provides cloud browser automation capabilities using Stagehand and Browserbase, enabling LLMs to i…
AI-powered browser automation — navigate, click, fill forms, and extract data from any website.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceProvides browser automation capabilities using Playwright, enabling users to navigate websites, extract content, take screenshots, and interact with web pages through natural language prompts.15MIT
- AlicenseBqualityNot gradedmaintenanceEnables browser automation and web scraping through Playwright, supporting navigation, screenshots, element interaction, form filling, JavaScript execution, and content extraction.8-
- AlicenseAqualityDmaintenanceAutomates Spectrum/Charter ISP account management tasks such as viewing account overview, paying bills, checking outages, and scheduling technician visits via browser automation.617MIT
- AlicenseAqualityDmaintenanceMCP server for AT&T telecom account management, automating att.com with Playwright to enable account overview, usage details, bill payment, bill history, and upgrade eligibility checks.520MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/markswendsen-code/mcp-tmobile'
If you have feedback or need assistance with the MCP directory API, please join our Discord server