How to integrate Maxio MCP with Vercel AI SDK v6

This guide walks you through connecting Maxio to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working Maxio agent that can list overdue maxio invoices by customer, create subscription for new saas customer, summarize monthly recurring revenue changes through natural language commands. This guide will help you understand how to give your Vercel AI SDK agent real control over a Maxio account through Composio's Maxio MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Get started for freeGet a demo
Maxio logoMaxio
Api Key

Maxio is a subscription billing and revenue management platform for B2B SaaS. It helps teams automate invoicing, payments, usage billing, and revenue insights.

177 Tools

Introduction

This guide walks you through connecting Maxio to Vercel AI SDK v6 using the Composio tool router. By the end, you'll have a working Maxio agent that can list overdue maxio invoices by customer, create subscription for new saas customer, summarize monthly recurring revenue changes through natural language commands.

This guide will help you understand how to give your Vercel AI SDK agent real control over a Maxio account through Composio's Maxio MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Maxio with

OpenAI Agents SDKClaude Agent SDKClaude CodeClaude CoworkCodexOpenClawHermesCLIGoogle ADKLangChainMastra AILlamaIndexCrewAI

TL;DR

Here's what you'll learn:
  • How to set up and configure a Vercel AI SDK agent with Maxio integration
  • Using Composio's Tool Router to dynamically load and access Maxio tools
  • Creating an MCP client connection using HTTP transport
  • Building an interactive CLI chat interface with conversation history management
  • Handling tool calls and results within the Vercel AI SDK framework

What is Vercel AI SDK?

The Vercel AI SDK is a TypeScript library for building AI-powered applications. It provides tools for creating agents that can use external services and maintain conversation state.

Key features include:

  • streamText: Core function for streaming responses with real-time tool support
  • MCP Client: Built-in support for Model Context Protocol via @ai-sdk/mcp
  • Step Counting: Control multi-step tool execution with stopWhen: stepCountIs()
  • OpenAI Provider: Native integration with OpenAI models

What is the Maxio MCP server, and what's possible with it?

The Maxio MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Maxio account. It provides structured and secure access to your customers, products, subscriptions, pricing, credits, prepayments, and invoices, so your agent can create customers, configure products and prices, manage subscriptions, issue credits, and prepare invoices on your behalf.

  • Customer and subscription management: Have your agent create or update customers, start new subscriptions, change subscription details, and cancel scheduled cancellations.
  • Product and pricing setup: Let the agent create product families and products, then create or update product and component price points.
  • Invoice preparation and control: Direct your agent to preview or create proforma invoices, issue advance invoices, and void advance invoices when needed.
  • Credits and prepayments: Instruct your agent to create or refund prepayments and issue or deduct service credits for subscriptions.
  • Subscription records and churn reasons: Have your agent create or update subscription notes, attach metadata, and maintain churn reason codes.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before you begin, make sure you have:
  • Node.js and npm installed
  • A Composio account with API key
  • An OpenAI API key
2

Getting API Keys for OpenAI and Composio

OpenAI API Key
  • Go to the OpenAI dashboard and create an API key. You'll need credits to use the models, or you can connect to another model provider.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install required dependencies

bash
npm install @ai-sdk/openai @ai-sdk/mcp @composio/core ai dotenv

First, install the necessary packages for your project.

What you're installing:

  • @ai-sdk/openai: Vercel AI SDK's OpenAI provider
  • @ai-sdk/mcp: MCP client for Vercel AI SDK
  • @composio/core: Composio SDK for tool integration
  • ai: Core Vercel AI SDK
  • dotenv: Environment variable management
4

Set up environment variables

bash
OPENAI_API_KEY=your_openai_api_key_here
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_user_id_here

Create a .env file in your project root.

What's needed:

  • OPENAI_API_KEY: Your OpenAI API key for GPT model access
  • COMPOSIO_API_KEY: Your Composio API key for tool access
  • COMPOSIO_USER_ID: A unique identifier for the user session
