# Bridgecore — plain words to n8n workflow (`bridgecore/bridgecore-automation-planner`) Actor

Say what should happen in plain words ('when a typeform is submitted add a row to google sheets and send a slack message'). Get the right tool for each step from 3,500+ app capabilities, an importable n8n workflow, or the call itself (do mode). Built for AI agents. Blanks listed honestly.

- **URL**: https://apify.com/bridgecore/bridgecore-automation-planner.md
- **Developed by:** [Bridgecore](https://apify.com/bridgecore) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 automation (recipes + plan + n8n workflow)s

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Bridgecore — plain words to n8n workflow (automation planner for people and AI agents)

Say what should happen, in plain words. Bridgecore picks the right tool for each step from **3,597 app capabilities** (n8n nodes incl. AI steps, OpenAPI services, MCP servers) and gives you back an **importable n8n workflow JSON**, the matching ready-made recipes, and the honest list of blanks only you can fill. Or, in `do` mode, it finds the one capability your sentence needs and **makes the call** for you.

```
when a typeform is submitted add a row to google sheets and send a slack message to #leads
```

→ Typeform Trigger → Google Sheets (append row) → Slack (#leads filled in) · blanks: the sheet · accounts: Typeform, Google, Slack.

No login to any app is needed to plan. Nothing you say is stored beyond the run's own dataset.

### What you can ask for

| You say | You get |
|---|---|
| `when a new email arrives in gmail summarize it with openai and send the summary to slack` | Gmail Trigger → OpenAI (prompt written) → Slack, 3 accounts to connect |
| `when a shopify order is paid text the customer a thank you` | Shopify Trigger → Twilio SMS, phone taken from the order |
| `when a github issue is opened classify it with an ai agent and comment` | GitHub Trigger → AI Agent (tools attached) → GitHub comment |
| `when a hubspot contact is created send me a telegram message` | HubSpot Trigger → Telegram |
| `text +15551234567 saying the report is ready` (`output: do`) | the exact Twilio request, dry-run first; `dry_run: false` sends it |

Works for lead capture, order notifications, alerts and monitoring, social posting, AI summaries and classification, agent workflows — any app n8n, an OpenAPI spec or an MCP server can reach (Google Sheets, Slack, Gmail, Notion, Airtable, HubSpot, Shopify, Stripe, Telegram, Discord, Twilio, OpenAI, Gemini, Claude and hundreds more).

### Input

| Field | Meaning |
|---|---|
| `needs` | One automation per line. Start with **when …** for the trigger. |
| `output` | `all` (default: recipes + plan + workflow) · `recipe` · `plan` · `workflow` · `do` |
| `inputs` | `do` mode: values for the capability's inputs by name, e.g. `{"to": "+1555…", "body": "hi"}` |
| `auth` | `do` mode: headers the call needs, e.g. `{"Authorization": "Bearer …"}` — used inside this run only, masked, never stored |
| `dry_run` | `do` mode: `true` (default) shows the exact request and sends nothing; `false` makes the call |

Example input:

```json
{ "needs": ["when a typeform is submitted add a row to google sheets and send a slack message to #leads"], "output": "all" }
```

### Output (one dataset item per need)

- `plan.steps[]` — `text`, `kind` (trigger/action), `tool` (`id`, `app`, `summary`, `inputs`, `auth`) or `gap` when the named app cannot do that step. **A gap is reported, never papered over with another app.**
- `workflow` — importable n8n JSON (nodes wired in order, said values filled). Import it in n8n, connect the accounts, test, turn on.
- `blanks[]` — what only you can fill (`node`, `need`). `accounts[]` — credentials to connect.
- `recipes[]` — tested ready-made recipes that match, each with its own workflow JSON; `public_templates[]` — matching public n8n templates by title and official link.
- `do` mode returns `steps[]` instead: per step the matched `capability`, `request` (method, url, headers masked, body), `missing[]` inputs, and when `dry_run: false` the service's `status`, `data` or `error`; plus `ran`, `charged` and `fee_usd` so you can see exactly what was billed.

### For AI agents (Apify MCP, OpenAI/Claude tool use, LangChain, CrewAI…)

This Actor is exposed by the Apify MCP server (`https://mcp.apify.com`) like every Store Actor. An agent can call it without reading this page:

```
call-actor  bridgecore/bridgecore-automation-planner
input       {"needs": ["<the user's sentence>"], "output": "plan"}
```

Use `output: "plan"` when you only need the right tool per step, `"workflow"` when the user wants something to import into n8n, `"do"` when the user wants the thing done now (dry run first, then `dry_run: false` with the user's own `auth`). The result is plain JSON; `gap` entries tell you what to ask the user.

The same engine is reachable without Apify as the MCP server **`io.github.chinlee2200-dotcom/bridgecore`** (official MCP registry · Smithery · Glama) with tools `do`, `find_recipe`, `plan_automation`, `make_n8n_workflow`, and as the free site https://bridgecore.chinlee2200.workers.dev .

### Pricing (pay per event — nothing is charged for a need that errors)

| Event | When | Price |
|---|---|---|
| `automation` (default) | one need answered with recipes + plan + workflow | $0.05 |
| `recipe` / `plan` / `workflow` | one need answered with just that part | $0.02 |
| `run` | one **successful real call** in `do` mode | $0.05 — dry runs, errors, missing inputs and 4xx/5xx replies are never charged |

Compute is included in the event price.

### How it decides (so you can trust or doubt it)

- The engine indexes **real node descriptions** from n8n (565 nodes, 121 AI/agent nodes), OpenAPI specs and MCP `tools/list` — one capability per resource/operation. Matching is measured: single-step top-1 93 %, top-3 100 %; multi-step "every step right" 61/61 on the held-out set (2026-10-14).
- Values you say out loud (emails, phone numbers, #channels, trigger events) are filled; everything else is left as a named blank rather than guessed.
- Workflows are shape-checked against n8n's own validator, but **you test them in n8n before turning them on**.
- Public templates are listed by title and official link only; open the link on n8n.io to use them.

### FAQ

**Is this an n8n template scraper?** No. It designs a workflow for *your* sentence and only points to public templates by title and link.
**Does it store my API keys?** No. `auth` is used inside the run that received it and masked in every output.
**Does it need an n8n account?** Planning: no. Importing the workflow: yes, any n8n (Cloud or self-hosted).
**Which apps?** Anything n8n has a node for, plus any OpenAPI service or MCP server in the index. If an app cannot do a step, the plan says `gap`.

Source: github.com/chinlee2200-dotcom/Laboratory- (`core/`, `apify/bridgecore-actor`). Issues and requests welcome there.

# Actor input Schema

## `needs` (type: `array`):

Plain words. Start with 'when …' for the trigger. Each line is one automation.

## `output` (type: `string`):

recipe = ready-made recipes that match (+ public n8n templates) · plan = trigger + actions with the tool for each step · workflow = importable n8n workflow JSON + blanks + accounts · all = everything · do = the broker's hand: find the capability for the need, fill inputs, make the call (dry run by default) — one `run` event per successful real call

## `inputs` (type: `object`):

Values for the capability's inputs by name, e.g. {"body": "hello"}. A dry run lists what is still missing.

## `auth` (type: `object`):

Headers the call needs, e.g. {"Authorization": "Bearer …"}. Used for the call inside this run only — never logged, never in the dataset, never sent anywhere but the service the capability names.

## `dry_run` (type: `boolean`):

true (default): show the exact request, send nothing, charge nothing. false: make the call.

## Actor input object example

```json
{
  "needs": [
    "when a typeform is submitted add a row to google sheets and send a slack message to #leads"
  ],
  "output": "all",
  "inputs": {},
  "dry_run": true
}
```

# Actor output Schema

## `automations` (type: `string`):

JSON array of results, one per need: { need, recipes, public_templates, plan, workflow, blanks, accounts, problems, error }.

## `workflows` (type: `string`):

Same items, trimmed to the need and the importable n8n workflow JSON.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "needs": [
        "when a typeform is submitted add a row to google sheets and send a slack message to #leads"
    ],
    "inputs": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("bridgecore/bridgecore-automation-planner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "needs": ["when a typeform is submitted add a row to google sheets and send a slack message to #leads"],
    "inputs": {},
}

# Run the Actor and wait for it to finish
run = client.actor("bridgecore/bridgecore-automation-planner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "needs": [
    "when a typeform is submitted add a row to google sheets and send a slack message to #leads"
  ],
  "inputs": {}
}' |
apify call bridgecore/bridgecore-automation-planner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bridgecore/bridgecore-automation-planner"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yo7Zc1B6h4lRGt3si/builds/83rzRPZ0hDLxTPW6w/openapi.json