twelve-data-automation
by ComposioHQtwelve-data-automation helps Claude agents automate Twelve Data workflows through Composio Rube MCP. It covers setup, active twelve_data connection checks, RUBE_SEARCH_TOOLS discovery, and schema-aware usage for Workflow Automation.
This skill scores 66/100, which makes it acceptable but limited for directory listing. Directory users can understand that it is meant to route Twelve Data automation through Rube MCP and can follow the basic connection/discovery pattern, but they should expect to rely heavily on live tool discovery and external Composio toolkit docs rather than rich in-repository workflow guidance.
- Valid frontmatter with a clear MCP requirement (`rube`) and a concise description of automating Twelve Data via Composio.
- Provides prerequisite and setup steps, including checking `RUBE_SEARCH_TOOLS`, managing the `twelve_data` connection, and confirming ACTIVE status before workflows.
- Emphasizes tool discovery first, which should help agents obtain current tool schemas instead of relying on stale hard-coded parameters.
- No support files, scripts, resources, or README are present, so the listing depends entirely on a single SKILL.md.
- The available evidence is mostly a generic Rube MCP discovery/setup pattern; concrete Twelve Data workflows, example outputs, and task-specific edge cases are limited.
Overview of twelve-data-automation skill
What twelve-data-automation is for
twelve-data-automation is a Claude skill for automating Twelve Data workflows through Composio’s Rube MCP server. It is designed for agents that need to discover current Twelve Data tool schemas, verify an authenticated Twelve Data connection, and then run market-data-related operations without guessing tool names or request fields.
Best-fit users and workflows
This twelve-data-automation skill is a good fit if you already use Claude with MCP tools and want a repeatable way to request Twelve Data actions such as fetching financial market data, checking available toolkit operations, or building automation steps around Composio’s twelve_data toolkit. It is most useful for workflow automation where the available tools and schemas may change, because the skill explicitly instructs the agent to search tools first.
Main differentiator
The key value is not a large codebase or helper scripts; the repository contains a focused SKILL.md. Its main operational rule is important: use RUBE_SEARCH_TOOLS before execution so the agent works from the latest Rube MCP tool schema instead of relying on stale assumptions. That makes twelve-data-automation better suited to live MCP execution than a static prompt that invents parameters.
Adoption considerations
Before installing, confirm that your client can connect to MCP servers and that Rube MCP is available. You also need an active Twelve Data connection through RUBE_MANAGE_CONNECTIONS using the twelve_data toolkit. If your environment cannot use MCP tools, this skill will not execute Twelve Data operations by itself.
How to Use twelve-data-automation skill
twelve-data-automation install and setup path
Install the skill from the GitHub skill collection, then configure the MCP dependency:
npx skills add ComposioHQ/awesome-claude-skills --skill twelve-data-automation
In your MCP-capable client, add Rube MCP using:
https://rube.app/mcp
Then verify that RUBE_SEARCH_TOOLS is available. Use RUBE_MANAGE_CONNECTIONS with toolkit twelve_data; if the connection is not ACTIVE, complete the returned authorization flow before asking the agent to run any Twelve Data workflow.
Inputs the skill needs from you
For reliable twelve-data-automation usage, give the agent the actual data task, target instrument or symbol, timeframe, output format, and any constraints. Weak prompt: “Get stock data.” Stronger prompt: “Use twelve-data-automation to retrieve the latest available daily time series for AAPL from Twelve Data, confirm the active twelve_data connection first, discover the current tool schema with RUBE_SEARCH_TOOLS, and return the result as a concise table with timestamp, open, high, low, close, and volume if those fields are available.”
Practical workflow for agents
A good run usually follows this sequence:
- Call
RUBE_SEARCH_TOOLSfor the specific use case, not a generic search. - Reuse the returned session ID when checking available operations.
- Confirm the Twelve Data connection is active with
RUBE_MANAGE_CONNECTIONS. - Select the matching tool slug and fill parameters from the discovered schema.
- Execute the workflow and summarize results, including any missing fields or API limitations.
This pattern matters because Twelve Data and Composio tool schemas can evolve. The skill’s “search first” discipline reduces failed calls caused by outdated parameter names.
Repository files to read first
Start with composio-skills/twelve-data-automation/SKILL.md. There are no separate README.md, rules/, resources/, references/, or scripts in the file tree, so the skill’s behavior is concentrated in that one file. Pay close attention to the “Prerequisites,” “Setup,” “Tool Discovery,” and “Core Workflow Pattern” sections before judging whether it fits your environment.
twelve-data-automation skill FAQ
Is twelve-data-automation only for financial market data?
Yes, its scope is specifically Twelve Data operations exposed through Composio’s twelve_data toolkit. It is not a general finance-analysis framework, backtesting engine, or portfolio optimizer. It helps an agent access and automate available Twelve Data tools; your prompt still needs to define the desired market-data task.
How is this better than an ordinary prompt?
A normal prompt may ask Claude to “use Twelve Data,” but it may not know the current MCP tool slugs or required input schema. The twelve-data-automation skill forces a tool-discovery step with RUBE_SEARCH_TOOLS, then uses the active Rube MCP connection. That makes it more dependable for Workflow Automation where execution accuracy matters.
Is it beginner-friendly?
It is beginner-friendly if you already have an MCP-enabled client and can follow an auth link for the Twelve Data connection. It is less suitable for users expecting a one-click web app or a standalone package. The main setup work is connecting Rube MCP and activating the twelve_data toolkit.
When should I not use it?
Do not use this skill if you cannot run MCP tools, do not want to connect Composio/Rube, or need a static offline library. It is also not the right fit if your task requires guaranteed schemas without runtime discovery; the skill intentionally depends on searching current tools first.
How to Improve twelve-data-automation skill
Improve prompts by specifying the exact data job
The fastest way to improve twelve-data-automation output is to replace broad market-data requests with operational instructions. Include symbol, asset type, interval, date range, preferred fields, timezone expectations, and output format. For example: “Fetch intraday EUR/USD data at 15-minute granularity for the last trading day and return only timestamp, open, high, low, close, with a note if the selected Twelve Data tool imposes a limit.”
Avoid common failure modes
Common failures include skipping RUBE_SEARCH_TOOLS, assuming a connection is active, using stale parameter names, or asking for a result without defining the instrument and interval. If a call fails, ask the agent to show the discovered tool schema, selected tool slug, required fields, and which parameter was missing or rejected.
Iterate after the first result
After the first output, refine based on what the tool actually returned. If fields are missing, ask whether the schema supports them. If the result is too broad, add filters such as date range, symbol exchange, or interval. If the response is hard to use, request a normalized table, JSON object, CSV-ready rows, or a short execution summary.
Strengthen the skill locally
Because the upstream skill is compact, teams can improve it by adding local examples for their recurring Twelve Data workflows: standard symbol formats, preferred intervals, expected output columns, and organization-specific error handling. Keep the core rule intact: in any customized twelve-data-automation guide, require tool discovery before execution so the agent stays aligned with live Rube MCP schemas.