5

Import required modules and validate environment

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});
What's happening:
  • We're importing all necessary libraries including Vercel AI SDK's OpenAI provider and Composio
  • The dotenv/config import automatically loads environment variables
  • The MCP client import enables connection to Composio's tool server
6

Create Tool Router session and initialize MCP client

typescript
async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["maxio"],
  });

  const mcpUrl = session.mcp.url;
What's happening:
  • We're creating a Tool Router session that gives your agent access to Maxio tools
  • The create method takes the user ID and specifies which toolkits should be available
  • The returned mcp object contains the URL and authentication headers needed to connect to the MCP server
  • This session provides access to all Maxio-related tools through the MCP protocol
7

Connect to MCP server and retrieve tools

typescript
const mcpClient = await createMCPClient({
  transport: {
    type: "http",
    url: mcpUrl,
    headers: session.mcp.headers, // Authentication headers for the Composio MCP server
  },
});

const tools = await mcpClient.tools();
What's happening:
  • We're creating an MCP client that connects to our Composio Tool Router session via HTTP
  • The mcp.url provides the endpoint, and mcp.headers contains authentication credentials
  • The type: "http" is important - Composio requires HTTP transport
  • tools() retrieves all available Maxio tools that the agent can use
8

Initialize conversation and CLI interface

typescript
let messages: ModelMessage[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log(
  "Ask any questions related to maxio, like summarize my last 5 emails, send an email, etc... :)))\n",
);

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
  prompt: "> ",
});

rl.prompt();
What's happening:
  • We initialize an empty messages array to maintain conversation history
  • A readline interface is created to accept user input from the command line
  • Instructions are displayed to guide the user on how to interact with the agent
9

Handle user input and stream responses with real-time tool feedback

