What is zyte-api-automation?

It automates Zyte API tasks via Rube MCP (Composio) and requires always searching tool schemas first.

Do I need an active Zyte API connection?

Yes. Ensure RUBE_MANAGE_CONNECTIONS indicates ACTIVE for the zyte_api toolkit before running workflows.

How do I discover available tools?

Use RUBE_SEARCH_TOOLS with a Zyte API use case (e.g., 'Zyte API operations') to retrieve tool slugs and their input schemas.

zyte-api-automation

Scanned

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

Files (1)

SKILL.md

2.9 KB

Zyte API Automation via Rube MCP

Automate Zyte API operations through Composio's Zyte API toolkit via Rube MCP.

Toolkit docs: composio.dev/toolkits/zyte_api

Prerequisites

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

Step 2: Check Connection

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

Overview

Automate Zyte API operations through Composio's Zyte API toolkit via Rube MCP. This skill emphasizes always searching tool schemas first to ensure up-to-date inputs and slugs, and relies on a connected Zyte API setup.

How This Skill Works

The workflow begins by discovering available Zyte API tools with RUBE_SEARCH_TOOLS to obtain current slugs and input schemas. Next, validate that the Zyte API connection is ACTIVE via RUBE_MANAGE_CONNECTIONS, then execute one or more tools with RUBE_MULTI_EXECUTE_TOOL, including the memory parameter. Always perform discovery before execution to adapt to schema changes.

When to Use It

Setting up a Zyte API automation workflow from scratch and validating the connection
Automating a Zyte API task using a discovered tool slug and schema
Ensuring tool schemas are current before running a workflow by re-discovering tools
Running a sequence of Zyte API operations within a single session
Troubleshooting tool changes by verifying schemas and connection status before execution

Quick Start

Step 1: Add https://rube.app/mcp as an MCP server in your client config (no API keys needed)
Step 2: Verify RUBE_SEARCH_TOOLS responds and returns Zyte API tool slugs and schemas
Step 3: Connect zyte_api with RUBE_MANAGE_CONNECTIONS, then discover tools and execute using RUBE_MULTI_EXECUTE_TOOL with memory

Best Practices

Always search first with RUBE_SEARCH_TOOLS to get current tool slugs and schemas
Check that the Zyte API connection is ACTIVE via RUBE_MANAGE_CONNECTIONS before executing tools
Use exact field names and types as returned in the tool schemas
Include memory in every RUBE_MULTI_EXECUTE_TOOL call, even if empty
Reuse session IDs for related workflows and generate new ones for separate tasks

Example Use Cases

Discover Zyte API tasks, pick a tool slug from RUBE_SEARCH_TOOLS, then execute with RUBE_MULTI_EXECUTE_TOOL
Connect to Zyte via RUBE_MANAGE_CONNECTIONS, verify ACTIVE, and run a sequence of operations in a single session
Re-run RUBE_SEARCH_TOOLS after a schema change to refresh inputs before execution
Execute multiple Zyte tools in one workflow by passing discovered slugs and memory object across calls
Inspect full tool schemas with RUBE_GET_TOOL_SCHEMAS to validate inputs before running a Zyte task

Frequently Asked Questions

Add this skill to your agents