johnxie · Oct 22, 2026 · Oct 23, 2026
diff --git a/README.md b/README.md
@@ -15,6 +15,10 @@ Building a Taskade integration for another platform (n8n, Activepieces, Make, Pi
 | n8n | Source in [`packages/n8n-nodes-taskade`](packages/n8n-nodes-taskade) (package `n8n-nodes-taskade` 0.2.0). Not yet published to npm. |
 | Activepieces, Make, Pipedream | Planned. No code in this repo yet. |
 
+## Recipes
+
+Step-by-step recipes connect Taskade with Make, n8n, Square and any app with an API key today. They use the Taskade webhook trigger, the HTTP step and the Public Action API v2. Start at the [recipes index](recipes/README.md).
+
 ## Zapier app capabilities
 
 | Type | Keys | Notes |

diff --git a/recipes/README.md b/recipes/README.md
@@ -0,0 +1,39 @@
+# Recipes
+
+These recipes connect Taskade with tools that have no official Taskade app yet, or whose app is still in review. Each recipe uses only what ships in Taskade today:
+
+- The **When a webhook arrives** trigger in a Taskade automation, for events that another tool sends to Taskade.
+- The **Send HTTP Request** step with its **Authentication** panel, for calls from Taskade to another tool.
+- The [Public Action API v2](https://www.taskade.com/api/documentation/v2) at `https://www.taskade.com/api/v2`, for calls from another tool to Taskade.
+
+| Recipe | Who it is for | Uses |
+|---|---|---|
+| [Use Taskade with Make today](make.md) | Make users, until the official Make app passes review | Public API, Send HTTP Request |
+| [Use Taskade with n8n today](n8n.md) | n8n users, until the Taskade node is on npm | Public API, Send HTTP Request |
+| [Connect Square to Taskade](square.md) | Teams that take payments in Square | Webhook trigger, Send HTTP Request with a Bearer Token |
+| [Connect any app with an API key](any-app-with-an-api-key.md) | Teams whose tool is not in the 100+ integrations | Send HTTP Request with Custom auth, webhook trigger, Public API |
+
+## Before you start
+
+| You need | Where |
+|---|---|
+| A personal access token (starts with `tskdp_`) | Taskade **Settings** > **API** > **Personal access tokens** > **Create token**. A verified email is required, and you can keep up to 5 active tokens |
+| A project ID | Open the project. The ID is in the address bar after `/d/` |
+| The Pro plan or higher | Only for the **When a webhook arrives** trigger and **Outgoing webhooks** |
+
+Every Public API v2 operation is a `POST` with a JSON body and the header `Authorization: Bearer tskdp_YOUR_TOKEN`. A first call that lists the workspaces your token can reach:
+
+```bash
+curl https://www.taskade.com/api/v2/listSpaces \
+  -H "Authorization: Bearer tskdp_YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{}'
+```
+
+## Keep secrets out of headers
+
+Put an API key or a token only in the **Authentication** panel of the **Send HTTP Request** step. Taskade saves that panel as an encrypted credential and sends it only when the step runs. The **Headers** and **Query params** fields are saved as plain text in the automation, so everyone who can open the automation can read them.
+
+## Taskade EVE can build these
+
+Each recipe ends with a one-sentence prompt. Paste it into the Taskade EVE chat, and Taskade EVE builds the automation. If a step needs a key, Taskade EVE asks you to paste it into the **Authentication** panel of that step.
diff --git a/recipes/any-app-with-an-api-key.md b/recipes/any-app-with-an-api-key.md
@@ -0,0 +1,62 @@
+# Connect any app with an API key
+
+Taskade connects to 100+ integrations. If your app is not one of them, it can still join an automation when it has an API key or sends webhooks.
+
+**Who it is for:** Teams whose tool is not in the Taskade integrations list, but who can copy an API key from it.
+
+**What it does:** A Taskade automation calls the app with your saved API key, and the app sends its events to a Taskade automation.
+
+**Before you start:** You need an API key and the API docs of the app. The webhook part needs the Pro plan or higher.
+
+## Steps
+
+1. In the app, create an API key. In its API docs, find the header for the key, for example `Authorization: Bearer <key>` or `X-API-Key: <key>`.
+2. In a Taskade automation, add **Send HTTP Request** from the **Data & Text Tools** tab.
+3. Open **Authentication** and pick the **Auth Type** that the app expects: **Bearer Token**, **API Key** with a **Header Name**, or **Basic Auth**. Paste the key there.
+4. Set **Method**, **URL** and **Request Body Type** **JSON**. Set **Response Body Type** to **JSON**, so the next steps can use the answer.
+5. To hear from the app, create an automation with **When a webhook arrives**. Paste its **Webhook URL** into the webhook settings of the app.
+6. Set **Verify requests** to a mode that the app supports: **Bearer token**, **Stripe signature** or **HMAC-SHA256 signature**. Use **None** only when the app supports no check.
+7. If the app can run a script but cannot send webhooks, call the Taskade API from the script with a personal access token, as shown below.
+
+```bash
+curl https://www.taskade.com/api/v2/createTask \
+  -H "Authorization: Bearer tskdp_YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"projectId":"YOUR_PROJECT_ID","tasks":[{"contentType":"text/markdown","content":"Hello from my app","placement":"beforeend"}]}'
+```
+
+## Auth Type reference
+
+| Auth Type | Taskade sends |
+|---|---|
+| **Bearer Token** | `Authorization: Bearer <token>` |
+| **API Key** | `<Header Name>: <key>` |
+| **Basic Auth** | `Authorization: Basic base64(username:password)` |
+
+## Verify requests reference
+
+| Mode | What the sender must do |
+|---|---|
+| **Bearer token** | Send `Authorization: Bearer <token>`. Taskade makes the token when you turn on the automation |
+| **Stripe signature** | Send the `Stripe-Signature` header of a Stripe webhook endpoint. Paste its signing secret in Taskade |
+| **HMAC-SHA256 signature** | Send the hex HMAC-SHA256 of `<timestamp>.<raw body>` in `X-Taskade-Signature-V2` and the Unix time in seconds in `X-Taskade-Timestamp`. Taskade rejects a request more than 5 minutes old |
+| **None** | Nothing. Anyone with the URL can start the automation |
+
+## Check the result
+
+You are done when the **Send HTTP Request** step shows the answer of the app in its run, and an event from the app starts your webhook automation.
+
+## Notes
+
+- Never put a key in **Headers** or **Query params**. Taskade saves those fields as plain text in the automation, and everyone who can open the automation can read them.
+- The webhook takes JSON, `multipart/form-data` and `application/x-www-form-urlencoded` bodies up to about 1.5 MB. If the automation is off, the URL answers 404.
+- The **Send HTTP Request** step does not reach `localhost` or private network addresses.
+
+## Taskade EVE can build this for you
+
+> Build an automation that sends each new task in my Requests project to the Acme API with my saved API key.
+
+## Checked
+
+- Taskade steps, labels, the Auth Type and Verify requests options, and the `createTask` call: checked against the Taskade app and the [v2 spec](https://www.taskade.com/api/documentation/v2) on 2026-10-22.
+- The behavior of a specific third-party app is not covered. Read its API docs for the URL, the header and the webhook settings.
diff --git a/recipes/make.md b/recipes/make.md
@@ -0,0 +1,56 @@
+# Use Taskade with Make today
+
+The official Taskade app for Make is in review. [PR #34](https://github.com/taskade/integrations/pull/34) holds the app, and [issue #33](https://github.com/taskade/integrations/issues/33) tracks the Make review. Until Make approves it, connect Make and Taskade with the Make HTTP module and a Taskade automation.
+
+**Who it is for:** Make users who want a scenario to add tasks in Taskade, or to start when a task lands in Taskade.
+
+**What it does:** A Make scenario adds tasks to a Taskade project through the Taskade API, and a Taskade automation sends each new task to a Make scenario.
+
+**Before you start:** You need a Taskade account with a verified email and a Make account. The Taskade API takes a personal access token.
+
+## Steps
+
+1. In Taskade, open **Settings**, then **API**, and click **Create token** under **Personal access tokens**. Copy the token. It starts with `tskdp_`.
+2. Open the Taskade project for the new tasks. Copy the project ID from the address bar, after `/d/`.
+3. In Make, add the **HTTP** app's **Make a request** module. Set the method to `POST` and the URL to `https://www.taskade.com/api/v2/createTask`.
+4. Add the header `Authorization` with the value `Bearer tskdp_YOUR_TOKEN`. Add the header `Content-Type` with the value `application/json`.
+5. Before the HTTP module, add the **JSON** app's **Create JSON** module. Give it the structure of the body below, and map your Make values into `content`.
+6. In the HTTP module, set the body to raw JSON and map the **JSON string** output of **Create JSON** as the request content. Do not type mapped values into raw JSON text. Raw text does not escape a quote or a line break in a value, so a name such as `Jane "JJ" Doe` breaks the request.
+7. Run the scenario once. Make sure that Taskade answers `{"ok":true,...}` and that the task shows in your project.
+8. To start a scenario from Taskade, copy the URL of a Make **Custom webhook** module. In a Taskade automation, add **When a task is added**, then **Send HTTP Request** with **Method** `POST`, that **URL** and **Request Body Type** **JSON**.
+
+Request body for step 5:
+
+```json
+{
+  "projectId": "YOUR_PROJECT_ID",
+  "tasks": [
+    { "contentType": "text/markdown", "content": "New lead: {{name}}", "placement": "beforeend" }
+  ]
+}
+```
+
+Answer from Taskade:
+
+```json
+{ "ok": true, "items": [{ "id": "NEW_TASK_ID" }] }
+```
+
+## Check the result
+
+You are done when a Make run adds a task to your project, and a new Taskade task starts your Make scenario. The **When a task is added** trigger waits about 5 minutes after the last edit of a task.
+
+## Notes
+
+- Anyone who can edit the scenario can read the token in the header. Give the token its own name, such as `make`, and revoke it in **Settings** > **API** when you stop.
+- `createTask` takes 1 to 20 tasks per call, and each `content` holds up to 2,000 characters. `placement` is `beforeend` (last) or `afterbegin` (first).
+- For Taskade events such as a task assigned or a comment added, paste the Make URL into **Settings** > **API** > **Outgoing webhooks** (Pro and above). No automation is needed for those events.
+
+## Taskade EVE can build this for you
+
+> Build an automation that sends every new task in my Leads project to my Make webhook URL.
+
+## Checked
+
+- Taskade steps, labels and the `createTask` body: checked against the Taskade app and the [v2 spec](https://www.taskade.com/api/documentation/v2) on 2026-10-22.
+- Make labels (**HTTP**, **Make a request**, **Custom webhook**, **JSON**, **Create JSON**, **JSON string**): taken from Make's public docs. Not checked in a Make account.
diff --git a/recipes/n8n.md b/recipes/n8n.md
@@ -0,0 +1,51 @@
+# Use Taskade with n8n today
+
+The Taskade node for n8n is ready for n8n verification in [PR #32](https://github.com/taskade/integrations/pull/32), and [issue #17](https://github.com/taskade/integrations/issues/17) tracks the npm publish and the n8n review. The node is not on npm yet. Until it is, connect n8n and Taskade with the built-in n8n nodes and a Taskade automation.
+
+**Who it is for:** n8n users, on n8n Cloud or self-hosted, who want a workflow to read or write Taskade.
+
+**What it does:** An n8n workflow adds tasks to a Taskade project through the Taskade API, and a Taskade automation starts an n8n workflow with each new task.
+
+**Before you start:** You need a Taskade account with a verified email. Taskade must reach your n8n over the public internet. The Taskade **Send HTTP Request** step blocks `localhost` and private network addresses.
+
+## Steps
+
+1. In Taskade, open **Settings**, then **API**, and click **Create token**. Copy the token. It starts with `tskdp_`.
+2. In n8n, add an **HTTP Request** node. Set **Method** to `POST` and **URL** to `https://www.taskade.com/api/v2/createTask`.
+3. Set **Authentication** to **Generic Credential Type**, then **Header Auth**. Use the name `Authorization` and the value `Bearer tskdp_YOUR_TOKEN`.
+4. Turn on **Send Body** and pick **JSON**. Set the JSON field to **Expression**, and paste the expression below with your project ID. The project ID is in the Taskade address bar, after `/d/`.
+5. Click **Execute step**. Make sure that Taskade answers `{"ok":true,...}` and that the task shows in your project.
+6. To start n8n from Taskade, add an n8n **Webhook** node with the method `POST`, and copy its **Production URL**.
+7. In a Taskade automation, add **When a task is added**, then **Send HTTP Request** with **Method** `POST`, the n8n URL and **Request Body Type** **JSON**. Activate the n8n workflow.
+
+Request body for step 4:
+
+```js
+{{ {
+  "projectId": "YOUR_PROJECT_ID",
+  "tasks": [
+    { "contentType": "text/markdown", "content": $json.title, "placement": "beforeend" }
+  ]
+} }}
+```
+
+The expression returns the whole body as an object, and n8n serializes it. Do not put `{{ $json.title }}` inside quoted JSON text. n8n does not escape the value there, so a title such as `Call "Acme"` makes the body invalid.
+
+## Check the result
+
+You are done when an n8n run adds a task to your project, and a new Taskade task shows as an execution in n8n.
+
+## Notes
+
+- The **Header Auth** credential keeps the token out of the workflow JSON, so an exported workflow does not carry it.
+- For Taskade events such as a task assigned, paste the n8n URL into **Settings** > **API** > **Outgoing webhooks** (Pro and above). Each delivery carries an `X-Taskade-Signature` header that you can check.
+- When the Taskade node is on npm, it replaces steps 2 to 5 with a **Taskade** node and a **Taskade Trigger** node.
+
+## Taskade EVE can build this for you
+
+> Build an automation that sends every new task in my Requests project to my n8n webhook URL.
+
+## Checked
+
+- Taskade steps, labels and the `createTask` body: checked against the Taskade app and the [v2 spec](https://www.taskade.com/api/documentation/v2) on 2026-10-22.
+- n8n labels (**HTTP Request**, **Generic Credential Type**, **Header Auth**, **Send Body**, **Expression**, **Execute step**, **Webhook**, **Production URL**): taken from n8n's public docs. Not checked in an n8n instance.
diff --git a/recipes/square.md b/recipes/square.md
@@ -0,0 +1,50 @@
+# Connect Square to Taskade
+
+Square has no Taskade integration yet. A Taskade webhook and the **Send HTTP Request** step with your Square access token cover the common jobs today.
+
+**Who it is for:** Shops, studios and service teams that take payments in Square and track orders or clients in Taskade.
+
+**What it does:** Each completed Square payment adds a task to a Taskade project, and a Taskade automation can create a customer in Square.
+
+**Before you start:** The **When a webhook arrives** trigger needs the Pro plan or higher. You need a Square developer application. Test with its Sandbox access token and the Sandbox host `connect.squareupsandbox.com` first.
+
+## Steps
+
+1. In Taskade, create an automation with the trigger **When a webhook arrives**. Copy the **Webhook URL**, and set **Verify requests** to **None**.
+2. In **Parameters**, add the Square fields that the next steps use: `data.object.payment.id`, `data.object.payment.status` and `data.object.payment.amount_money.amount`.
+3. Add an **Only continue if...** step that passes when the payment status is `COMPLETED`. Then add an **Add a task** step with the payment ID and the amount in the task text. Turn on the automation.
+4. In the Square Developer Console, open your application, then **Webhooks**, then **Subscriptions**. Add a subscription with the Taskade URL and the `payment.updated` event.
+5. Send a test event from Square. Make sure that a run shows in the automation history and that a task shows in your project.
+6. To write to Square, add **Send HTTP Request** to a Taskade automation. Open **Authentication**, pick **Bearer Token**, and paste your Square Sandbox access token.
+7. Set **Method** `POST`, **URL** `https://connect.squareupsandbox.com/v2/customers`, a `Square-Version` header, and **Request Body Type** **JSON** with the body below.
+
+Request body for step 7 (map the values from your task):
+
+```json
+{
+  "given_name": "Jane",
+  "email_address": "jane@example.com"
+}
+```
+
+## Check the result
+
+You are done when a Square test payment adds a task, and the **Send HTTP Request** step answers with a new customer `id`.
+
+## Notes
+
+- Square signs each event with its own header, and Taskade does not read that header. Thus the Taskade URL is the only key. Keep it private, and do not paste it into a page or a chat.
+- Put the Square token only in the **Authentication** panel, never in **Headers**. Taskade saves headers as plain text in the automation.
+- To go live, change both the token and the host. Use your production access token and `https://connect.squareup.com/v2/customers`. A Sandbox token fails on the production host, and a production token creates real customers.
+- The **Only continue if...** step skips a payment that is not complete. It does not stop a duplicate task. Square retries an event that it did not see delivered, and a completed payment can send `payment.updated` again, for example after a refund. Thus one payment can add more than one task. The payment ID in the task text helps you find a duplicate.
+- If the automation is off, the webhook URL answers 404, and Square retries the event.
+
+## Taskade EVE can build this for you
+
+> Build an automation that adds a task to my Orders project each time Square sends a completed payment to my webhook.
+
+## Checked
+
+- Taskade steps, labels and webhook behavior: checked against the Taskade app on 2026-10-22.
+- Square facts (Developer Console labels, the `payment.updated` event and its payload paths, the Sandbox and production hosts, `/v2/customers` and its fields, the `Square-Version` header, the Square signature header, retries): taken from Square's public docs. Not checked in a Square account.
+- A nested field such as `data.object.payment.status` in **Parameters**: the field builder supports nested objects, but this recipe was not run end to end.