# TeleSign MCP > 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. ## Overview - **Category:** communication-messaging - **Price:** Free - **Tags:** phone-verification, fraud-prevention, otp-authentication, risk-scoring, identity-verification, phone-intelligence ## Description 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. ## Tools ### 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. ### get_phone_id Retrieves detailed metadata about a phone number, including carrier and location data. ### get_phone_type Identifies the classification of the phone number (e.g., mobile, landline, VoIP). ### score_phone Calculates a quantitative fraud risk score for any provided phone number. ### send_push_verification Sends an OTP code directly via the user's push notification system. ### send_sms Transmits a one-time password (OTP) code to the specified phone number via SMS text message. ### send_verification Initiates the sending of a verification code using an unspecified default channel. ### send_voice_verification Delivers a one-time password (OTP) code via an automated voice call to the number. ## Prompt Examples **Prompt:** ``` Send a verification code to +14155551234. ``` **Response:** ``` Verification code sent! Reference ID: ref_8291. The user should receive the code shortly. ``` **Prompt:** ``` Score fraud risk for +14155551234. ``` **Response:** ``` Risk score for +14155551234: 120/1000 (Low Risk). Carrier: Verizon, Type: Mobile, Location: San Francisco, CA. ``` **Prompt:** ``` Check if +14155551234 has been deactivated. ``` **Response:** ``` Number +14155551234 is active. Last ported: 2024-03-15 from AT&T to Verizon. No deactivation detected. ``` ## Capabilities ### Determine phone number risk The agent runs the `score_phone` tool to calculate a quantitative risk score for any provided number. ### Validate phone activity status You can use `check_deactivation` to confirm if a specific number is active or has been deactivated by its carrier. ### Send multi-factor codes The agent sends verification codes using three methods: `send_sms`, `send_voice_verification`, or `send_push_verification`. ### Gather phone metadata Using `get_phone_id` and `get_phone_type`, the agent collects detailed information about the number's origin, carrier, and type. ### Check verification status The `check_verification` tool verifies if a previously sent code was successfully received or used by the user. ## 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. ## Benefits - 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_id` and `get_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_verification` for speed, or `send_voice_verification` when 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_verification` confirms whether the user received it and if they used it correctly, giving you clean audit logs. ## How It Works 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. 1. Your agent first calls `get_phone_id` to grab metadata (carrier, type) and then runs `score_phone` against the number to get an initial risk assessment. 2. Based on that score, the agent decides which verification method is best. It uses `send_sms` or `send_voice_verification` if a second factor is needed. 3. Finally, it calls `check_verification` to confirm that the user successfully received and submitted the correct code. ## Frequently Asked Questions **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.