home / skills / composiohq / awesome-claude-skills / lemon_squeezy-automation

lemon_squeezy-automation skill

/lemon_squeezy-automation

This skill automates Lemon Squeezy tasks via Rube MCP, discovering tools first and executing compliant operations for products, orders, subscriptions, and

npx playbooks add skill composiohq/awesome-claude-skills --skill lemon_squeezy-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.1 KB
---
name: lemon_squeezy-automation
description: "Automate Lemon Squeezy tasks via Rube MCP (Composio): products, orders, subscriptions, checkouts, and digital sales. Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Lemon Squeezy Automation via Rube MCP

Automate Lemon Squeezy operations through Composio's Lemon Squeezy toolkit via Rube MCP.

**Toolkit docs**: [composio.dev/toolkits/lemon_squeezy](https://composio.dev/toolkits/lemon_squeezy)

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Lemon Squeezy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy`
- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas

## Setup

**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.

1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy`
3. If connection is not ACTIVE, follow the returned auth link to complete setup
4. Confirm connection status shows ACTIVE before running any workflows

## Tool Discovery

Always discover available tools before executing workflows:

```
RUBE_SEARCH_TOOLS: queries=[{"use_case": "products, orders, subscriptions, checkouts, and digital sales", "known_fields": ""}]
```

This returns:
- Available tool slugs for Lemon Squeezy
- Recommended execution plan steps
- Known pitfalls and edge cases
- Input schemas for each tool

## Core Workflows

### 1. Discover Available Lemon Squeezy Tools

```
RUBE_SEARCH_TOOLS:
  queries:
    - use_case: "list all available Lemon Squeezy tools and capabilities"
```

Review the returned tools, their descriptions, and input schemas before proceeding.

### 2. Execute Lemon Squeezy Operations

After discovering tools, execute them via:

```
RUBE_MULTI_EXECUTE_TOOL:
  tools:
    - tool_slug: "<discovered_tool_slug>"
      arguments: {<schema-compliant arguments>}
  memory: {}
  sync_response_to_workbench: false
```

### 3. Multi-Step Workflows

For complex workflows involving multiple Lemon Squeezy operations:

1. Search for all relevant tools: `RUBE_SEARCH_TOOLS` with specific use case
2. Execute prerequisite steps first (e.g., fetch before update)
3. Pass data between steps using tool responses
4. Use `RUBE_REMOTE_WORKBENCH` for bulk operations or data processing

## Common Patterns

### Search Before Action
Always search for existing resources before creating new ones to avoid duplicates.

### Pagination
Many list operations support pagination. Check responses for `next_cursor` or `page_token` and continue fetching until exhausted.

### Error Handling
- Check tool responses for errors before proceeding
- If a tool fails, verify the connection is still ACTIVE
- Re-authenticate via `RUBE_MANAGE_CONNECTIONS` if connection expired

### Batch Operations
For bulk operations, use `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` in a loop with `ThreadPoolExecutor` for parallel execution.

## Known Pitfalls

- **Always search tools first**: Tool schemas and available operations may change. Never hardcode tool slugs without first discovering them via `RUBE_SEARCH_TOOLS`.
- **Check connection status**: Ensure the Lemon Squeezy connection is ACTIVE before executing any tools. Expired OAuth tokens require re-authentication.
- **Respect rate limits**: If you receive rate limit errors, reduce request frequency and implement backoff.
- **Validate schemas**: Always pass strictly schema-compliant arguments. Use `RUBE_GET_TOOL_SCHEMAS` to load full input schemas when `schemaRef` is returned instead of `input_schema`.

## Quick Reference

| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Lemon Squeezy-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `lemon_squeezy` |
| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |

> **Toolkit docs**: [composio.dev/toolkits/lemon_squeezy](https://composio.dev/toolkits/lemon_squeezy)

Overview

This skill automates Lemon Squeezy tasks through Rube MCP (Composio) to manage products, orders, subscriptions, checkouts, and digital sales. It centralizes discovery, execution, and multi-step workflows while enforcing tool schema validation and connection checks. Always run tool discovery first to get current schemas and recommended execution plans.

How this skill works

The skill uses RUBE_SEARCH_TOOLS to discover available Lemon Squeezy tool slugs, input schemas, and execution guidance. After discovery, it runs operations via RUBE_MULTI_EXECUTE_TOOL and coordinates complex sequences with RUBE_REMOTE_WORKBENCH, passing data between steps and handling pagination, errors, and rate limits. Connection management is handled via RUBE_MANAGE_CONNECTIONS and schema lookups use RUBE_GET_TOOL_SCHEMAS when needed.

When to use it

  • Automating creation, update, or listing of Lemon Squeezy products and checkouts
  • Processing orders, managing subscriptions, or delivering digital sales automatically
  • Building multi-step workflows that require fetching then updating Lemon Squeezy data
  • Running bulk operations or parallel jobs against Lemon Squeezy resources
  • Ensuring schema-compliant tool calls when tool functionality may change

Best practices

  • Always call RUBE_SEARCH_TOOLS first — never hardcode tool slugs or input shapes
  • Verify Lemon Squeezy connection via RUBE_MANAGE_CONNECTIONS and ensure status is ACTIVE
  • Use RUBE_GET_TOOL_SCHEMAS when a tool returns schemaRef to validate inputs precisely
  • Implement pagination handling using next_cursor or page_token until results are exhausted
  • Handle errors and rate limits with retries, exponential backoff, and re-authentication flows
  • Use RUBE_REMOTE_WORKBENCH and ThreadPoolExecutor for safe, parallel bulk operations

Example use cases

  • Discover available checkout creation tools, create a checkout, then fetch the resulting order
  • List subscriptions with pagination, filter by status, and batch-cancel expired subscriptions
  • Update a product after fetching its current record to avoid duplicate creations
  • Run bulk file deliveries for digital sales using RUBE_REMOTE_WORKBENCH with run_composio_tool()
  • Automate re-authentication when an OAuth connection expires, then resume queued workflow

FAQ

Do I need API keys to use Rube MCP?

No. Add https://rube.app/mcp as an MCP server in your client configuration; no API keys are required.

What must I do before executing any Lemon Squeezy tool?

Run RUBE_SEARCH_TOOLS to discover current tool slugs and schemas, and confirm the Lemon Squeezy connection is ACTIVE via RUBE_MANAGE_CONNECTIONS.