typescript
rl.on("line", async (userInput: string) => {
  const trimmedInput = userInput.trim();

  if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
    console.log("\nGoodbye!");
    rl.close();
    process.exit(0);
  }

  if (!trimmedInput) {
    rl.prompt();
    return;
  }

  messages.push({ role: "user", content: trimmedInput });
  console.log("\nAgent is thinking...\n");

  try {
    const stream = streamText({
      model: openai("gpt-5"),
      messages,
      tools,
      toolChoice: "auto",
      stopWhen: stepCountIs(10),
      onStepFinish: (step) => {
        for (const toolCall of step.toolCalls) {
          console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});
What's happening:
  • We use streamText instead of generateText to stream responses in real-time
  • toolChoice: "auto" allows the model to decide when to use Maxio tools
  • stopWhen: stepCountIs(10) allows up to 10 steps for complex multi-tool operations
  • onStepFinish callback displays which tools are being used in real-time
  • We iterate through the text stream to create a typewriter effect as the agent responds
  • The complete response is added to conversation history to maintain context
  • Errors are caught and displayed with helpful retry suggestions

Complete Code

Here's the complete code to get you started with Maxio and Vercel AI SDK:

typescript
import "dotenv/config";
import { openai } from "@ai-sdk/openai";
import { Composio } from "@composio/core";
import * as readline from "readline";
import { streamText, type ModelMessage, stepCountIs } from "ai";
import { createMCPClient } from "@ai-sdk/mcp";

const composioAPIKey = process.env.COMPOSIO_API_KEY;
const composioUserID = process.env.COMPOSIO_USER_ID;

if (!process.env.OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!composioAPIKey) throw new Error("COMPOSIO_API_KEY is not set");
if (!composioUserID) throw new Error("COMPOSIO_USER_ID is not set");

const composio = new Composio({
  apiKey: composioAPIKey,
});

async function main() {
  // Create a tool router session for the user
  const session = await composio.create(composioUserID!, {
    toolkits: ["maxio"],
  });

  const mcpUrl = session.mcp.url;

  const mcpClient = await createMCPClient({
    transport: {
      type: "http",
      url: mcpUrl,
      headers: session.mcp.headers, // Authentication headers for the Composio MCP server
    },
  });

  const tools = await mcpClient.tools();

  let messages: ModelMessage[] = [];

  console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
  console.log(
    "Ask any questions related to maxio, like summarize my last 5 emails, send an email, etc... :)))\n",
  );

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: "> ",
  });

  rl.prompt();

  rl.on("line", async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (["exit", "quit", "bye"].includes(trimmedInput.toLowerCase())) {
      console.log("\nGoodbye!");
      rl.close();
      process.exit(0);
    }

    if (!trimmedInput) {
      rl.prompt();
      return;
    }

    messages.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    try {
      const stream = streamText({
        model: openai("gpt-5"),
        messages,
        tools,
        toolChoice: "auto",
        stopWhen: stepCountIs(10),
        onStepFinish: (step) => {
          for (const toolCall of step.toolCalls) {
            console.log(`[Using tool: ${toolCall.toolName}]`);
          }
          if (step.toolCalls.length > 0) {
            console.log(""); // Add space after tool calls
          }
        },
      });

      for await (const chunk of stream.textStream) {
        process.stdout.write(chunk);
      }

      console.log("\n\n---\n");

      // Get final result for message history
      const response = await stream.response;
      if (response?.messages?.length) {
        messages.push(...response.messages);
      }
    } catch (error) {
      console.error("\nAn error occurred while talking to the agent:");
      console.error(error);
      console.log(
        "\nYou can try again or restart the app if it keeps happening.\n",
      );
    } finally {
      rl.prompt();
    }
  });

  rl.on("close", async () => {
    await mcpClient.close();
    console.log("\n👋 Session ended.");
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("Fatal error:", err);
  process.exit(1);
});

Conclusion

You've successfully built a Maxio agent using the Vercel AI SDK with streaming capabilities! This implementation provides a powerful foundation for building AI applications with natural language interfaces and real-time feedback.

Key features of this implementation:

  • Real-time streaming responses for a better user experience with typewriter effect
  • Live tool execution feedback showing which tools are being used as the agent works
  • Dynamic tool loading through Composio's Tool Router with secure authentication
  • Multi-step tool execution with configurable step limits (up to 10 steps)
  • Comprehensive error handling for robust agent execution
  • Conversation history maintenance for context-aware responses

You can extend this further by adding custom error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.
TOOLS

Supported Tools

Every Maxio action and event your agent gets out of the box.

Allocate Component

Creates an allocation for a component on a subscription.

Apply Coupons to Subscription

Applies one or more coupons to a subscription.

Archive Component

Archives a component to prevent new allocations.

Archive Component Price Point

Archives a component price point, making it inactive.

Archive Coupon

Archives a coupon to prevent new uses.

Archive Offer

Archives an offer to prevent new subscriptions from using it.

Archive Product

Archives a product to prevent new subscriptions from being created.

Archive product price point

Archives a product price point by its ID.

Cancel Delayed Cancellation

Cancels a scheduled cancellation on a subscription.

Clone Component Price Point

Clones an existing component price point to create a new one.

Bulk Create Product Price Points

Creates multiple product price points in a single API call.

Create Component

Creates a new component within a product family in Chargify.

Create Component Price Point

Creates a price point for a component in Maxio Advanced Billing.

Create Coupon Subcodes

Creates multiple subcodes for an existing coupon in Maxio Advanced Billing.

Create Customer

Creates a new customer in Maxio/Chargify with the required fields: first_name, last_name, and email.

Create Webhook Endpoint

Creates a new webhook endpoint in Maxio Advanced Billing.

Create Invoice

Creates a one-time invoice for a subscription with custom line items.

Create Metadata

Creates metadata values for a resource in Maxio/Chargify Advanced Billing.

Create Metafields

Creates metafield definitions for a resource type.

Create or Update Coupon Currency Prices

Tool to create or update currency prices for a coupon in Maxio.

Create Payment Profile

Creates a new payment profile for a customer in Maxio (Chargify).

Create Prepaid Usage Component

Creates a prepaid usage component for pre-purchased units.

Create Prepayment

Creates a prepayment for a subscription.

Create Product

Tool to create a new product within a product family in Maxio.

Create Product Family

Creates a new product family in Maxio/Chargify.

Create Product Price Point

Creates a price point for a product in Maxio Advanced Billing.

Create Proforma Invoice

Creates a proforma invoice for a subscription.

Create Quantity Based Component

Creates a quantity-based component for recurring units within a product family.

Create Reason Code

Creates a new churn reason code in Maxio/Chargify Advanced Billing.

Create Signup Proforma Invoice

Creates a proforma invoice for signup preview.

Create Subscription

Creates a new subscription in Maxio (Chargify) with specified product, customer, and payment details.

Create Subscription Group With Signup

Creates a subscription group with subscriptions and a shared payer in a single operation.

Create Subscription Note

Creates a note on a subscription in Maxio/Chargify Advanced Billing.

Create Usage

Records usage for a metered component on a subscription.

Deactivate Event Based Component

Deactivates an event-based component on a subscription.

Deduct Service Credit

Deducts from a subscription's service credit balance.

Delete Coupon Subcode

Deletes a specific subcode from an existing coupon in Maxio Advanced Billing.

Delete Customer

Deletes a customer from Maxio/Chargify.

Delete Prepaid Usage Allocation

Deletes a prepaid usage allocation from a subscription component.

Delete Reason Code

Deletes a churn reason code from Maxio/Chargify Advanced Billing.

Delete Subscription Group

Deletes a subscription group and all its associated data.

Delete Subscription Note

Deletes a specific note from a subscription in Maxio Advanced Billing.

Delete Subscription Payment Profile

Removes a payment profile from a subscription in Maxio Advanced Billing.

Delete Unused Payment Profile

Permanently deletes an unused payment profile from Maxio/Chargify.

Deliver Proforma Invoice

Delivers a proforma invoice to the customer via email.

Enable Webhooks

Enables or disables webhooks for the Maxio/Chargify site.

Export Invoices

Initiates an invoices export job.

Export Proforma Invoices

Initiates an asynchronous export of proforma invoices data.

Export Subscriptions

Initiates an asynchronous export of subscription data from Maxio/Chargify.

Get MRR

Returns monthly recurring revenue data for the site.

Initiate Delayed Cancellation

Schedules a subscription for cancellation at the end of its current billing period.

Issue Advance Invoice

Issues an advance invoice for a subscription.

Issue Invoice

Issues a draft invoice for payment collection.

Issue Service Credit

Issues a service credit to a subscription.

List All Component Price Points

Lists all component price points across the site.

List Allocations

Lists all allocations for a component on a subscription.

List All Product Price Points

Lists all product price points across the site in Maxio Advanced Billing.

List Chargify.js Public Keys

Lists all public keys for Chargify.

List Component Price Points

Lists all price points for a component in Maxio Advanced Billing.

List Components

Returns a list of all components across product families in Chargify.

List Components for Product Family

Lists all components within a product family in Maxio/Chargify.

List Consolidated Invoice Segments

Lists segments of a consolidated invoice.

List Coupons for Product Family

Lists all coupons within a product family.

List Coupon Subcodes

Lists all subcodes for an existing coupon in Maxio Advanced Billing.

List Credit Notes

Returns a list of credit notes from Maxio/Chargify.

List Customers

Returns a list of customers with optional filtering and pagination.

List Customer Subscriptions

Lists all subscriptions for a specific customer in Maxio Advanced Billing.

List Webhook Endpoints

Returns a list of webhook endpoints configured in Maxio Advanced Billing.

List Events

Returns a list of events for the site in Maxio Advanced Billing.

List Exported Invoices

Retrieves a list of exported invoices for a specific invoice export batch.

List Exported Proforma Invoices

Lists exported proforma invoice rows from a previously initiated export batch.

List Exported Subscriptions

Lists exported subscriptions from a subscription export batch in Maxio/Chargify.

List Invoice Events

Lists all invoice events from Maxio/Chargify with optional filtering.

List Invoices

Returns a list of invoices with optional filtering and pagination.

List Metadata for Resource Type

Lists all metadata definitions for a resource type in Maxio/Chargify Advanced Billing.

List Metafields

Lists all metafield definitions for a resource type in Maxio/Chargify Advanced Billing.

List MRR Movements

Returns MRR movement history showing changes in Monthly Recurring Revenue.

List MRR Per Subscription

Returns MRR broken down by subscription.

List Offers

Returns a list of all offers in Chargify.

List Payment Profiles

Returns a list of payment profiles in Maxio Advanced Billing.

List Prepayments

Lists all prepayments for a subscription in Maxio Advanced Billing.

List Product Families

Returns a list of all product families in Maxio/Chargify.

List Product Price Points

Lists all price points for a product in Maxio Advanced Billing.

List Products

Returns a list of all products from Maxio (Chargify).

List Products for Product Family

Lists all products within a product family in Maxio/Chargify.

List Proforma Invoices

Lists all proforma invoices for a specific subscription in Maxio Advanced Billing.

List Reason Codes

Returns a list of all churn reason codes in Maxio/Chargify Advanced Billing.

List Service Credits

Lists all service credits for a subscription in Maxio Advanced Billing.

List Subscription Components

Lists all components attached to a subscription in Maxio (Chargify).

List Subscription Components For Site

Lists all subscription components for a site.

List Subscription Events

Returns a list of events for a specific subscription in Maxio Advanced Billing.

List Subscription Groups

Returns a list of subscription groups with optional filtering and pagination.

List Subscription Notes

Lists all notes attached to a subscription in Maxio/Chargify Advanced Billing.

List Subscriptions

Returns a list of subscriptions with optional filtering and pagination.

List Usages

Lists all usage records for a component on a subscription.

List Webhooks

Returns a list of webhooks configured in Maxio Advanced Billing.

Migrate Subscription Product

Migrates a subscription to a different product in Maxio/Chargify Advanced Billing.

Override Subscription

Overrides cancellation settings of a subscription.

Promote Product Price Point to Default

Promotes a product price point to be the default price point for a product.

Pause Subscription

Pauses an active subscription in Maxio (Chargify) Advanced Billing.

Preview Allocations

Previews allocation charges before creating them for subscription components.

Preview Customer Information Changes

Previews customer information changes for an invoice.

Preview Proforma Invoice

Previews a proforma invoice for a subscription without actually creating it.

Preview Renewal

Previews the next renewal charges for a subscription in Maxio (Chargify).

Preview Signup Proforma Invoice

Previews a proforma invoice for signup.

Preview Subscription

Previews a subscription in Maxio (Chargify) before actual creation to see pricing and details.

Preview Subscription Product Migration

Previews a product migration before executing it.

Promote Component Price Point to Default

Promotes a component price point to be the default price point for its component.

Reactivate Subscription

Reactivates a canceled subscription in Maxio (Chargify) Advanced Billing.

Reactivate Subscription Group

Reactivates a canceled subscription group in Maxio/Chargify.

Read Account Balances

Retrieves the account balances for a subscription in Maxio Advanced Billing.

Read Advance Invoice

Retrieves an advance invoice for a subscription.

Read Component

Retrieves details of a specific component within a product family in Maxio/Chargify.

Read Component by Handle

Finds a component by its unique handle in Maxio/Chargify.

Read Component Price Point

Retrieves a specific component price point in Maxio Advanced Billing.

Read Coupon

Retrieves details of a specific coupon within a product family.

Find Coupon by Code

Finds and retrieves a coupon by its unique code in Maxio Advanced Billing.

Read Coupon Usage

Retrieves usage statistics for a coupon.

Read Credit Note

Retrieves details of a specific credit note from Maxio/Chargify.

Read Customer

Retrieves details of a specific customer by their Chargify ID.

Read Customer By Reference

Looks up a customer by their external reference value.

Read Events Count

Returns a count of events for the site in Maxio Advanced Billing.

Read Invoice

Retrieves details of a specific invoice by its unique identifier (UID).

Read Invoices Export Status

Retrieves the status and details of an invoices export batch job.

Read Offer

Retrieves details of a specific offer by its ID from Maxio (Chargify).

Read Payment Profile

Retrieves details of a specific payment profile in Maxio Advanced Billing.

Read Product

Retrieves details of a specific product by its ID from Maxio (Chargify).

Read Product By Handle

Retrieves a single product from Maxio (Chargify) by its unique handle.

Read Product Family

Retrieves details of a specific product family in Maxio/Chargify.

Read Product Price Point

Retrieves a specific product price point in Maxio Advanced Billing.

Read Proforma Invoice

Retrieves a specific proforma invoice by its unique identifier.

Read Proforma Invoices Export

Retrieves the status and details of a proforma invoices export batch job.

Read Reason Code

Retrieves a specific churn reason code by its ID from Maxio/Chargify Advanced Billing.

Read Site

Retrieves details about the current Chargify/Maxio site.

Read Site Stats

Returns site-wide statistics for the Chargify site.

Read Subscription

Retrieves details of a specific subscription by its unique identifier (ID).

Read Subscription By Reference

Finds a subscription by its external reference identifier in Maxio Advanced Billing.

Read Subscription Component

Retrieves details of a component attached to a subscription in Maxio (Chargify).

Read Subscription Note

Retrieves a specific note attached to a subscription in Maxio/Chargify Advanced Billing.

Read Subscriptions Export Status

Retrieves the status and details of a subscriptions export batch job.

Bulk Record Events

Tool to record multiple billable events in bulk for a subscription component.

Record Payment for Invoice

Records a payment for an invoice.

Refund Invoice

Creates a refund for a paid invoice.

Refund Prepayment

Refunds a prepayment made on a subscription.

Remove Coupon from Subscription

Removes an applied coupon from a subscription in Maxio (Chargify) Advanced Billing.

Remove Subscription from Group

Removes a subscription from its subscription group in Maxio Advanced Billing.

Reopen Invoice

Reopens a voided or canceled invoice, changing its status back to open.

Replay Webhooks

Replays specified webhook deliveries in Maxio Advanced Billing.

Bulk Reset Subscription Components Price Points

Resets subscription component price points to their default values.

Resume Subscription

Resumes a paused subscription in Maxio (Chargify) Advanced Billing.

Retry Subscription

Retries payment for a past due subscription in Maxio (Chargify) Advanced Billing.

Revoke Billing Portal Access

Revokes billing portal access for a customer.

Send Invoice

Sends an invoice to the customer via email.

Send Request Update Payment Email

Sends an email to the customer requesting they update their payment method.

Unarchive Component Price Point

Unarchives a component price point, restoring it to active status.

Unarchive Offer

Unarchives a previously archived offer, making it available for new subscriptions again.

Unarchive product price point

Unarchives a product price point by its ID.

Update Automatic Subscription Resumption

Updates automatic resumption settings for a paused subscription in Maxio (Chargify) Advanced Billing.

Update Component

Updates a component's details in Chargify.

Update Component Price Point

Updates a price point for a component in Maxio Advanced Billing.

Update Coupon

Updates an existing coupon within a product family in Maxio.

Update Coupon Subcodes

Updates all subcodes for an existing coupon in Maxio Advanced Billing.

Update Customer

Updates an existing customer in Maxio/Chargify.

Update Invoice Customer Information

Updates customer information on an invoice in Maxio/Chargify.

Update Webhook Endpoint

Updates an existing webhook endpoint in Maxio Advanced Billing.

Update Payment Profile

Updates an existing payment profile in Maxio (Chargify).

Update Prepaid Expiration

Updates the expiration date of a prepaid usage allocation.

Update Product

Updates an existing product in Maxio/Chargify.

Update Product Family Component

Updates a component within its product family in Maxio/Chargify.

Update Product Price Point

Updates a product price point in Maxio Advanced Billing.

Update Reason Code

Updates an existing churn reason code in Maxio/Chargify Advanced Billing.

Update Subscription

Updates an existing subscription's details in Maxio/Chargify.

Bulk Update Subscription Component Price Points

Bulk updates component price points for a subscription.

Update Subscription Note

Updates an existing note on a subscription in Maxio/Chargify Advanced Billing.

Validate Coupon

Validates a coupon code for a product.

Void Advance Invoice

Voids an advance invoice for a subscription.

Void Invoice

Voids an open invoice to stop future collection.

FRAMEWORKS

How to build Maxio MCP Agent with another framework

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Maxio MCP with OpenAI Agents SDK

Claude Agent SDK logo

Claude Agent SDK

Use Maxio MCP with Claude Agent SDK

Claude Code logo

Claude Code

Use Maxio MCP with Claude Code

Claude Cowork logo

Claude Cowork

Use Maxio MCP with Claude Cowork

Codex logo

Codex

Use Maxio MCP with Codex

OpenClaw logo

OpenClaw

Use Maxio MCP with OpenClaw

Hermes logo

Hermes

Use Maxio MCP with Hermes

CLI logo

CLI

Use Maxio MCP with CLI

Google ADK logo

Google ADK

Use Maxio MCP with Google ADK

LangChain logo

LangChain

Use Maxio MCP with LangChain

Mastra AI logo

Mastra AI

Use Maxio MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Maxio MCP with LlamaIndex

CrewAI logo

CrewAI

Use Maxio MCP with CrewAI

FAQ

Frequently asked questions

With a standalone Maxio MCP server, the agents and LLMs can only access a fixed set of Maxio tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Maxio and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. Vercel AI SDK v6 fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Maxio tools.

Yes, absolutely. You can configure which Maxio scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Maxio data and credentials are handled as safely as possible.

Start with Maxio.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Maxio tool your agent needs.Free to start.

Start building
Customer stories

Teams ship real agents on Composio

GET STARTED FOR FREEBOOK A DEMO
agent.aiZoomLettaGleanHubSpotAWSWabi

Karan skipped his own birthday party to fix our critical issue. It was 10pm and he diverted his Waymo to help us instead. This really sets the bar — it shows the commitment you need when users rely on your software.

Harsha Gaddipati
Harsha Gaddipati
Co-founder, Slashy

A lot of students tell us that the moment their connected tools start talking to each other inside Opennote feels almost magical. The agent just knows them, and it's immensely helped keep new users on the platform.

Abhi Arya
Abhi Arya
Co-founder, Opennote

We chose Composio over Pipedream because it delivered depth where it mattered — niche tools and tricky edge cases other platforms simply ignored. That gave us confidence to scale without compromising.

Nirman Dave
Nirman Dave
CEO, Zams

As a solo builder, shipping fast is life or death. The only way I can outcompete incumbents is by outmanoeuvring them. Getting bogged down managing agent auth would have been a death sentence.

Ryan Yu
Ryan Yu
Founder, Extra Thursday

Before Composio, adding tool integrations was slow and resource-intensive. Each one could take weeks of engineering time, and maintaining them meant constantly keeping up with API changes.

Tomisin Jenrola
Tomisin Jenrola
Founder & CEO, SwarmZero

With hands-on help from their founder, we integrated Gmail and Google Drive in just 30 minutes. This level of personal support and commitment is exactly what startups should strive for.

Jerome Leclanche
Jerome Leclanche
Co-Founder, Ingram Technologies