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

builtwith-automation skill

safe

/builtwith-automation

This skill automates Builtwith tasks via Rube MCP, prioritizing tool discovery to ensure current schemas and active connections before execution.

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

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

Files (1)

SKILL.md

2.9 KB

---
name: builtwith-automation
description: "Automate Builtwith tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Builtwith Automation via Rube MCP

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

**Toolkit docs**: [composio.dev/toolkits/builtwith](https://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.

1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `builtwith`
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: "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](https://composio.dev)*

Overview

This skill automates Builtwith tasks by orchestrating Composio’s Builtwith toolkit through a Rube MCP connection. It guides discovery of live tool schemas, manages the Builtwith connection, and executes toolkit actions reliably. The workflow enforces schema compliance, session reuse, and pagination handling to avoid runtime errors.

How this skill works

The skill first calls RUBE_SEARCH_TOOLS to retrieve current tool slugs, input schemas, and recommended execution plans. It verifies and activates the Builtwith connection via RUBE_MANAGE_CONNECTIONS. Finally it runs tools using RUBE_MULTI_EXECUTE_TOOL (including a memory object and session_id), or bulk workflows via RUBE_REMOTE_WORKBENCH when appropriate.

When to use it

Automate Builtwith lookups and technology stack discovery at scale
Integrate Builtwith data into agent workflows or pipelines
Run bulk or scheduled Builtwith queries using Composio tooling
When tool schemas may change frequently and live discovery is required
During multi-step workflows that need session state and pagination handling

Best practices

Always call RUBE_SEARCH_TOOLS first to fetch live tool schemas and avoid hardcoded fields
Verify Builtwith connection status via RUBE_MANAGE_CONNECTIONS and complete any returned auth flow until ACTIVE
Pass an explicit memory object (even {}) in RUBE_MULTI_EXECUTE_TOOL calls
Reuse session_id across a workflow; generate new sessions only for new workflows
Inspect responses for pagination tokens and iterate until all data is retrieved

Example use cases

Discover technologies across a list of domains by searching tools, then executing a Builtwith lookup tool per domain
Automate regular audits of customer stacks and store results in downstream systems via RUBE_MULTI_EXECUTE_TOOL
Run bulk operations using RUBE_REMOTE_WORKBENCH and run_composio_tool() for high-volume analysis
Create an interactive agent that searches tool schemas, prompts for missing args, checks connection status, and executes the selected Builtwith tool

FAQ

Do I need API keys to use Rube MCP?

No API keys are required for the MCP endpoint; add https://rube.app/mcp to your client configuration to connect.

What if RUBE_SEARCH_TOOLS returns a different schema than I expected?

Treat the returned schema as authoritative. Update your arguments to match exact field names and types, and re-run discovery before execution.