Do I need API keys to use Coinranking automation via Rube MCP?

No API keys are required. You simply add the MCP endpoint and connect the Coinranking toolkit; all tool schemas are retrieved dynamically via RUBE_SEARCH_TOOLS.

What should I do if tool schemas change?

Always call RUBE_SEARCH_TOOLS first to fetch the latest tool slugs and input schemas before executing any tool.

What is the recommended sequence for a workflow?

Discover tools with RUBE_SEARCH_TOOLS, check and establish the active connection with RUBE_MANAGE_CONNECTIONS, then execute tools with RUBE_MULTI_EXECUTE_TOOL using the discovered slugs and memory payload.

coinranking-automation

Scanned

npx machina-cli add skill ComposioHQ/awesome-claude-skills/coinranking-automation --openclaw

Files (1)

SKILL.md

2.9 KB

Coinranking Automation via Rube MCP

Automate Coinranking operations through Composio's Coinranking toolkit via Rube MCP.

Toolkit docs: composio.dev/toolkits/coinranking

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Coinranking connection via RUBE_MANAGE_CONNECTIONS with toolkit coinranking
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.

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

Tool Discovery

Always discover available tools before executing workflows:

RUBE_SEARCH_TOOLS
queries: [{use_case: "Coinranking operations", known_fields: ""}]
session: {generate_id: true}

This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.

Core Workflow Pattern

Step 1: Discover Available Tools

RUBE_SEARCH_TOOLS
queries: [{use_case: "your specific Coinranking task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["coinranking"]
session_id: "your_session_id"

Step 3: Execute Tools

RUBE_MULTI_EXECUTE_TOOL
tools: [{
  tool_slug: "TOOL_SLUG_FROM_SEARCH",
  arguments: {/* schema-compliant args from search results */}
}]
memory: {}
session_id: "your_session_id"

Known Pitfalls

Always search first: Tool schemas change. Never hardcode tool slugs or arguments without calling RUBE_SEARCH_TOOLS
Check connection: Verify RUBE_MANAGE_CONNECTIONS shows ACTIVE status before executing tools
Schema compliance: Use exact field names and types from the search results
Memory parameter: Always include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty ({})
Session reuse: Reuse session IDs within a workflow. Generate new ones for new workflows
Pagination: Check responses for pagination tokens and continue fetching until complete

Quick Reference

Operation	Approach
Find tools	`RUBE_SEARCH_TOOLS` with Coinranking-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `coinranking`
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`

Powered by Composio

Source

git clone https://github.com/ComposioHQ/awesome-claude-skills/blob/master/composio-skills/coinranking-automation/SKILL.md

View on GitHub

Overview

Automate Coinranking operations using Composio's Rube MCP toolkit. It requires connecting Rube MCP, Coinranking toolkit, and always calling RUBE_SEARCH_TOOLS to fetch current tool schemas before executing. This keeps workflows aligned with the latest tool definitions.

How This Skill Works

Discover available Coinranking tools with RUBE_SEARCH_TOOLS, then verify and manage the Coinranking connection via RUBE_MANAGE_CONNECTIONS. After selecting a tool slug from the results, execute it with RUBE_MULTI_EXECUTE_TOOL using the exact input schema and include a memory payload. All steps rely on an active session and current tool schemas.

When to Use It

When you need to automate recurring Coinranking tasks using up-to-date tool schemas
When starting a new Coinranking workflow and you must fetch current tool slugs and inputs
When validating the Coinranking connection is ACTIVE before execution
When performing a sequence of tool executions that depend on previously discovered schemas
When performing bulk or multi-tool operations via the Composio workflow pattern

Quick Start

Step 1: Add https://rube.app/mcp as an MCP server in your client and verify RUBE_SEARCH_TOOLS responds
Step 2: Run RUBE_MANAGE_CONNECTIONS with toolkits: [coinranking] and complete any auth flow until status is ACTIVE
Step 3: Use RUBE_SEARCH_TOOLS to discover available Coinranking tools, then execute a chosen tool with RUBE_MULTI_EXECUTE_TOOL using the memory parameter

Best Practices

Always run RUBE_SEARCH_TOOLS first to get current tool schemas
Check the connection with RUBE_MANAGE_CONNECTIONS and ensure ACTIVE status
Use exact field names and types from the search results; do not hardcode slugs
Include memory in every RUBE_MULTI_EXECUTE_TOOL call, even if empty
Reuse session IDs within a workflow and regenerate for new workflows

Example Use Cases

Daily Coinranking metrics: discover tools, verify connection, and run a price fetch tool with current inputs
Bulk price checks for a list of coins by iterating tool slugs discovered via RUBE_SEARCH_TOOLS
New Coinranking integration: add Rube MCP, authenticate, then execute a starter tool from discovered results
Handle paginated coin lists by continuing searches until completion using provided tokens
Multi-tool execution: discover, validate, and run several Coinranking tools in a single session

Frequently Asked Questions

Add this skill to your agents