TeleSign MCP. Validate phone identity and prevent fraud at signup.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Just plug in your AI agents and start using Vinkius.
TeleSign connects phone number intelligence, SMS/voice verification, and fraud risk scoring directly to your AI agent via MCP. It lets you validate user identities and detect account takeover attempts at sign-up by checking if numbers are active, identifying their carrier, or calculating a real-time risk score.
What your AI agents can do
Check deactivation
Checks if a given phone number is currently deactivated by its carrier.
Check telesign status
Verifies the connection and operational status of your TeleSign API account.
Check verification
Determines if a submitted verification code was valid for the given phone number.
The agent runs the score_phone tool to calculate a quantitative risk score for any provided number.
You can use check_deactivation to confirm if a specific number is active or has been deactivated by its carrier.
The agent sends verification codes using three methods: send_sms, send_voice_verification, or send_push_verification.
Using get_phone_id and get_phone_type, the agent collects detailed information about the number's origin, carrier, and type.
The check_verification tool verifies if a previously sent code was successfully received or used by the user.
Ask AI about this MCP
Supported MCP Clients
OAuth 2.0 Compatible Gemini Waiting for input…
TeleSign MCP Server: 10 Tools for Identity & Verification
Access ten specific tools that let your AI client verify user identities, score fraud risk, and manage multi-factor authentication flows directly in your code.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using TeleSign on Vinkius019dd170check deactivation
Checks if a given phone number is currently deactivated by its carrier.
019dd170check telesign status
Verifies the connection and operational status of your TeleSign API account.
019dd170check verification
Determines if a submitted verification code was valid for the given phone number.
019dd170get phone id
Retrieves detailed metadata about a phone number, including carrier and location data.
019dd170get phone type
Identifies the classification of the phone number (e.g., mobile, landline, VoIP).
019dd170score phone
Calculates a quantitative fraud risk score for any provided phone number.
019dd170send push verification
Sends an OTP code directly via the user's push notification system.
019dd170send sms
Transmits a one-time password (OTP) code to the specified phone number via SMS text message.
019dd170send verification
Initiates the sending of a verification code using an unspecified default channel.
019dd170send voice verification
Delivers a one-time password (OTP) code via an automated voice call to the number.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with TeleSign, then connect any of our 4,800+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 4,800+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by TeleSign. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.
Manually vetting users is slow. It adds friction before they even see your product.
Today, if you're building a secure sign-up flow, you'll have to write complex code that handles three separate checks: 1) Is the number real? (Requires an external API call). 2) Did they get the text message? (Requires a timeout and retry loop). 3) What if their carrier changes? (Requires constant maintenance of IP lookups). It's brittle, it takes time, and you can't easily change methods when SMS fails.
With TeleSign, your agent handles the complexity. You tell it: 'Verify this user.' The server then automatically runs `get_phone_id` to check metadata, calculates a risk score with `score_phone`, and if needed, sends an OTP via the best available method (`send_sms`, `send_voice_verification`, or `send_push_verification`). You just get a clean YES/NO answer.
TeleSign MCP Server: Use phone data for risk assessment and identity proofing.
Before, if the user's number was flagged as high-risk by your internal team, you had to manually check its history in a separate dashboard. Then you'd have to cross-reference that with carrier data and check for deactivation status before alerting the security team.
Now, the agent runs `score_phone` and `check_deactivation` together. It gives you an immediate, combined risk assessment right in your code. The system handles the multi-step investigation instantly.
What you can do with this MCP connector
This server gives your AI agent direct access to TeleSign's phone number intelligence, letting you verify identities and score fraud risk right in your client. You can check a number’s activity status using check_deactivation to confirm whether a carrier has deactivated it.
To build out full user profiles, the agent first runs get_phone_id, which pulls detailed metadata about the phone number, including its specific carrier and geographical location. It also uses get_phone_type to classify what kind of line it is—whether it's a mobile connection, a landline, or VoIP.
Before you even send a code, you should always run score_phone. This tool calculates a quantitative fraud risk score for any number provided. It gives you concrete metrics on the potential risk level associated with that phone line. You can also verify if the TeleSign API connection is good by calling check_telesign_status.
When it comes time to get verification codes out, the agent has three ways to send them: you can transmit a one-time password (OTP) via text message using send_sms; or you can deliver that code through an automated voice call with send_voice_verification; alternatively, you'll use send_push_verification to get the code delivered directly to the user's notification system.
The general function send_verification also initiates sending a code using default channels.
After you send that code, you gotta confirm it worked. You can run check_verification to determine if the submitted verification code was valid for that specific number and if the user successfully used it. If you need more depth on how numbers are treated, you'll find that the agent uses all these tools in sequence: first gathering metadata with get_phone_id and classifying it with get_phone_type; then checking its live status via check_deactivation; running score_phone for immediate risk scoring; sending a code through your preferred method (send_sms, send_voice_verification, or send_push_verification); and finally, confirming the whole thing with check_verification.
This workflow lets you build out robust identity checks that go far beyond just validating a single password. You're checking carrier status, number type, location data, fraud risk score, and confirmation of use—all within one session.
019dd170-562a-70a9-9ce7-afb545197b9f 
How TeleSign MCP Works
- 1 Your agent first calls
get_phone_idto grab metadata (carrier, type) and then runsscore_phoneagainst the number to get an initial risk assessment. - 2 Based on that score, the agent decides which verification method is best. It uses
send_smsorsend_voice_verificationif a second factor is needed. - 3 Finally, it calls
check_verificationto confirm that the user successfully received and submitted the correct code.
The bottom line is: your agent executes a full identity check—from basic metadata gathering to multi-factor confirmation—without you writing any dedicated API logic.
Who Is TeleSign MCP For?
This suite is for security engineers, backend architects, and product owners who own user sign-up flows. If your app handles accounts, transactions, or sensitive data, you're here. You need to know that the person building this system can't rely on just one kind of check. They need a dynamic flow that escalates security only when the risk warrants it.
They implement multi-layered authentication logic, using score_phone to set risk thresholds and deciding whether to force an additional check via send_voice_verification.
They define the optimal user journey. They want a fast sign-up experience, so they guide the agent to use low-friction checks like send_push_verification unless the number is flagged by get_phone_id.
They build compliance gates. They must ensure that every new user record passes both a deactivation check (check_deactivation) and a high risk score assessment before activating the account.
What Changes When You Connect
- Fraud detection gets precise with
score_phone. Instead of just a pass/fail, your agent gets a numerical risk score. This lets you set dynamic security policies—you only force MFA if the score crosses a specific threshold. - You gain full visibility into phone metadata via
get_phone_idandget_phone_type. You know exactly what kind of number it is (e.g., mobile vs. VoIP) before running any checks, which helps you tailor your security prompts. - Handling different networks is simple. The agent can choose the best verification path:
send_push_verificationfor speed, orsend_voice_verificationwhen SMS reliability is questionable. - The system ensures continuity with
check_deactivation. You don't waste time sending codes to numbers that are already inactive or disconnected, improving conversion rates and keeping your user experience smooth. - Verification status is trackable. After you send a code using any method,
check_verificationconfirms whether the user received it and if they used it correctly, giving you clean audit logs.
Real-World Use Cases
Onboarding high-risk users
A new enterprise client signs up with a number flagged by score_phone as having moderate risk. The agent sees this score and immediately skips the basic sign-up flow, forcing the user to complete verification using send_voice_verification instead of just SMS.
Handling potential SIM swaps
A suspicious account attempts to log in. The agent first uses get_phone_id and finds unusual metadata (e.g., a sudden location change). It then calls check_deactivation to ensure the number is current before allowing login.
Validating marketing leads
A B2B sales tool collects thousands of potential contacts. Before importing them, the agent uses get_phone_type and score_phone to filter out known VoIP numbers or overly risky lines, saving manual cleanup time.
Automated account recovery
A user initiates an account reset. The system first checks the number's status with check_deactivation. If it’s active, the agent sends a code via send_push_verification for quick, low-friction access.
The Tradeoffs
Assuming SMS is always best
Only implementing send_sms and assuming that if the user gets a code, they are verified. This fails when users use VoIP or networks with unreliable SMS delivery.
→
Always run get_phone_type first. If it shows the number is non-standard (like a VOIP line), fall back to using send_voice_verification instead of relying solely on send_sms.
Skipping risk checks
Allowing sign-up immediately after basic number validation. This leaves the system wide open to bots and fraud that only require a simple, active phone number.
→
Every time an account is created, you must run score_phone. If the score is above your threshold, block creation until a second factor (like send_push_verification) is completed.
Ignoring number history
Treating every phone number as if it's brand new. You can miss accounts that have been recently ported or deactivated.
→
Always call check_deactivation and use the metadata from get_phone_id. This confirms the number is currently connected to an active line.
When It Fits, When It Doesn't
Use this server if your core business logic revolves around user identity, account creation, or sensitive transactions. You need a verifiable proof that the person signing up is who they say they are. Run score_phone and check for deactivation status first—those two tools should drive 90% of your security logic.
Don't use this if you just need to send bulk messages (use dedicated messaging platforms). Also, don't rely on it as a primary biometric tool; while get_phone_id is great, remember that phone numbers can be spoofed or swapped. This suite proves the number is active and belongs to someone, not necessarily the person using it.
Common Questions About TeleSign MCP
How do I check if a number is active using the TeleSign MCP Server? +
Use the check_deactivation tool. This function confirms whether the phone number you are checking is currently connected and active on its carrier's network.
What’s the difference between `send_sms` and `send_voice_verification`? +
send_sms delivers a code as a text message. send_voice_verification, however, calls the number and reads the code aloud over an automated voice line, which is often preferred for higher security contexts.
Can I use score_phone to detect suspicious activity? +
Yes. The score_phone tool provides a quantitative risk score (e.g., 120/1000). You can program your agent to automatically block sign-ups if the score exceeds your predefined security threshold.
Does TeleSign help me verify phone type? +
The get_phone_type tool classifies the number. It tells you whether it's a mobile line, a landline, or another category, which is critical for designing reliable authentication flows.
How do I confirm API connectivity using `check_telesign_status`? +
It confirms your connection health immediately. This tool checks if the TeleSign server is reachable and operating correctly before you run any major workflows, preventing failed calls later on.
After sending a code with `send_verification`, how can I check its status using `check_verification`? +
It tells you the exact status of a sent code. This is crucial for building reliable sign-up flows, letting your agent know immediately if the user accepted or rejected the verification attempt.
What are the benefits of using `send_push_verification` over traditional SMS methods? +
Push notifications offer a more modern and sometimes faster authentication method. This tool delivers codes directly to your user's registered app, bypassing potential SMS carrier delays or spam filters.
What specific metadata does `get_phone_id` return about the number? +
It returns comprehensive identity data for the number. You get more than just the digits; you receive details like the carrier, line type, and geographical location that help build a full risk profile.
Can my AI send and verify OTP codes? +
Yes. send_verification sends the code, then check_verification validates the user's response.
Can I check fraud risk for a phone number? +
Yes. score_phone returns a fraud risk score based on carrier intelligence and historical data.
Can I identify if a number is mobile or landline? +
Yes. get_phone_type returns whether the number is mobile, landline, VoIP, or toll-free.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.