# Upzelo MCP > Upzelo MCP Server stops subscription churn by managing customer retention flows. Use your AI agent to intercept cancellations and launch personalized win-back campaigns at the exact moment a user tries to leave. You can list customers, check active subscriptions, and manually trigger complex retention sequences without logging into the Upzelo console. ## Overview - **Category:** sales-automation - **Price:** Free - **Tags:** churn-reduction, subscription-management, customer-retention, win-back-campaigns, lifecycle-marketing ## Description **Upzelo MCP Server - Manage Churn & Retention Flows** Don't let customers slip through your fingers again. You connect this server to your AI client, and your agent handles the whole customer lifecycle conversationally. Instead of logging into the Upzelo console—and having to manually click through five different screens just to check on one user—you tell your agent what you need, and it gets the job done immediately. This server lets you intercept cancellations and launch those personalized win-back campaigns the second a high-risk customer even thinks about leaving. It's pure power, built right into your chat window. ### Managing Your Customer Base You can get detailed info on any single user using `get_customer` by feeding it just their ID; you'll instantly know their current status and all the associated data points Upzelo keeps on file. Need to see who's in your pool? You run `list_customers`, and that pulls a full roster of every customer profile tracked in Upzelo. If you find a record with bad segmentation info, you can use `save_customer` to either create an entirely new user record or just update the details on an existing one—it's how you keep your targeting sharp. ### Tracking Subscriptions and Billing Details Managing billing shouldn't be guesswork. You pull all the specific financial data for a single account using `get_subscription` when you need to check rates or plan structures. Want to audit everything? Run `list_subscriptions`, and you get a complete list of every subscription managed within your Upzelo account. If something changes—say, a customer upgrades their tier mid-cycle—you can use `update_subscription` to programmatically change specific attributes like the plan name or status directly through the agent. You'll never have to manually update a billing record again. ### Running Retention Campaigns and Monitoring Status The main goal here is keeping people subscribed, so retention flows are your bread and butter. First, you check what strategies you even have available by running `list_flows`, which gives you the names of every existing retention template. You can then pull the specific blueprint for any single flow using `get_flow` to see exactly how that sequence is built out. When a customer shows signs of canceling, you tell your agent to start the process with `start_flow`; this kicks off the automated, multi-step win-back sequence immediately for that user. Don't assume it worked just because you hit 'send.' You run into potential roadblocks, and you need proof. To check if a retention sequence is actually running right now or what its final outcome was, you use `get_flow_session`. This tool tells you the real-time operational status of the flow—did it succeed? Did it fail on step three? You get that granular detail every time. ### The Full Workflow Picture This combination means you're never blind. You start by listing all customers via `list_customers` and checking out their billing details using `list_subscriptions`. Then, if a user looks shaky, you check the flow structure with `get_flow`, manually trigger the sequence with `start_flow`, and keep monitoring that session status until it's complete. You can refine the entire operation by saving new customer segments via `save_customer` before kicking off the whole thing. This server lets your agent handle every single touchpoint, from initial data retrieval to final subscription update, without you ever leaving your chat window. ## Tools ### save_customer Creates a new customer record or modifies an existing one for better segmentation. ### get_customer Retrieves all details for a specific customer ID in Upzelo. ### get_flow_session Checks the current status and outcomes of an active, running retention sequence. ### get_flow Gets the setup and structure details for a single defined retention flow. ### get_subscription Pulls all billing details for a specific subscription ID. ### list_customers Returns a list of every customer profile tracked within Upzelo. ### list_flows Provides an overview and names of all available retention flow templates. ### list_subscriptions Retrieves a list of every subscription managed by the Upzelo account. ### start_flow Initiates the automated, multi-step retention sequence for a specified customer. ### update_subscription Changes specific attributes of a subscription record, such as plan or status. ## Prompt Examples **Prompt:** ``` List all customers currently tracked in Upzelo. ``` **Response:** ``` I've retrieved your customer list. You have 25 active profiles including 'John Miller', 'Sarah Smith', and 'Global Tech'. Would you like to check the retention status for any of them? ``` **Prompt:** ``` Trigger the 'Basic Retention' flow (ID: fl_8823) for customer 'cust_1029'. ``` **Response:** ``` Retention flow initialized! I've started the 'Basic Retention' sequence for customer cust_1029. The session ID is sess_99023. I'll monitor for the final outcome. ``` **Prompt:** ``` Show me the details for subscription 'sub_12903'. ``` **Response:** ``` Fetching subscription data... Subscription sub_12903 is currently 'Active'. It's on the 'Professional Plan' and the next renewal is scheduled for Dec 15th. Shall I update any attributes? ``` ## Capabilities ### Retrieve Specific Customer Data You get detailed information on a single customer profile, including their current status and associated data. ### Launch Targeted Retention Campaigns The agent starts a pre-defined retention flow for any customer who is showing signs of canceling. ### Manage Subscription Records You can pull subscription details or programmatically update statuses and plan attributes. ### Monitor Active Flow Status The system checks the current operational status of a retention sequence, telling you if it succeeded or failed. ### List All Customer & Subscription Data You pull comprehensive lists of all active customers and all tracked subscriptions for bulk review. ## Use Cases ### The CSM needs to save an at-risk client. A Customer Success Manager learns a key account is considering canceling. They ask their agent, 'What should I do for John Doe?' The agent runs `get_customer` first to confirm segmentation data. Then, it calls `start_flow`, initiating the highest priority retention sequence immediately. ### Product Ops needs to audit billing records. The Product Operations team needs to check if 50 enterprise accounts have updated their plan attributes after a recent product change. Instead of running manual reports, they ask the agent to list all subscriptions and then use `get_subscription` on specific IDs to confirm the new status. ### The Growth Team needs campaign performance metrics. The Business Growth team suspects a retention flow isn't working. They tell their agent, 'Check the last three active win-back campaigns.' The agent uses `get_flow_session` to pull the status and outcome for each session ID, confirming if the sequence completed successfully. ### Syncing local IDs with Upzelo records. Your internal system updates a customer's record. You use `save_customer` along with your external identifiers to link your data model directly to Upzelo, ensuring future calls using tools like `get_customer` pull the correct, linked profile. ## Benefits - Immediate action on churn: Don't just know a customer is leaving. Use `start_flow` to launch an entire retention campaign—a personalized sequence of messages or offers—the second your agent spots the risk. - Full visibility into billing state: Forget logging into the billing dashboard. Call `get_subscription` or `list_subscriptions` to pull real-time status, next renewal dates, and plan details instantly. - Precise customer data updates: Found a missing detail? Instead of opening a web form, use `save_customer` to update segmentation tags directly through your agent's conversation context. - Audit flow performance: Track whether retention attempts actually work. Use `get_flow_session` to check the outcome and status of any running campaign, confirming success or pinpointing failure points. - Centralized data access: Need a full view? The ability to run `list_customers` means your agent can pull comprehensive lists for batch processing or sending reports without leaving your primary workspace. ## How It Works The bottom line is that your AI client treats Upzelo like another internal database, allowing you to run complex customer lifecycle actions without switching interfaces. 1. Subscribe to the Upzelo server and provide your App ID and API Key. 2. Your AI client calls a function like `list_customers` or `get_subscription` to gather necessary data (e.g., identifying a churn risk). 3. The agent uses the collected IDs and context to call `start_flow`, which initiates the retention sequence in Upzelo. ## Frequently Asked Questions **How do I check if a retention flow actually finished with Upzelo MCP Server?** You use the `get_flow_session` tool. This function takes the session ID generated when you ran `start_flow`, and it reports the final status, confirming success or indicating where the sequence failed. **Can I list all my customers using Upzelo MCP Server?** Yes, running `list_customers` pulls a comprehensive roster of every customer ID tracked in your account. This is useful for bulk reporting or identifying who needs immediate attention. **What if I need to change a subscription plan? Should I use update_subscription?** Yes, `update_subscription` is the correct tool for changing attributes like status or plan type. It directly modifies the record in Upzelo without requiring manual UI interaction. **Is there a way to segment customers using the Upzelo MCP Server?** You use `save_customer` for segmentation. You can create or modify customer records, adding specific tags or data points that allow your agent to target offers more accurately. **How do I get started and authenticate to run a flow using `start_flow`?** You must supply your Upzelo App ID and API Key in the server configuration. These credentials authorize your AI client to access customer data and initialize retention sequences. **When I use the `save_customer` tool, how does it handle my external system identifiers?** The tool links your internal Upzelo records to any external IDs you provide. This ensures that even if a customer record changes systems, their history stays connected for accurate targeting. **If I run into an error while checking flow status with `get_flow`, what should I check first?** First, verify that the Flow ID and Customer IDs you passed are correct and active. Errors often relate to outdated credentials or non-existent identifiers rather than a system failure. **Should I use `list_subscriptions` or `get_subscription` if I only need details on one specific plan?** Use `get_subscription` when you know the exact subscription ID. This is much more efficient because it pulls single data points directly, avoiding the overhead of listing every single record. **Can I manually start a retention flow for a customer via AI?** Yes! Use the `start_flow` tool and provide the Flow ID, Customer ID, and Subscription ID. This will initialize the retention experience for that user immediately. **How do I see if a customer successfully stayed after a flow?** Run the `get_flow_session` query with the specific Session ID. It will return the outcome and status of the retention attempt. **Is it possible to update a subscription's status via AI?** Absolutely. Use the `update_subscription` tool by providing the Subscription ID and the new status to synchronize data between your systems and Upzelo.