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

zoho_bigin-automation skill

/zoho_bigin-automation

This skill automates Zoho Bigin operations through Rube MCP, enabling pipelines, contacts, companies, and products tasks with tools discovery and safe

npx playbooks add skill composiohq/awesome-claude-skills --skill zoho_bigin-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: zoho_bigin-automation
description: "Automate Zoho Bigin tasks via Rube MCP (Composio): pipelines, contacts, companies, products, and small business CRM. Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Zoho Bigin Automation via Rube MCP

Automate Zoho Bigin operations through Composio's Zoho Bigin toolkit via Rube MCP.

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

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Zoho Bigin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_bigin`
- 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 `zoho_bigin`
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": "pipelines, contacts, companies, products, and small business CRM", "known_fields": ""}]
```

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

## Core Workflows

### 1. Discover Available Zoho Bigin Tools

```
RUBE_SEARCH_TOOLS:
  queries:
    - use_case: "list all available Zoho Bigin tools and capabilities"
```

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

### 2. Execute Zoho Bigin 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 Zoho Bigin 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 Zoho Bigin 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 Zoho Bigin-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho_bigin` |
| 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/zoho_bigin](https://composio.dev/toolkits/zoho_bigin)

Overview

This skill automates Zoho Bigin CRM tasks through Rube MCP using the Composio zoho_bigin toolkit. It streamlines pipelines, contacts, companies, products, and small-business CRM operations while enforcing schema-driven, discover-first execution. Follow connection and discovery steps before running any workflows to avoid errors.

How this skill works

The skill first queries RUBE_SEARCH_TOOLS to discover current tool slugs, input schemas, recommended execution plans, and edge cases. It uses RUBE_MANAGE_CONNECTIONS to ensure an ACTIVE Zoho Bigin connection and then runs operations with RUBE_MULTI_EXECUTE_TOOL or bulk jobs via RUBE_REMOTE_WORKBENCH. Always fetch schemas with RUBE_GET_TOOL_SCHEMAS when schemaRef is returned and pass schema-compliant arguments to avoid failures.

When to use it

  • Automate routine CRM tasks: create/update contacts, companies, products, or pipeline stages
  • Run multistep workflows that must pass data between operations (fetch → transform → update)
  • Perform bulk imports or large edits using remote workbench and parallel execution
  • Check or refresh integrations when OAuth tokens may have expired
  • Validate tool capabilities and schemas before coding automation logic

Best practices

  • Always call RUBE_SEARCH_TOOLS first to discover available tool slugs and input schemas
  • Verify Zoho Bigin connection status with RUBE_MANAGE_CONNECTIONS and complete auth flow if not ACTIVE
  • Search for existing records before creating new ones to prevent duplicates
  • Use RUBE_GET_TOOL_SCHEMAS when schemaRef is present and validate all arguments strictly against the schema
  • Handle pagination by reading next_cursor or page_token until exhausted and implement retry/backoff for rate limits

Example use cases

  • Create contact records and link them to companies after confirming no duplicates via a search step
  • Advance deals through pipeline stages by fetching the current stage, applying business logic, then updating the deal
  • Bulk-update product pricing using RUBE_REMOTE_WORKBENCH with run_composio_tool() and ThreadPoolExecutor for parallelism
  • Refresh OAuth tokens via RUBE_MANAGE_CONNECTIONS then re-run failed workflows that returned auth errors
  • Export full contact lists with pagination handled, then import filtered results into another system

FAQ

Do I need API keys to use Rube MCP?

No API keys are required. Add the Rube MCP endpoint (https://rube.app/mcp) to your client configuration and use the RUBE_* tool calls.

What if tool schemas change?

Always run RUBE_SEARCH_TOOLS before executing actions. If a tool returns schemaRef, call RUBE_GET_TOOL_SCHEMAS to fetch the full, current schema and adjust arguments accordingly.