# Stigg MCP

> Stigg brings billing and subscription management directly into your AI workflow. Use this MCP to provision new customers, manage active plans, or report usage metrics without leaving your client. You can handle the entire customer lifecycle—from initial account creation using rest_create_customer to tracking metered feature usage via gql_report_usage—all through natural conversation.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** billing, subscriptions, saas-pricing, usage-based-billing, customer-management

## Description

Stop switching between billing dashboards just to check a customer's status or adjust their plan. This connector lets you take full control of your entire pricing and packaging workflow, right from any MCP-compatible client. You can handle the whole customer journey, whether it’s creating a new account, updating details, provisioning a subscription, or canceling service when needed. Need to know how much usage a user has consumed? Just ask your agent to report the metered feature usage in real time for accurate billing. Because this MCP is hosted on Vinkius, you get access to these core operations—like customer profile retrieval and plan management—all from one place. Your AI acts like an instant, hands-on billing ops assistant that never gets tired of API calls.

## Tools

### rest_cancel_subscription
Cancels a customer's subscription account using the REST API.

### rest_create_customer
Creates an entirely new customer profile using the REST API.

### rest_create_subscription
Sets up a brand new subscription for a customer via the REST API.

### rest_get_customer
Retrieves all available details about an existing customer profile using the REST API.

### rest_get_subscription
Fetches all specific information regarding a given subscription plan via the REST API.

### gql_get_customer
Retrieves customer details using the flexible GraphQL query language.

### gql_get_entitlements_state
Checks the current state of a user's feature entitlements via GraphQL.

### gql_provision_customer
Creates and optionally provisions a subscription for a customer using GraphQL.

### gql_provision_subscription
Sets up a new subscription plan directly via the GraphQL endpoint.

### gql_report_usage
Reports metered feature usage data using the structured GraphQL query language.

### rest_report_usage
Records metered usage for billing purposes through a dedicated REST API call.

### rest_update_customer
Modifies existing details for a customer using the REST API.

## Prompt Examples

**Prompt:** 
```
Create a customer with ID 'cust_123', name 'Alice', and email 'alice@example.com' using REST.
```

**Response:** 
```
I've successfully created the customer 'Alice' (ID: cust_123) in Stigg. Would you like to provision a subscription for them now?
```

**Prompt:** 
```
Report 50 units of usage for feature 'api-calls' for customer 'cust_123'.
```

**Response:** 
```
Usage reported. I've added 50 units to the 'api-calls' feature for customer 'cust_123' via the REST API.
```

**Prompt:** 
```
Get the details for customer 'cust_123' using GraphQL.
```

**Response:** 
```
Retrieving data... Customer 'Alice' (cust_123) is currently active with email 'alice@example.com'. I can also list their active subscriptions if you'd like.
```

## Capabilities

### Manage Customer Profiles
Create new accounts or fetch existing customer details using both REST and GraphQL endpoints.

### Provision Subscriptions
Set up a new subscription for a customer or retrieve the current state of their active plans.

### Control Subscriptions
Cancel an existing subscription or update basic customer information when necessary.

### Track Usage Metrics
Report metered feature usage to ensure billing accuracy and enforce entitlements in real time.

## Use Cases

### Onboarding a new enterprise client
A Customer Success rep asks their agent: 'Create customer ID cust-456 and provision them the Enterprise plan.' The agent executes gql_provision_customer, ensuring both the account and the subscription are live immediately.

### Verifying usage limits during a sprint
A Developer runs into an apparent billing issue. They prompt their agent to 'Report 150 units of usage for feature X.' The agent uses rest_report_usage, providing immediate confirmation and allowing the dev to confirm if the limit was hit.

### Auditing a customer's plan status
A Product Manager needs to know what features 'cust-123' has access to. They ask their agent to use gql_get_entitlements_state, getting instant confirmation without opening the billing console.

### Handling service termination
Support receives a cancellation request. The rep directs the agent to 'Cancel subscription for cust-123.' The agent uses rest_cancel_subscription and confirms the status change, logging the action immediately.

## Benefits

- Avoid dashboard hopping: Instead of jumping between the Stigg console to check a customer's plan status or feature entitlements, you just ask your agent. It gives you the data instantly.
- Process complex lifecycle changes quickly: Need to create an account and immediately set up their first paid subscription? Use gql_provision_customer or rest_create_subscription in one go with simple instructions.
- Maintain billing accuracy: Don't rely on manual reporting for usage. Tell your agent to report the metered feature usage (like using gql_report_usage) so billing is always accurate and up-to-date.
- Flexible integration options: Whether you prefer calling out updates via rest_update_customer or fetching data through GraphQL, this MCP handles both REST and GraphQL actions for maximum flexibility.
- Centralized control: You can manage the entire customer journey—from initial provisioning to final cancellation using rest_cancel_subscription—without ever leaving your primary development environment or chat tool.

## How It Works

The bottom line is that your AI client turns complex billing API calls into simple, conversational instructions.

1. First, subscribe to this MCP on Vinkius and input your Stigg API Key.
2. Next, tell your AI client exactly what you need—for example, 'Get the details for customer X' or 'Report usage of feature Y'.
3. The agent uses the appropriate tool (like gql_get_customer or rest_report_usage) to perform the action and gives you a direct answer.

## Frequently Asked Questions

**How do I create a customer using the Stigg MCP?**
You use rest_create_customer or gql_provision_customer. You just need to tell your agent the necessary details, like name and email, and specify which endpoint you want to use.

**Is reporting usage difficult with Stigg?**
No. You simply ask your agent to report the metered feature usage by using gql_report_usage or rest_report_usage, providing only the units and the feature name.

**Can I retrieve customer details in multiple ways with Stigg?**
Yes. You can use both GraphQL (gql_get_customer) for flexible querying, or REST (rest_get_customer) if you prefer direct resource retrieval via API calls.

**What happens when I try to cancel a subscription?**
The agent executes rest_cancel_subscription. It confirms the cancellation and updates the customer's status immediately, making it visible in your chat history.

**Does Stigg handle complex provisioning?**
It does. You can use gql_provision_customer to provision both a new customer account and an associated subscription plan simultaneously.