What is builtwith-automation?

A framework to automate Builtwith tasks using Composio’s Rube MCP, emphasizing live tool schemas discovered via RUBE_SEARCH_TOOLS and an active Builtwith connection.

What prerequisites are required?

Rube MCP must be connected with RUBE_SEARCH_TOOLS available, an active Builtwith connection via RUBE_MANAGE_CONNECTIONS with toolkit 'builtwith', and you must always search tools first to get current schemas.

How do I handle changing tool schemas?

Always fetch current schemas with RUBE_SEARCH_TOOLS before executing. Do not hardcode tool slugs or arguments; adapt your workflow to the live results and ensure memory is included in multi-execute calls.

builtwith-automation

Scanned

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

Files (1)

SKILL.md

2.9 KB

Builtwith Automation via Rube MCP

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

Toolkit docs: composio.dev/toolkits/builtwith

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Builtwith connection via RUBE_MANAGE_CONNECTIONS with toolkit builtwith
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 builtwith
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: "Builtwith 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 Builtwith task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["builtwith"]
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 Builtwith-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `builtwith`
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/builtwith-automation/SKILL.mdView on GitHub

Overview

Builtwith-automation orchestrates Builtwith operations using Composio’s Rube MCP toolkit. It relies on live tool schemas discovered through RUBE_SEARCH_TOOLS and requires an active Builtwith connection to ensure accurate inputs and reliable executions.

How This Skill Works

Discover available Builtwith tools with RUBE_SEARCH_TOOLS, then verify and manage the connection with RUBE_MANAGE_CONNECTIONS. Once the toolkit is ACTIVE, execute tools via RUBE_MULTI_EXECUTE_TOOL, supplying the correct memory payload and a session_id. Always use the latest tool schemas from search results to prevent failures.

When to Use It

When you need to orchestrate a Builtwith operation across multiple domains and must fetch current tool schemas first
When you must confirm the Builtwith connection is ACTIVE before running workflows
When executing multiple Builtwith tasks within a single or related sessions to preserve context
When tool schemas change and hardcoding slugs or arguments would break automation
When performing bulk Builtwith operations and requiring exact input schemas from RUBE_SEARCH_TOOLS

Quick Start

Step 1: Add https://rube.app/mcp as an MCP server and verify RUBE_SEARCH_TOOLS responds
Step 2: Call RUBE_MANAGE_CONNECTIONS with toolkit 'builtwith' and ensure the status is ACTIVE
Step 3: Use RUBE_SEARCH_TOOLS to discover tools, then run RUBE_MULTI_EXECUTE_TOOL with the chosen tool_slug, proper arguments, memory, and a session_id

Best Practices

Always call RUBE_SEARCH_TOOLS before executing to get current tool slugs and schemas
Verify RUBE_MANAGE_CONNECTIONS reports ACTIVE for the builtwith toolkit
Use exact field names and types from the search results; avoid hardcoding
Include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty
Reuse session IDs within a workflow; generate new ones for new workflows; check pagination tokens and fetch until complete

Example Use Cases

Discover Builtwith tools for a list of domains and execute a corresponding RUBE_MULTI_EXECUTE_TOOL per domain using the latest schemas
Batch-update Builtwith technology profiles for multiple domains by looping through discovered tool slugs and arguments
Before a data-collection run, validate that the Builtwith connection is ACTIVE and then execute with a single session_id
Reuse an existing session_id across related Builtwith tasks to maintain context and reduce setup steps
Encounter a schema change; re-run RUBE_SEARCH_TOOLS to fetch updated slugs and adjust execution calls accordingly

Frequently Asked Questions

Add this skill to your agents