# nodes

node_type: n8n-nodes-woovi.woovi
package_name: n8n-nodes-woovi
display_name: woovi
description: n8n nodes for Woovi
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: sibelius
author_github_url: git+https://github.com/woovibr/n8n-nodes-woovi.git
npm_package_name: n8n-nodes-woovi
npm_version: 2.3.0
community_fetched_at: 2026-03-25T21:19:41.749Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-woovi

  ![Woovi N8N logo](img/woovi-n8n.png)

  [![NPM Version](https://badge.fury.io/js/n8n-nodes-woovi.svg?style=flat)](https://npmjs.org/package/n8n-nodes-woovi)

  [![https://nodei.co/npm/n8n-nodes-woovi.png?downloads=true&downloadRank=true&stars=true](https://nodei.co/npm/n8n-nodes-woovi.png?downloads=true&downloadRank=true&stars=true)](https://www.npmjs.com/package/n8n-nodes-woovi)

  n8n nodes for create charges and payments with [Woovi](https://woovi.com)

  ## How to use

  ### Community Nodes (Recommended)

  1. Go to Settings > Community Nodes.
  2. Select Install.
  3. Enter `n8n-nodes-woovi` in *Enter npm package name.* field.
  4. Agree to the risks of using community nodes: select I understand the risks of installing unverified code from a public source.
  5. Select Install.

  ### Manual installation

  To get started install the package in your n8n root directory:

  `npm install n8n-nodes-woovi`

  ### Setup

  1. Go to Credentials.
  2. Select `Add Credential` button.
  3. Select `Woovi API` from the *Search for app* dropdown.
  4. Get your Woovi API key from [API Getting Started](https://developers.woovi.com/docs/apis/api-getting-started).
  5. Enter your Woovi API key in the *API Key* field.

  #### Sandbox (Ambiente de teste)

  Se você deseja usar o ambiente de sandbox, abra as credenciais `Woovi API` no n8n e ative `Use Sandbox Environment`. Quando ativado, preencha `API Key (Sandbox)` e `Base URL (Sandbox)` (padrão: `https://api.woovi-sandbox.com/api`). Desative para voltar ao ambiente de produção e preencher `API Key (Production)`.

  ## API Reference

  - [Woovi API](https://developers.woovi.com/docs/apis/api-getting-started)

  - All requests require the `Authorization` header with your AppID (set it in the `Woovi API` credential used by the node).

  ## Using implemented routes in n8n

  The package currently implements two primary integrations for n8n:

  - Create charge (POST /charge) — available as the `Woovi` node
  - Webhook listener for Woovi events — available as the `Woovi Trigger` node

  **Implemented endpoints:**

  | Endpoint | Method | n8n Node | Required fields / Parameters | Short usage | Example output |
  |---|---:|---|---|---|---|
  | `/v1/charge` | POST | `Woovi` | `Value` (number, cents) — required; `CorrelationID` (string) — optional | Create a charge (dynamic PIX / payment link). Configure **Woovi API** credentials, set `Value` and optional `CorrelationID`, then execute the `Woovi` node. | `charge.identifier`, `charge.status`, `charge.paymentLinkUrl`, `charge.brCode`, `charge.pixKey`, `expiresIn` |
  | `/webhook` (webhook listener) | POST (webhook) | `Woovi Trigger` | `events` (dropdown) — choose a specific event or `ALL` | Receive Woovi events (charge created/completed, transaction received, refunds, movement updates). Add `Woovi Trigger`, choose event(s), enable the workflow to expose the webhook URL, then configure Woovi to post to that URL. | Full event payload in node output JSON (field names depend on event) |
  | `/v1/subaccount` | GET | `Woovi` | — | List subaccounts for the company. Use the `resource=subaccount` and `operation=listSubaccounts` in the `Woovi` node. | Array of subaccount objects (id, pixKey, name, balance, ...) |
  | `/v1/subaccount/{id}` | GET | `Woovi` | `Subaccount ID` (string) — required | Get a single subaccount's details. Use `resource=subaccount` + `operation=getSubaccount` and provide `Subaccount ID`. | Subaccount object with details (id, pixKey, name, balance, createdAt, ...) |
  | `/v1/subaccount` | POST | `Woovi` | `Pix Key` (string) — required (or other identifying fields) ; `Subaccount Name` (string) — optional | Create or retrieve a subaccount by `pixKey`. Use `resource=subaccount` + `operation=createSubaccount`. | Created or existing subaccount object (id, pixKey, name, ...) |
  | `/v1/subaccount/{id}/withdraw` | POST | `Woovi` | `Subaccount ID` (string) — required; `Amount` (number, cents) — required | Withdraw (partial) from a subaccount to the main account. Use `operation=withdrawSubaccount`. | Operation result (success/info) |
  | `/v1/subaccount/{id}/debit` | POST | `Woovi` | `Subaccount ID` (string) — required; `Amount` (number, cents) — required; `Description` (string) — optional | Debit (move) value from a subaccount to the main account with an optional description. Use `operation=debitSubaccount`. | Operation result (success/info) |
  | `/v1/subaccount/{id}` | DELETE | `Woovi` | `Subaccount ID` (string) — required | Delete a subaccount (only allowed if balance == 0). Use `operation=deleteSubaccount`. | Operation result (success/info) |
  | `/v1/subaccount/transfer` | POST | `Woovi` | `Value` (number, cents) — required; `From Pix Key` (string) — required; `To Pix Key` (string) — required; `CorrelationID` (string) — optional | Transfer funds between subaccounts. Use `operation=transferSubaccounts` and provide transfer details. | Operation result (success/info) |
  | `/v1/subaccount` | GET | `Woovi` | — | List subaccounts for the company. Use the `resource=subaccount` and `operation=listSubaccounts` in the `Woovi` node. | Array of subaccount objects (id, pixKey, name, balance, ...)
  | `/v1/subaccount/{id}` | GET | `Woovi` | `Subaccount ID` (string) — required | Get a single subaccount's details. Use `resource=subaccount` + `operation=getSubaccount` and provide `Subaccount ID`. | Subaccount object with details (id, pixKey, name, balance, createdAt, ...)
  | `/v1/subaccount` | POST | `Woovi` | `Pix Key` (string) — required (or other identifying fields) ; `Subaccount Name` (string) — optional | Create or retrieve a subaccount by `pixKey`. Use `resource=subaccount` + `operation=createSubaccount`. | Created or existing subaccount object (id, pixKey, name, ...)
  | `/v1/subaccount/{id}/withdraw` | POST | `Woovi` | `Subaccount ID` (string) — required; `Amount` (number, cents) — required | Withdraw (partial) from a subaccount to the main account. Use `operation=withdrawSubaccount`. | Operation result (success/info)
  | `/v1/subaccount/{id}/debit` | POST | `Woovi` | `Subaccount ID` (string) — required; `Amount` (number, cents) — required; `Description` (string) — optional | Debit (move) value from a subaccount to the main account with an optional description. Use `operation=debitSubaccount`. | Operation result (success/info)
  | `/v1/subaccount/{id}` | DELETE | `Woovi` | `Subaccount ID` (string) — required | Delete a subaccount (only allowed if balance == 0). Use `operation=deleteSubaccount`. | Operation result (success/info)
  | `/v1/subaccount/transfer` | POST | `Woovi` | `Value` (number, cents) — required; `From Pix Key` (string) — required; `To Pix Key` (string) — required; `CorrelationID` (string) — optional | Transfer funds between subaccounts. Use `operation=transferSubaccounts` and provide transfer details. | Operation result (success/info)
  |  `/v1/customer`    | POST |  `Woovi` | `name` (string) — required; **at least one of:** `taxID` (string), `email` (string), or `phone` (string) — required; `correlationID` (string) — optional; `address` (object: { zipcode (string), street (string), number (string), neighborhood (string), city (string), state (string), complement (string), country (string) }) — optional, but if provided all fields except `complement` must be filled | Create a new customer. Use `resource=customer` + `operation=createCustomer` and provide `name` plus at least one identifier (`taxID`, `email`, or `phone`) | Operation result (success/info) 
  |  `/v1/customer`  | GET | `Woovi` | — | List customers of the company. Use `resource=customer` + `operation=listCustomers` | Operation result (success/info)
  |  `/v1/customer/{id}`  | GET | `Woovi` | `Id` CorrelationID or Tax ID (String) - required | Get a customer of the company. Use `resource=customer` + `operation=getCustomer` and provide a `id` that could be `Tax ID` or `Correlation ID` | Operation result (success/info)
  |  `/v1/customer/{id}`    | PATCH |  `Woovi` | `correlationID` (string) — required; `name` (string) — optional; `taxID` (string) — optional; `email` (string) — optional; `phone` (string) — optional; `address` (object: {  zipcode — (string); street — (string); number — (string); neighborhood — (string); city — (string);state — (string);complement — (string);country — (string) }) — optional if not provided | Update an existing customer. Use `resource=customer` + `operation=updateCustomer` and provide fields to update | Operation result (success/info)
  |  `/v1/refund`  | GET | `Woovi` | — | List refunds of the company. Use `resource=refund` + `operation=listRefunds` | Operation result (success/info)
  |  `/v1/refund/{id}`  | GET | `Woovi` | `Id` Refund ID or Correlation ID (String) - required | Get a refund of the company. Use `resource=refund` + `operation=getRefund` and provide a `id` that could be `Refund ID` or `Correlation ID` | Operation result (success/info)
  |  `/v1/refund`    | POST |  `Woovi` | `value` (number) — required; `correlationID` (string) — required; `transactionEndToEndId` (string) required; `comment` (string) optional | Create a new refund. Use `resource=refund` + `operation=createRefund` and provide `value`, `transactionEndToEndId` and `correlationID` at least | Operation result (success/info)
  |  `/v1/invoice`  | GET | `Woovi` | `limit` (number) — optional (default: 20); `skip` (number) — optional (default: 0); `start` (string, format: YYYY-MM-DD) — optional; `end` (string, format: YYYY-MM-DD) — optional | List invoices of the company. Use `resource=invoice` + `operation=listInvoices` and optionally filter by date range | Array of invoice objects
  |  `/v1/invoice/{correlationID}/cancel`  | POST | `Woovi` | `correlationID` (string) — required | Cancel an invoice. Use `resource=invoice` + `operation=cancelInvoice` and provide the invoice `correlationID` | Operation result (success/info)
  |  `/v1/invoice/{correlationID}/pdf`  | GET | `Woovi` | `correlationID` (string) — required | Get invoice PDF. Use `resource=invoice` + `operation=getInvoicePdf` and provide the invoice `correlationID` | PDF file data
  |  `/v1/invoice/{correlationID}/xml`  | GET | `Woovi` | `correlationID` (string) — required | Get invoice XML. Use `resource=invoice` + `operation=getInvoiceXml` and provide the invoice `correlationID` | XML file data
  |  `/v1/invoice`  | POST | `Woovi` | `billingDate` (string, ISO 8601) — required; `correlationID` (string) — required; **one of:** `charge` (string) OR `value` (number) — required; `description` (string) — optional; `customerId` (string) — optional; `customer` (object with taxID, name, email, phone, address) — optional (if provided, all customer fields are required) | Create a new invoice. Use `resource=invoice` + `operation=createInvoice` and provide required fields | Operation result (success/info)
  |  `/v1/installments/{id}`  | GET | `Woovi` | `id` (string) — required (globalID or endToEndId) | Get a single installment's details. Use `resource=installment` + `operation=getInstallment` and provide the installment `id` (either globalID or endToEndId) | Installment object with details (globalID, endToEndId, value, status, ...)
  |  `/v1/installments/{id}/cobr`  | POST | `Woovi` | `id` (string) — required (globalID); `value` (number, cents) — optional | Create CobR manually for an installment. Use `resource=installment` + `operation=createInstallmentCobr` and provide the installment `id`. Optionally provide custom `value` in cents, otherwise uses the installment value | Created CobR object with details (globalID, value, brCode, pixKey, status, ...)
  |  `/v1/installments/{id}/cobr/retry`  | POST | `Woovi` | `id` (string) — required (globalID) | Manually retry CobR creation for an installment. Use `resource=installment` + `operation=retryInstallmentCobr` and provide the installment `id` | Created CobR object with details (globalID, value, brCode, status, ...)
  |  `/v1/subscriptions`  | GET | `Woovi` | — | List all subscriptions of the company. Use `resource=subscription` + `operation=listSubscriptions`. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Array of subscription objects (id, status, value, dayGenerateCharge, customer, ...)
  |  `/v1/subscriptions/{id}`  | GET | `Woovi` | `id` (string) — required | Get a subscription's details. Use `resource=subscription` + `operation=getSubscription` and provide the subscription `id`. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Subscription object with details (id, status, value, dayGenerateCharge, customer, ...)
  |  `/v1/subscriptions`  | POST | `Woovi` | `value` (number, cents) — required; `type` (PIX_RECURRING or RECURRENT) — required; `correlationID` (string) — required; `customer` (object: name, email, phone, taxID, address) — required; `name` (string) — optional; `comment` (string) — optional; `dayGenerateCharge` (number 1-31, default 5) — optional; `frequency` (WEEKLY, MONTHLY, SEMIANNUALLY, ANNUALLY) — optional; `dayDue` (number >=3, default 7) — optional | Create a new subscription. Use `resource=subscription` + `operation=createSubscription` and provide all required fields including complete customer data with address. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Created subscription object with id and details
  |  `/v1/subscriptions/{id}/cancel`  | PUT | `Woovi` | `id` (string) — required | Cancel a subscription. Use `resource=subscription` + `operation=cancelSubscription` and provide the subscription `id`. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Subscription object with status CANCELED
  |  `/v1/subscriptions/{id}/value`  | PUT | `Woovi` | `id` (string) — required; `value` (number, cents) — required (must be > 0) | Update the value of future subscription installments (when allowed). Use `resource=subscription` + `operation=updateSubscriptionValue` and provide the subscription `id` and new `value`. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Updated subscription object with new value
  |  `/v1/subscriptions/{id}/installments`  | GET | `Woovi` | `id` (string) — required | List all installments for a subscription. Use `resource=subscription` + `operation=listSubscriptionInstallments` and provide the subscription `id`. **⚠️ Note: Subscriptions only work in Woovi production environment (not available in sandbox)** | Array of installment objects (globalID, endToEndId, value, status, ...)
  |  `/v1/pix-keys`  | POST | `Woovi` | `pixKey` (string) — optional for EVP; `pixKeyType` (string, CNPJ or EVP) — required | Create a new pix key. Use `resource=pixKey` + `operation=create` and provide `pixKeyType`. For CNPJ type, `pixKey` is required. | Pix Key object (key, type, status, ...)
  |  `/v1/pix-keys`  | GET | `Woovi` | — | List all pix keys. Use `resource=pixKey` + `operation=list`. | Array of Pix Key objects and account info
  |  `/v1/pix-keys/{pixKey}/check`  | GET | `Woovi` | `pixKey` (string) — required | Check a pix key. Use `resource=pixKey` + `operation=check` and provide the `pixKey`. | Pix Key object (key, type, status, ...)
  |  `/v1/pix-keys/{pixKey}/default`  | POST | `Woovi` | `pixKey` (string) — required | Set a pix key as default. Use `resource=pixKey` + `operation=setDefault` and provide the `pixKey`. | Operation result (success/info)
  |  `/v1/pix-keys/{pixKey}`  | DELETE | `Woovi` | `pixKey` (string) — required | Delete a pix key. Use `resource=pixKey` + `operation=delete` and provide the `pixKey`. | Operation result (success/info)
  |  `/v1/pix-keys/tokens`  | GET | `Woovi` | — | Get tokens data for pix keys. Use `resource=pixKey` + `operation=getTokens`. | Tokens info (limit, refresh)
  |  `/v1/qrcode-static`  | POST | `Woovi` | `name` (string) — required; `value` (number, cents) — required; `correlationID` (string) — optional; `comment` (string) — optional; `pixKey` (string) — optional | Create a new static Pix QR code. Use `resource=qrCodeStatic` + `operation=create` and provide required fields. | QR Code object (brCode, qrCodeImage, paymentLinkUrl, ...)
  |  `/v1/qrcode-static/{id}`  | GET | `Woovi` | `qrCodeId` (string) — required | Get a static Pix QR code. Use `resource=qrCodeStatic` + `operation=get` and provide the `qrCodeId` (ID, correlation ID, or identifier). | QR Code object (id, name, value, status, ...)
  |  `/v1/qrcode-static`  | GET | `Woovi` | `limit` (number) — optional (default: 20); `skip` (number) — optional (default: 0) | List all static Pix QR codes. Use `resource=qrCodeStatic` + `operation=list`. Optionally provide `limit` and `skip` for pagination. | Array of QR Code objects
  | `/v1/payment` | POST | `Woovi` | `paymentType` (`PIX_KEY`/`QR_CODE`/`MANUAL`) — required; `value` (number, cents) — required; `correlationID` (string) — required. Optional: `destinationAlias`, `destinationAliasType` (`CPF`,`CNPJ`,`EMAIL`,`PHONE`,`RANDOM`), `pixKeyEndToEndId`, `comment`, `metadata` (JSON object, max 30 keys). | Request a payment (PIX key / QR code / manual). Use `resource=payment` + `operation=create` and provide required fields. | `payment` object with fields like `type`, `value`, `destinationAlias`, `destinationAliasType`, `qrCode` (when `QR_CODE`), `correlationID`, `comment`, `status` |
  | `/v1/payment` | GET | `Woovi` | `limit` (number) — optional (default: 20); `skip` (number) — optional (default: 0); `correlationID` (string) — optional; `status` (string) — optional | List payments for the company. Use `resource=payment` + `operation=list` and optionally filter by `correlationID` or `status`. | Array of payment objects |
  | `/v1/payment/{id}` | GET | `Woovi` | `id` (string) — required (payment ID or correlationID) | Get a single payment by ID or correlationID. Use `resource=payment` + `operation=get` and provide `id`. | Payment object with details (payment, transaction, destination) |
  Note: In the n8n node the `metadata` field is entered as a key/value collection (fixed collection) and will be converted to a JSON object by the node (maximum 30 keys). For `paymentType = QR_CODE` the `value` is optional and the node omits the `value` field when creating a QR code payment.
  | `/v1/psp` | GET | `Woovi` | `ispb` (string) — optional; `name` (string) — optional; `compe` (string) — optional | List PSPs (Payment Service Providers). Use `resource=psp` + `operation=list` and optionally filter by `ispb`, `name`, or `compe`. | Array of PSP objects (name, ispb, code, compe) |

  Common events available in the trigger: `OPENPIX:CHARGE_CREATED`, `OPENPIX:CHARGE_COMPLETED`, `OPENPIX:CHARGE_EXPIRED`, `OPENPIX:TRANSACTION_RECEIVED`, `OPENPIX:TRANSACTION_REFUND_RECEIVED`, `OPENPIX:MOVEMENT_CONFIRMED`, `OPENPIX:MOVEMENT_FAILED`, `OPENPIX:MOVEMENT_REMOVED`, and `ALL`.

  Tip: select `ALL` to receive every event and branch inside the workflow by inspecting the event payload's `event` field.


  ## Contributing

  1. Fork it (<https://github.com/entria/n8n-nodes-woovi/fork>)
  2. Create your feature branch (`git checkout -b feature/fooBar`)
  3. Commit your changes (`git commit -m 'feat(fooBar) Add some fooBar'`)
  4. Push to the branch (`git push origin feature/fooBar`)
  5. Create a new Pull Request

ai_documentation_summary:
  {"purpose":"This n8n node package enables integration with Woovi, a Brazilian payment gateway, allowing users to create charges, manage subaccounts, and handle payment events within n8n workflows.","capabilities":["Create charges (dynamic PIX/payment links)","List subaccounts","Get subaccount details","Create subaccounts","Withdraw funds from subaccounts","Debit funds from subaccounts","Delete subaccounts","Transfer funds between subaccounts","Listen to Woovi webhook events"],"authentication":"API Key required (AppID)","commonUseCases":["Automating PIX payment processing","Managing multi-currency or multi-merchant subaccounts","Receiving and processing payment events automatically","Handling refunds and fund movements"],"limitations":["Subaccount deletion is only allowed if the balance is zero","Requires manual installation via npm or community node installation"],"relatedNodes":["Woovi Trigger","Webhook"]}


node_type: n8n-nodes-comfyui.comfyui
package_name: n8n-nodes-comfyui
display_name: comfyui
description: n8n node to integrate with ComfyUI stable diffusion workflows
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: mason276752
author_github_url: git+https://github.com/mason276752/n8n-nodes-comfyui.git
npm_package_name: n8n-nodes-comfyui
npm_version: 0.0.9
community_fetched_at: 2026-03-25T21:19:41.752Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-comfyui

  This package provides an n8n node to integrate with [ComfyUI](https://github.com/comfyanonymous/ComfyUI) — a powerful and modular stable diffusion GUI with a graph/nodes interface.

  ## Features

  - Execute ComfyUI workflows directly from n8n
  - Support for multiple input items (each item runs its own workflow)
  - Automatic retrieval of generated images **and videos**
  - Output format conversion: JPEG, PNG, WebP, or Raw (no conversion)
  - Quality control for JPEG and WebP output
  - Progress monitoring and error handling
  - Optional API key authentication
  - Configurable timeout

  ## Prerequisites

  - n8n (version 1.0.0 or later)
  - ComfyUI instance running and accessible
  - Node.js 22.16 or newer

  ## Installation

  ```bash
  pnpm install n8n-nodes-comfyui
  ```

  Or via the n8n community nodes panel: search for `n8n-nodes-comfyui`.

  ## Node Configuration

  ### Credentials

  | Field   | Description                                              |
  |---------|----------------------------------------------------------|
  | API URL | URL of your ComfyUI instance (e.g. `http://127.0.0.1:8188`) |
  | API Key | Optional — required if your ComfyUI has authentication enabled |

  ### Parameters

  | Parameter      | Description                                                                 |
  |----------------|-----------------------------------------------------------------------------|
  | Workflow JSON  | ComfyUI workflow exported as JSON (API format)                              |
  | Output Format  | `JPEG` / `PNG` / `WebP` / `Raw (Original)` — applies to image outputs only |
  | JPEG Quality   | Quality 1–100 (shown when Output Format is JPEG)                           |
  | WebP Quality   | Quality 1–100 (shown when Output Format is WebP)                           |
  | Timeout        | Maximum minutes to wait for workflow completion (default: 30)               |

  ### Output Format notes

  - **JPEG / PNG / WebP** — images are decoded and re-encoded via [sharp](https://sharp.pixelplumbing.com/)
  - **Raw (Original)** — files are downloaded as-is without any conversion; useful for formats sharp doesn't support, or when you want to preserve the original file exactly

  ### Outputs

  Each output item contains:

  **JSON fields**
  - `filename` — original filename from ComfyUI
  - `type` — `output` or `temp`
  - `subfolder` — subfolder path if any
  - `mediaType` — `image` or `video`

  **Binary (`data`)**
  - The file content as binary data, with correct `mimeType` and `fileExtension` set

  ## Multiple Input Items

  When multiple items are passed into this node, each item is processed sequentially — one ComfyUI workflow execution per item. This allows expressions in the Workflow JSON field to reference each item's data (e.g. `{{ $json.prompt }}`).

  ## Usage

  1. Export your workflow from ComfyUI via **Save (API Format)**
  2. Add the ComfyUI node to your n8n workflow
  3. Paste the workflow JSON into the **Workflow JSON** field
  4. Set the API URL in the credentials
  5. Execute — generated images and videos will appear as binary outputs

  ## Error Handling

  The node handles:
  - API connection failures
  - Invalid workflow JSON
  - ComfyUI execution errors (with node ID and error message)
  - Timeout conditions
  - Individual file download failures (non-fatal; returns error in `json.error`)

  ## Development

  ```bash
  # Install dependencies
  pnpm install

  # Build
  pnpm build

  # Watch mode
  pnpm dev

  # Lint
  pnpm lint
  ```

  ## License

  [MIT](LICENSE.md)

ai_documentation_summary:
  {"purpose":"This n8n node integrates with ComfyUI to execute Stable Diffusion workflows directly from n8n, supporting both image and video generation with optional API key authentication.","capabilities":["Execute ComfyUI workflows via JSON API","Process multiple input items sequentially","Retrieve generated images and videos","Convert output formats to JPEG, PNG, WebP, or Raw","Control JPEG and WebP quality (1-100)","Monitor workflow progress","Handle timeouts and errors gracefully","Support expressions in workflow JSON for dynamic inputs"],"authentication":"Optional API key required if ComfyUI instance has authentication enabled","commonUseCases":["Automated image generation in marketing workflows","Video creation pipelines","Dynamic prompt-based content generation","Batch processing of Stable Diffusion workflows"],"limitations":["Requires Node.js 22.16 or newer","Minimum n8n version is 1.0.0","Image outputs in JPEG/WebP formats are re-encoded via sharp (may not preserve exact original quality)","Raw format downloads files without conversion but may not support all formats sharp can handle"],"relatedNodes":["n8n-nodes-base.httpRequest","n8n-nodes-base.binaryData","n8n-nodes-base.code"]}


node_type: n8n-nodes-synology-suite.synologysuite
package_name: n8n-nodes-synology-suite
display_name: synologysuite
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: clawbow
author_github_url: git+https://github.com/ClawBow/n8n-nodes-synology-suite.git
npm_package_name: n8n-nodes-synology-suite
npm_version: 0.33.0
community_fetched_at: 2026-03-25T21:19:41.761Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  n8n community nodes for Synology DSM (API, Drive, Sheets, Office, MailPlus, Calendar, Note, Photos, Contacts, FileStation, Chat, Security, DownloadStation2, Storage Manager, AudioStation) - AI Agent compatible

npm_readme:
  # n8n-nodes-synology-suite

  Community nodes for Synology DSM WebAPI.

  - **NPM**: https://www.npmjs.com/package/n8n-nodes-synology-suite
  - **GitHub**: https://github.com/ClawBow/n8n-nodes-synology-suite
  - **Issues**: https://github.com/ClawBow/n8n-nodes-synology-suite/issues

  ## Project status

  > ⚠️ **Work in progress / actively expanding**
  >
  > This package is under active development. New Synology APIs are added progressively, coverage is improving release after release, and some operations can still be unstable depending on DSM version/build.
  >
  > Bugs are possible (especially on less common DSM/API variants). I’m actively fixing them and extending coverage over time.

  ## Included nodes (current)

  - **Synology API**: generic DSM caller (`api + method + version + params`)
  - **Synology Drive**: file operations, search, links, team folders, labels, webhooks
  - **Synology Sheets**: spreadsheet reads/writes, range ops, exports, batch updates
  - **Synology Office**: Office-family fallback + custom calls
  - **Synology MailPlus**: mailbox/message/label/filter operations
  - **Synology MailPlus Trigger**: incoming mail events (webhook style)
  - **Synology Calendar**: calendars, events, tasks, settings, timezone helpers
  - **Synology Note**: notebooks, notes, todos, tags, search, trash, sharing
  - **Synology Photos**: browse, albums, sharing, favorites, thumbnails
  - **Synology Contacts**: addressbooks, contacts, labels, search
  - **Synology File Station**: list/info/search/copy/move/delete/upload/download/background tasks
  - **Synology Chat**: users/channels/posts/webhooks/apps + custom chat calls
  - **Synology Security Observability**: security/logcenter-style discovery and operations
  - **Synology DownloadStation2**: modern Download Station operations

  ## Coverage philosophy

  Goal: cover as much of the Synology API surface as possible with stable operation-based nodes.

  - New API families are added incrementally.
  - Unsupported or DSM-variant methods can still be reached via `Custom * Call` operations.
  - Runtime probing artifacts are included to document what is actually available on real NAS targets.

  ## Credentials

  `Synology DSM API`
  - Base URL (example: `https://your-nas:5001`)
  - Username
  - Password
  - Session Name (default `FileStation`)
  - Ignore SSL Issues (for self-signed certs)

  ## Node usage examples

  ### Synology Office
  - **List Spreadsheets**: choose `List Spreadsheets`, set folder ID and limit.
  - **Read Range / Cells**: choose `Read Range / Cells`, set `fileId`, optional `sheetId`, and A1 range (`A1:C20`).
  - **Write Range / Cells**: choose `Write Range / Cells`, provide A1 range and a 2D JSON values array.
  - **Append Row**: provide `rowValues` JSON array.
  - If your DSM build uses different method names, keep using operation mode and pass `extraParamsJson`, or use `Custom Office Call`.

  ### Synology MailPlus
  - **List Mailboxes**: operation `List Mailboxes`.
  - **List Messages**: operation `List Messages`, optionally enable `Return All` for auto-pagination.
  - **Get Message Detail**: set `messageId`.
  - **Move Message**: set `messageIds` JSON array and destination mailbox.
  - **Mark Read / Unread**: set `messageId` + boolean `read`.
  - **Add / Remove Label**: set `messageId`, `labelId`, and label action.

  ### Synology Drive
  - **List Files**: supports offset/limit and `Return All`.
  - **Search Files**: can `Wait for Completion` and poll search task results.
  - **Create Share Link**: supports link password, expiration date, and download toggle.
  - `Custom Drive Call` remains available for unsupported variants.

  ## Error handling

  DSM error responses are normalized and include:
  - `api`
  - `method`
  - `version`
  - DSM `code`
  - mapped human message

  All nodes use n8n `continueOnFail()` behavior. If enabled, each failing item emits an error payload instead of stopping the workflow.

  ## Local test

  ```bash
  npm install
  npm run build
  npm run smoke
  ```

  ## Troubleshooting

  - **`code=102/103/104`**: API/method/version mismatch on your DSM version. Use `Custom * Call` mode or provide additional params in `extraParamsJson`.
  - **`code=105/106/107/119`**: auth/session issue. Verify credentials and session name. Re-login retry is automatic once.
  - **Mail label operations fail**: MailPlus versions differ. Try custom call and inspect available methods through `List Mail APIs`.
  - **Office sheet operation fails**: different Office method names exist between builds. Operation mode already attempts multiple method candidates; if still failing, switch to custom call.

  ## API inventories captured from your NAS

  - [`synology-api-catalog.full.json`](https://github.com/ClawBow/n8n-nodes-synology-suite/blob/main/synology-api-catalog.full.json) (full discovered catalog)
  - [`ALL_APIS.md`](https://github.com/ClawBow/n8n-nodes-synology-suite/blob/main/ALL_APIS.md) (human-readable full list)

  Additional per-service inventories (`syno-drive-apis.json`, `syno-office-apis.json`, `syno-mailplus-server-apis.json`, `syno-mailclient-apis.json`) are generated in the **workspace root** during local probing and are not part of this repository by default.

  ## Full-action discovery (exhaustive probe)

  The repository includes an exhaustive action discovery script that probes a conservative method set on every discovered DSM API:

  - candidate methods: `get,list,query,info,start,status,create,update,set,delete,run,stop,search,read,write`
  - default safety mode skips potentially destructive methods (`start/create/update/set/delete/run/stop/write`)
  - credentials are loaded from `../skills/synology-api-discovery/.env` by default

  Run (safe default):

  ```bash
  npm run probe:actions
  ```

  Outputs:
  - `API_PROBE_RESULTS.json` (full machine-readable probe results)
  - `API_PROBE_SUMMARY.md` (human summary, top valid methods, coverage stats)

  Optional destructive probing (use with caution):

  ```bash
  npm run probe:actions:destructive
  ```

  ### Caveats

  - Many endpoints require mandatory params; `error code 101` often means method likely exists but needs args.
  - `error code 103` usually indicates unsupported/non-existent method for that API.
  - Running with `--allow-destructive` can trigger state-changing operations. Prefer non-destructive mode unless on a test NAS.

  ## About Synology Office API docs/slides access

  Based on Synology support feedback, Synology Office API docs/slides resources are currently not accessible.

  If you need access, open a request via official channels:
  - Synology Support Center: https://account.synology.com/support
  - Synology KB portal: https://kb.synology.com/
  - Synology Community: https://community.synology.com/

  If you already received specific support links from Synology, add them here so other users can request the same access path.

  ## Release workflow

  - See [RELEASE_CHECKLIST.md](https://github.com/ClawBow/n8n-nodes-synology-suite/blob/main/RELEASE_CHECKLIST.md) for a safe publish process.
  - See [CHANGELOG.md](https://github.com/ClawBow/n8n-nodes-synology-suite/blob/main/CHANGELOG.md) for version history.

  ## Additional examples

  See [EXAMPLES.md](https://github.com/ClawBow/n8n-nodes-synology-suite/blob/main/EXAMPLES.md) for sample n8n workflow JSON snippets.

ai_documentation_summary:
  {"purpose":"A collection of community nodes enabling n8n workflows to interact with Synology DSM services including Drive, MailPlus, Office, Calendar, Photos, and more via WebAPI.","capabilities":["Generic Synology API calls with customizable method/version/params","File operations (upload, download, search, copy, move, delete) via Drive and File Station","Spreadsheet management (read/write ranges, append rows, exports) via Sheets","Email operations (list messages, move, mark read/unread, label management) via MailPlus","Calendar and Note management (events, tasks, notebooks, tags)","Photo management (albums, sharing, favorites, thumbnails)","Contact and addressbook management","Chat operations (users, channels, posts, webhooks)","Security and logcenter discovery","Download Station 2 operations"],"authentication":"Basic Auth (Username/Password) with configurable Session Name","commonUseCases":["Automating file backup and organization across Synology NAS","Syncing email data between Synology MailPlus and external services","Managing shared folders and generating secure share links","Automating photo album creation and tagging","Integrating Synology Calendar events with workflow automation"],"limitations":["Work in progress with active development; some operations may be unstable depending on DSM version/build","Bugs possible especially on less common DSM/API variants","Some Office and MailPlus operations may fail due to version-specific API method name differences","Requires manual probing or custom calls for unsupported DSM variants","Some per-service API inventories are generated locally and not included in the repository"],"relatedNodes":["n8n-nodes-base.httpRequest","n8n-nodes-base.code","n8n-nodes-base.webhook"]}


node_type: n8n-nodes-document-generator.documentgenerator
package_name: n8n-nodes-document-generator
display_name: documentgenerator
description: This node creates dynamic content for documents or emails with Handlebars templates
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: mcolomer
author_github_url: git+https://github.com/n8nhackers/n8n-nodes-document-generator.git
npm_package_name: n8n-nodes-document-generator
npm_version: 1.0.10
community_fetched_at: 2026-03-25T21:19:41.764Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  ![Banner image](images/n8n-and-n8nhackers.png)

  # n8n-nodes-document-generator

  This is an n8n community node. It helps you to create:
  * One dynamic content per all input items.
  * One dynamic content per input item.

  If you have any questions or remarks please [contact me](mailto:contact@n8nhackers.com).

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  ## TL;DR
  Don't want to read? Import the sample workflow [Generate dynamic contents for EMAILS or HTML pages](https://n8n.io/workflows/1790-generate-dynamic-contents-for-emails-or-html-pages/) to test this node with random samples. 
  ![Generate dynamic contents for EMAILS or HTML pages](images/workflow-sample.jpeg?raw=true "Generate dynamic contents for EMAILS or HTML pages")

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Compatibility

  This node was developed and tested with version 0.193.5 of n8n.

  ## Dependencies
  If you install this node, n8n will install automatically the next extra npm packages:
  * [@jaredwray/fumanchu](https://www.npmjs.com/package/@jaredwray/fumanchu): this new Handlebars replacement provides Handlebars + Helpers Together.

  ## Usage
  The node can solve multiple use cases when creating content like:
  * Email generation (HTML or TEXT)
  * Static HTML pages
  * WordPress posts
  * Telegram/Slack messages
  * Use helpers to filter templates

  The sky is your limit!

  Just follow the next samples to create your dynamic content and forget to use SET, FUNCTION, or FUNCTION ITEM nodes.

  ### All input items in one template

  #### Cases
  * You want to send a list of recent news about n8n.
  * You want to send the list of the customers created in the last hour in your database.

  #### Template
  Supposing that you have a customer list in JSON:
  ```json
  [
  	{
  		"email": "miquel@n8nhackers.com",
  		"name": "Miquel",
  		"primary": true
  	},
  	{
  		"email": "contact@n8nhackers.com",
  		"name": "Contact",
  		"primary": false
  	}
  ]
  ```

  We will try a Handlebars helper #if to show if the contact is the primary email or not.

  If you use the next template:
  ```
  <ul id="customer_list">
    {{#each items}}
    <li>{{name}}: {{email}} {{#if (eq primary true)}}(primary){{/if}}</li>
    {{/each}}
  </ul>
  ```

  And you will get the next output to send by email in HTML format:
  ```
  <ul id="customer_list">
  <li>Miquel: miquel@n8nhackers.com (primary)</li>
  <li>Contact: contact@n8nhackers.com</li>
  </ul>
  ```

  Property **items** is always mandatory to iterate over all items.

  ### One input item per template

  #### Cases
  * You have an invoice with header and lines and you want to send it by email.

  #### Template
  If you have one item/invoice with this JSON:
  ```json
  {
  	"date": "2022-01-12",
  	"to": "N8n hackers",
  	"address": "Granollers, Spain",
  	"total": 133.10,
  	"lines": [
  		{
  			"description": "Create a node to render items in handlebar templates",
  			"quantity": 1,
  			"amount": 100,
  			"vat": 21,
  			"total": 121
  		},
  		{
  			"description": "Test a node to render items in handlebar templates",
  			"quantity": 1,
  			"amount": 10,
  			"vat": 2.10,
  			"total": 12.1
  		}
  	]
  }
  ```

  You need to use this template:
  ```
  Date: {{date}}
  To: {{to}}
  Address: {{address}}
  Details:
  {{#each lines}}
  - "{{description}}" x {{quantity}} = {{amount}}€ + {{vat}}€ = {{total}}€
  {{/each}}
  Total invoice: {{total}}€
  ```

  And you will get the next output to send by email in TEXT format:
  ```
  Date: 2022-01-12
  To: N8n hackers
  Address: Granollers, Spain
  Details:
  - "Create a node to render items in handlebar templates" x 1 = 100€ + 21€ = 121€
  - "Test a node to render items in handlebar templates" x 1 = 10€ + 2.10€ = 12.10€
  Total invoice: 133.10€
  ```

  I recommend using this method if you want to send multiple invoices.

  ## Helpers
  Now the node supports helpers thanks to the [@jaredwray/fumanchu](https://www.npmjs.com/package/@jaredwray/fumanchu#helpers) package. 

  We recommend checking 

  ## Doubts about templates syntax
  Please, check the [official page](https://handlebarsjs.com/guide/expressions.html#basic-usage) to review all the existing expressions in Handlebars.

  ## Another way to try it out

  [N8N documentation on custom nodes](https://docs.n8n.io/nodes/creating-nodes/create-n8n-nodes-module.html)

  Clone the n8n-nodes-document-generator repository and execute:
  ```
  # Use v20.12.2 = lts/iron
  nvm use lts/iron

  # Install dependencies
  npm install

  # Build the code
  npm run build

  # "Publish" the package locally
  npm link
  ```

  Create an N8N installation and add the n8n-nodes-document-generator to it:
  ```
  # Ensure that custom nodes directory exists in your .n8n
  mkdir ~/.n8n/custom

  # Init npm packages (intro to all questions)
  cd ~/.n8n/custom && npm init

  # "Install" the locally published module
  npm link n8n-nodes-document-generator

  # Start n8n
  n8n start
  ```

  # Contribution

  To make this node even better, please let us know, [how you use it](mailto:contact@n8nhackers.com). Commits are always welcome.

  # Issues

  If you have any issues, please [let us know on GitHub](https://github.com/n8nhackers/n8n-nodes-document-generator/issues).

  # About

  Nodes by [n8nhackers.com](https://n8nhackers.com). For productive use and consulting on this, [contact us please](mailto:contact@n8nhackers.com).

  Special thanks to [N8n nodemation](https://n8n.io) workflow automation by Jan Oberhauser.

  # License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

ai_documentation_summary:
  {"purpose":"Generates dynamic content for documents, emails, or messages using Handlebars templates, supporting both single-item and multi-item input processing.","capabilities":["Render HTML or text content from Handlebars templates","Process one template per all input items (batch mode)","Process one template per input item (individual mode)","Iterate over arrays of data using {{#each}}","Use Handlebars helpers like {{#if}} and {{eq}} for conditional logic","Generate email content (HTML or text format)","Generate static HTML pages","Generate WordPress posts","Generate Telegram or Slack messages","Filter and conditionally display data based on template logic"],"authentication":"None","commonUseCases":["Sending personalized email campaigns with dynamic content","Generating HTML pages for websites","Creating WordPress blog posts with variable data","Automating Telegram or Slack notifications","Processing lists of customers or news items in a single template"],"limitations":["Requires manual installation via npm link for custom node integration","Compatible only with n8n version 0.193.5 or similar","Depends on external npm package @jaredwray/fumanchu for Handlebars support","No built-in authentication or security features for template data"],"relatedNodes":["Handlebars expression node","Set node","Function node","Function item node","Email node"]}


node_type: n8n-nodes-comfyui-image-to-video.comfyuiimagetovideo
package_name: n8n-nodes-comfyui-image-to-video
display_name: comfyuiimagetovideo
description: n8n node to integrate with ComfyUI stable diffusion workflows for image to video conversion
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: christiankuri
author_github_url: git+https://github.com/christiankuri/n8n-nodes-comfyui-image-to-video.git
npm_package_name: n8n-nodes-comfyui-image-to-video
npm_version: 1.0.1
community_fetched_at: 2026-03-25T21:19:41.766Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-comfyui-image-to-video

  This package provides n8n nodes to integrate with [ComfyUI](https://github.com/comfyanonymous/ComfyUI) - A powerful and modular stable diffusion GUI with a graph/nodes interface.

  ## Features

  - Execute ComfyUI workflows directly from n8n
  - Generate images and videos using stable diffusion models
  - Support for workflow JSON import
  - Automatic output retrieval from workflow outputs
  - Progress monitoring and error handling
  - Support for API key authentication
  - Configurable timeout settings

  ## Prerequisites

  - n8n (version 1.0.0 or later)
  - ComfyUI instance running and accessible
  - Node.js 16 or newer

  ## Installation

  ```bash
  npm install n8n-nodes-comfyui-image-to-video
  ```

  ## Node Types

  ### ComfyUI Node

  This node allows you to execute ComfyUI workflows and retrieve generated images.

  #### Settings

  - **API URL**: The URL of your ComfyUI instance (default: http://127.0.0.1:8188)
  - **API Key**: Optional API key if authentication is enabled
  - **Workflow JSON**: The ComfyUI workflow in JSON format

  #### Outputs

  The node outputs an array of generated images with:
  - `filename`: Name of the generated image file
  - `subfolder`: Subfolder path if any
  - `data`: Base64 encoded image data

  ### ComfyUI Image to Video Node

  This node allows you to convert images to videos using ComfyUI's image-to-video capabilities (like AnimateDiff, WanImageToVideo, or video generation models).

  #### Settings

  - **API URL**: The URL of your ComfyUI instance (default: http://127.0.0.1:8188)
  - **API Key**: Optional API key if authentication is enabled
  - **Workflow JSON**: The ComfyUI workflow in JSON format for video generation
  - **Input Type**: Choose between URL, Base64, or Binary input methods
  - **Input Image**: URL or base64 string of the input image (when using URL or Base64 input type)
  - **Binary Property**: Name of the binary property containing the image (when using Binary input type)
  - **Timeout**: Maximum time in minutes to wait for video generation

  #### Input

  The node accepts an image input in three ways:
  1. **URL**: Provide a direct URL to an image
  2. **Base64**: Provide a base64-encoded image string
  3. **Binary**: Use an image from a binary property in the workflow (e.g., from an HTTP Request node)

  #### Outputs

  The node outputs the generated video:
  - In the `binary.data` property with proper MIME type and file information
  - `fileName`: Name of the generated video file
  - `data`: Base64 encoded video data
  - `fileType`: The type of video file (e.g., 'video')
  - `fileSize`: Size of the video in KB
  - `fileExtension`: File extension (webp, mp4, gif)
  - `mimeType`: MIME type of the video

  > **Note**: If multiple videos are generated by the ComfyUI workflow, only the first video output will be returned. The node currently prioritizes video outputs (files with .webp, .mp4, or .gif extensions) and returns the first one it finds.

  ## Usage Examples

  ### Using the ComfyUI Node

  1. Export your workflow from ComfyUI as JSON
  2. Create a new workflow in n8n
  3. Add the ComfyUI node
  4. Paste your workflow JSON
  5. Configure the API URL
  6. Execute and retrieve generated images

  ### Using the ComfyUI Image to Video Node

  1. Create a workflow in ComfyUI for video generation (e.g., using WanImageToVideo, VHS_VideoCombine)
  2. Export the workflow as JSON (API)
  4. Add the ComfyUI Image to Video node
  5. Paste your workflow JSON
  6. Select the appropriate Input Type:
     - For URL: Enter the image URL
     - For Base64: Provide a base64 string
     - For Binary: Specify the binary property containing the image (default: "data")
  7. Configure timeout as needed
  8. Execute the workflow to generate a video from your input image

  ## Error Handling

  The node includes comprehensive error handling for:
  - API connection issues
  - Invalid workflow JSON
  - Execution failures
  - Timeout conditions
  - Input image validation

  ## Development

  ```bash
  # Install dependencies
  npm install

  # Build
  npm run build

  # Test
  npm run test

  # Lint
  npm run lint
  ```

  ## License

  [MIT](LICENSE.md)
   

ai_documentation_summary:
  {"purpose":"This n8n node integrates with ComfyUI to execute stable diffusion workflows for generating images and converting images to videos.","capabilities":["Execute ComfyUI workflows directly from n8n","Generate images using stable diffusion models","Convert images to videos using models like AnimateDiff or WanImageToVideo","Import and run workflows via JSON format","Accept image inputs via URL, Base64, or Binary properties","Monitor progress and handle errors","Support configurable timeout settings"],"authentication":"API key required (optional)","commonUseCases":["Generate images from text prompts using stable diffusion","Convert static images into animated videos","Run complex diffusion workflows without manual ComfyUI setup","Integrate video generation into automated marketing or content workflows"],"limitations":["Only returns the first video output if multiple are generated","Prioritizes video files with .webp, .mp4, or .gif extensions","Requires a running ComfyUI instance accessible via API","Node version requires n8n 1.0.0 or later"],"relatedNodes":["ComfyUI","HTTP Request","Binary File","Code"]}


node_type: n8n-nodes-data-validation.datavalidation
package_name: n8n-nodes-data-validation
display_name: datavalidation
description: This n8n community node validates input data using JSON Schemas.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: bartolomeumr
author_github_url: git+https://github.com/Bartmr/n8n-nodes-data-validation.git
npm_package_name: n8n-nodes-data-validation
npm_version: 1.0.1
community_fetched_at: 2026-03-25T21:19:41.767Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  ## How to

  This n8n community node validates input data using JSON Schemas.

  Visit <https://ajv.js.org/> or <https://json-schema.org/> to learn how to describe your validation rules in JSON Schemas.

  ## Library development

  ### Changing the supported Node version

  - Files to be changed
    - .nvmrc
    - Dockerfile.dev
    - package.json
      - `engine` field
      - `@types/node` version
    - tsconfig.base.json
    - .github/workflows/main.yml and other CI config files
  - delete all `node_modules` directories and `package-lock.json` files
  - run `npm run install`

ai_documentation_summary:
  {"purpose":"Validates input data against JSON Schemas to ensure data integrity and format compliance.","capabilities":["JSON Schema validation","Input data verification","Format compliance checking"],"authentication":"None","commonUseCases":["Validating API request payloads","Ensuring data format before processing","Quality control for incoming data streams"],"limitations":["Requires external JSON Schema definitions"],"relatedNodes":["n8n-nodes-http.request","n8n-nodes-http.response"]}


node_type: n8n-nodes-helicone.helicone
package_name: n8n-nodes-helicone
display_name: helicone
description: n8n node for Helicone AI gateway and observability
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: _juliettech
author_github_url: git+https://github.com/Helicone/n8n-nodes-helicone.git
npm_package_name: n8n-nodes-helicone
npm_version: 1.0.4
community_fetched_at: 2026-03-25T21:19:41.771Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-helicone

  This is an n8n community node that provides a LangChain-compatible Helicone Chat Model for use in AI chains and workflows. The node routes requests to your chosen LLM provider through the Helicone AI Gateway.

  [Helicone](https://helicone.ai) is an open-source LLM observability platform that helps developers monitor, debug, and improve production AI applications.

  ## Installation

  ### 1. Build the Node
  Clone the repository and install dependencies:
  ```bash
  git clone https://github.com/helicone/n8n-nodes-helicone.git
  cd n8n-nodes-helicone
  pnpm install
  pnpm build
  ```

  ### 2. Install as n8n Community Node
  You can install this node as an n8n community node:

  ```bash
  # Install via npm
  npm install n8n-nodes-helicone

  # Or install via pnpm
  pnpm add n8n-nodes-helicone
  ```

  ### 3. Alternative: Manual Installation
  If you prefer to install manually, navigate to your n8n folder (usually `~/.n8n` on macOS/Linux):
  ```bash
  cd ~/.n8n
  mkdir custom
  cd custom
  pnpm init
  ```

  Link your built node to the n8n custom folder:
  ```bash
  pnpm link /path/to/your/n8n-nodes-helicone
  ```
  Replace `/path/to/your/n8n-nodes-helicone` with the actual path to your repository.

  ### 4. Start n8n
  ```bash
  n8n start
  ```

  ### 5. Access n8n Interface
  Open your browser and go to: `http://localhost:5678`

  ## 6. Add Helicone API Credentials

    - Go to **Credentials > New**
    - Select **Helicone LLM Observability**
    - Enter your Helicone API key (get it from [Helicone Dashboard](https://helicone.ai/dashboard))
    - The base URL is automatically set to `https://ai-gateway.helicone.ai/`

  ## 7. Create a workflow and add your Helicone Chat Model node

  The Helicone Chat Model node is designed to work as part of any AI chain. It outputs a LangChain-compatible model that can be used with other AI nodes.

  **Node Configuration:**
  1. **AI Model:** Choose any model supported by Helicone AI Gateway (find them here: https://helicone.ai/models - e.g, `gpt-4.1-mini`, `claude-3-opus-20240229`).
  2. **Options:**
     - **Temperature:** Sampling temperature (0-2)
     - **Max Tokens:** Maximum number of tokens to generate
     - **Top P:** Nucleus sampling parameter (0-1)
     - **Frequency Penalty:** Control repetition (-2 to 2)
     - **Presence Penalty:** Control new topics (-2 to 2)
     - **Response Format:** Text or JSON
     - **Timeout:** Request timeout in milliseconds
     - **Max Retries:** Number of retry attempts

  **Helicone Options:**
  - **Custom Properties:** JSON object for metadata and filtering
  - **Session Tracking:** Session ID, Path, and Name for grouping requests
  - **Caching:** Enable response caching with configurable TTL (up to 365 days)

  ## How It Works

  The Helicone Chat Model node uses the [Helicone AI Gateway](https://ai-gateway.helicone.ai) to route requests to your chosen LLM provider. The node implements the `LmChatHelicone` class and provides a LangChain-compatible ChatOpenAI interface.

  This provides:
  - **Unified Interface:** Single endpoint for multiple providers
  - **Automatic fallbacks:** If the primary provider is down, the node will automatically use a fallback provider
  - **Observability:** Track usage, performance, and costs across providers
  - **Caching:** Reduce costs with intelligent response caching and reduce latency with intelligent caching
  - **Session Tracking:** Group related requests with session management
  - **Custom Properties:** Add metadata for filtering and analysis

  ## Usage in AI Chains

  This node is designed to be used as part of n8n's AI chain functionality:

  1. **Add the Helicone Chat Model node** to your workflow
  2. **Configure the model** with your desired parameters
  3. **Connect it to other AI nodes** that accept `ai_languageModel` inputs
  4. **Use in chains** for complex AI workflows

  The node outputs a LangChain-compatible model that can be used with:
  - Chat nodes
  - Chain nodes
  - Other AI processing nodes

  ## Helicone Features

  The node supports various Helicone observability features:

  - **Custom Properties:** Add metadata to requests for filtering and analysis
  - **Session Tracking:** Group related requests with Session ID, Path, and Name
  - **Caching:** Enable response caching with configurable TTL (up to 365 days)
  - **Automatic Logging:** All requests are automatically logged in your Helicone dashboard

  ## Response Format

  The node returns a LangChain ChatOpenAI model instance that can be used with other AI nodes. The underlying responses include:

  - Generated content
  - Token usage information
  - Model information
  - Helicone-specific metadata

  All requests are automatically logged in your Helicone dashboard for observability and analysis.

  ## Troubleshooting

  ### Common Issues

  1. **Authentication Errors**
     - Verify your Helicone API key is correct (starts with `pk-` for write access)
     - Ensure your Helicone account has access to the chosen provider

  2. **Model Errors**
     - Validate your model name is correct for the chosen provider
     - Check if the model is available in your Helicone account

  3. **Chain Integration Issues**
     - Ensure the node is properly connected to other AI nodes
     - Verify the output type is compatible with downstream nodes

  ### Getting Help

  - [Helicone Documentation](https://docs.helicone.ai)
  - [n8n Community Forum](https://community.n8n.io)
  - [Helicone Discord](https://discord.gg/helicone)

  ## License

  MIT

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Helicone documentation](https://docs.helicone.ai)
  - [Helicone GitHub](https://github.com/Helicone/helicone)
  - [This Node's GitHub](https://github.com/juliettech13/n8n-nodes-helicone)
  - [LangChain documentation](https://js.langchain.com/)

ai_documentation_summary:
  {"purpose":"A community n8n node that acts as a LangChain-compatible gateway to route AI requests through Helicone for observability, caching, and multi-provider fallback.","capabilities":["Route requests to multiple LLM providers via Helicone AI Gateway","Implement automatic fallback to secondary providers if primary is down","Enable response caching with configurable TTL (up to 365 days)","Track usage, performance, and costs across providers","Group requests using session tracking (Session ID, Path, Name)","Add custom metadata properties for filtering and analysis","Support standard LLM parameters (Temperature, Max Tokens, Top P, Penalties)","Output LangChain-compatible ChatOpenAI interface"],"authentication":"API key required (Helicone API key starting with 'pk-')","commonUseCases":["Monitoring and debugging production AI applications","Reducing costs through intelligent response caching","Unifying access to multiple LLM providers in one workflow","Tracking token usage and latency across different models","Grouping related AI requests for session-based analysis"],"limitations":["Community node (requires manual installation or npm/pnpm install)","Requires Helicone account with access to chosen LLM providers","API key must have write access (starts with 'pk-')","Model availability depends on Helicone account permissions"],"relatedNodes":["LangChain nodes","Chat nodes","Chain nodes","AI Language Model nodes"]}


node_type: n8n-nodes-c10_great_lotus.c10_great_lotus
package_name: n8n-nodes-c10_great_lotus
display_name: c10_great_lotus
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: meomay22
npm_package_name: n8n-nodes-c10_great_lotus
npm_version: 0.1.57
community_fetched_at: 2026-03-25T21:19:41.772Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  10 action groups: ManagerAction, MouseAction, KeyboardAction, BrowserControl, ElementAction, ImageAction, OthersAction, EmailAction, DeveloperAction, General Debug

npm_readme:
  # n8n-nodes-c10-great-lotus

  Unified GREAT LOTUS MQTT node.

  Highlights:
  1. Existing browser control groups are preserved (Mouse, Keyboard, Browser, Element, Image, Others, Email, Developer, General Debug).
  2. `ManagerAction` now also includes GPM profile actions from C11:
     - `list_profiles`, `get_profile_info`, `create_profile`, `open_profile`, `close_profile`, `update_profile`, `delete_profile`, `list_groups`
  3. `GPM_connect` can open GPM profile first (by `profile_id`) and then attach Playwright to the same `remote_port`.
  4. `quit` will close GPM profile (when session was created from `profile_id`) or close local browser session as usual.

  Quick start:
  1. Use Node.js `>=20.15` (for example: `nvm use` from this folder)
  2. `npm install`
  3. `npm run build`

ai_documentation_summary:
  {"purpose":"A unified MQTT node for the GREAT LOTUS automation framework that integrates browser control actions and GPM profile management.","capabilities":["ManagerAction: list_profiles, get_profile_info, create_profile, open_profile, close_profile, update_profile, delete_profile, list_groups","MouseAction","KeyboardAction","BrowserControl","ElementAction","ImageAction","OthersAction","EmailAction","DeveloperAction","General Debug"],"authentication":"None","commonUseCases":["Automated browser testing via Playwright","GPM profile management and remote session attachment","Unified automation workflows combining mouse, keyboard, and element interactions"],"limitations":["Requires Node.js >=20.15","Requires manual installation of dependencies (npm install) and building the node (npm run build)"],"relatedNodes":["n8n-nodes-mqtt","n8n-nodes-playwright"]}


node_type: n8n-nodes-glpi-v2-fork.glpiv2fork
package_name: n8n-nodes-glpi-v2-fork
display_name: glpiv2fork
description: GLPI Rest API Node compatible with GLPI API V2.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: marcoscamposyesh
author_github_url: git+https://github.com/YeshShareDEV/n8n-nodes-glpi-v2-glpi11.git
npm_package_name: n8n-nodes-glpi-v2-fork
npm_version: 2.1.17-rc.31
community_fetched_at: 2026-03-25T21:19:41.773Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-glpi-v2-glpi11

  ![version](https://img.shields.io/badge/version-2.0.12.13-blue) ![n8n](https://img.shields.io/badge/n8n-community-orange) ![GLPI](https://img.shields.io/badge/GLPI-REST%20API-blue)

  Node para integração do [GLPI](https://glpi-project.org/) com o [n8n](https://n8n.io/), compatível com a API REST V2 do GLPI.

  ## ✨ Funcionalidades
  - Autenticação automática via initSession (sem precisar criar node HTTP manual)
  - Suporte a operações de CRUD para Tickets, Changes, Problems, Computers, Softwares e comentários
  - Gerenciamento automático do Session-Token
  - Compatível com n8n Cloud e Self-hosted
  - Credenciais seguras (GLPI URL, App Token, Username, Password)

  --

  Nota rápida: para a criação/atualização de usuários em `Administration/User` o node agora espera o payload como JSON bruto no campo `Input (raw)`.
  Use a opção `Send raw body` para enviar exatamente esse JSON (sem o wrapper `{ "input": ... }`). Campos individuais como Name/Email/Password foram removidos do formulário para evitar ambiguidade.

  ## 🚀 Instalação

  1. Clone ou baixe este repositório
  2. Execute `npm install` para instalar as dependências
  3. Use os scripts disponíveis para build/dev:
     - `npm run build` — build de produção
     - `npm run dev` — modo desenvolvimento

  ## 🔧 Configuração no n8n

  1. Importe o node customizado no painel do n8n
  2. Crie uma credencial do tipo **GLPI API** informando:
     - GLPI URL (ex: https://glpi.seudominio.com/api.php)
     - App Token
     - Username
     - Password
  3. Use o node "GLPI API" nos seus fluxos, escolhendo a operação desejada (Get, Add, Update, Comment)

  ## 🧩 Exemplo de Uso

  - Buscar um ticket:
    - Operation: Get
    - Item Type: Ticket
    - Item ID: 123
  - Criar um novo computador:
    - Operation: Add
    - Item Type: Computer
    - Payload: `{ "name": "PC-01", "serial": "123456" }`

  ## 📁 Estrutura do Projeto

  - `credentials/GlpiV2Api.credentials.ts` — definição das credenciais
  - `nodes/GlpiV2/GlpiV2.node.ts` — implementação principal do node
  - `nodes/GlpiV2/resources/` — módulos separados por área do GLPI
  - `n8n-nodes-glpi-instructions.md` — instruções detalhadas e exemplos

  ## 📜 Licença

  MIT — veja o arquivo [LICENSE.md](LICENSE.md)

ai_documentation_summary:
  {"purpose":"A custom n8n node that integrates with the GLPI v2 REST API, enabling automated CRUD operations on IT assets like tickets, computers, and problems.","capabilities":["Automatic session initialization via initSession","Automatic session token management","CRUD operations on Tickets","CRUD operations on Changes","CRUD operations on Problems","CRUD operations on Computers","CRUD operations on Softwares","Commenting on items","Raw JSON body support for user creation/updates","Compatible with n8n Cloud and Self-hosted environments"],"authentication":"Credentials (GLPI URL, App Token, Username, Password)","commonUseCases":["Automated IT asset tracking","Incident management via ticket creation","Computer inventory management","Change request processing","Problem tracking and resolution"],"limitations":["User creation/updates require raw JSON payload in the 'Input (raw)' field","Individual user fields (Name/Email/Password) are removed from the form to prevent ambiguity"],"relatedNodes":["GLPI API","HTTP Request","JSON"]}


node_type: n8n-nodes-supermachine.supermachine
package_name: n8n-nodes-supermachine
display_name: supermachine
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: hungtidus
author_github_url: git+https://github.com/hungtidus/n8n-nodes-supermachine.git
npm_package_name: n8n-nodes-supermachine
npm_version: 1.3.0
community_fetched_at: 2026-03-25T21:19:41.775Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  n8n community node for Supermachine AI Image API — Generate images, manage models, LoRAs, and characters

npm_readme:
  # n8n-nodes-supermachine

  [![npm version](https://badge.fury.io/js/n8n-nodes-supermachine.svg)](https://www.npmjs.com/package/n8n-nodes-supermachine)

  This is an n8n community node for the [Supermachine AI Image API](https://supermachine.art). It lets you generate AI images, manage models, LoRAs, and characters in your n8n workflows.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ### Via n8n UI

  1. Go to **Settings** > **Community Nodes**
  2. Select **Install**
  3. Enter `n8n-nodes-supermachine` in **Enter npm package name**
  4. Click **Install**
  5. Restart n8n

  ### Via CLI

  ```bash
  npm install n8n-nodes-supermachine

ai_documentation_summary:
  {"purpose":"A community n8n node that integrates with the Supermachine AI Image API to generate AI images, manage models, LoRAs, and characters within workflows.","capabilities":["Generate AI images via the Supermachine API","Manage AI models","Manage LoRAs (Low-Rank Adaptation models)","Manage characters"],"authentication":"API key required (implied by API integration, specific method not detailed in README)","commonUseCases":["Automated image generation for content creation","Workflow-based asset management for AI models and characters","Integration with other n8n nodes for multi-step image processing pipelines"],"limitations":["Community node (not official n8n node)","Authentication method not explicitly documented in README"],"relatedNodes":["n8n-nodes-http.request","n8n-nodes-webhook"]}


node_type: n8n-nodes-attio.attio
package_name: n8n-nodes-attio
display_name: attio
description: n8n node for Attio API integration
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: itsjustanks
author_github_url: git+https://github.com/itsjustanks/n8n-nodes-attio.git
npm_package_name: n8n-nodes-attio
npm_version: 0.6.0
community_fetched_at: 2026-03-25T21:19:41.776Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-attio

  This is an n8n community node that allows you to integrate [Attio](https://attio.com) CRM with your n8n workflows.

  [Attio](https://attio.com) is a modern CRM built for the future of work, offering powerful data models, flexible workflows, and real-time collaboration features.

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Operations

  This node supports all Attio API operations as defined in their [OpenAPI specification](https://api.attio.com/openapi.json), including:

  - **Objects**: List, Create, Get, Update objects
  - **Records**: List, Create, Get, Update, Delete records  
  - **Attributes**: List, Create, Get, Update attributes
  - **Lists**: List, Create, Get, Update lists
  - **Entries**: List, Create, Get, Update, Delete list entries
  - **Notes**: Create, Get, Update notes
  - **Tasks**: List, Create, Get, Update tasks
  - **Comments**: List, Create comments on threads
  - **Workspace Members**: List workspace members
  - **Webhooks**: Create and manage webhooks
  - And more...

  ## Credentials

  To use this node, you'll need an Attio API access token:

  1. Log in to your [Attio account](https://app.attio.com)
  2. Go to Workspace Settings → Developer → API
  3. Create a new API token
  4. Copy the token and add it to the Attio credentials in n8n

  ## AI Agent Tool Compatibility

  This node can be used as a tool in n8n's AI Agent workflows. To enable this functionality:

  1. Set the environment variable when running n8n:
     ```bash
     N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true
     ```

  2. In your AI Agent workflow:
     - Add an AI Agent node (e.g., OpenAI Functions Agent)
     - Add the Attio node
     - Connect the Attio node to the AI Agent as a tool

  The AI agent will be able to use Attio operations to search, create, and update CRM data based on natural language instructions.

  ## MCP (Model Context Protocol) Integration

  This node is compatible with n8n's MCP Server, allowing AI agents and MCP clients to interact with Attio CRM:

  - **AI Agent Tool**: Use Attio operations directly in AI agent workflows
  - **MCP Server**: Expose Attio workflows to external MCP clients like Claude Desktop
  - **Intelligent CRM**: Build AI-powered workflows that can query and update customer data

  See the [MCP Integration Guide](MCP_INTEGRATION_GUIDE.md) for detailed setup instructions and examples.

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Attio API documentation](https://docs.attio.com/rest-api)
  - [Attio OpenAPI specification](https://api.attio.com/openapi.json)
  - [MCP Integration Guide](MCP_INTEGRATION_GUIDE.md)

  ## Credits

  - **Created by**: [@itsjustanks](https://x.com/itsjustanks) | [ankit.com.au](https://ankit.com.au)
  - **OpenAPI Integration**: Built using [@devlikeapro/n8n-openapi-node](https://www.npmjs.com/package/@devlikeapro/n8n-openapi-node) - Special thanks to the n8n-openapi-node project for making it easy to convert OpenAPI specs to n8n nodes

  ## License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

ai_documentation_summary:
  {"purpose":"Integrates Attio CRM with n8n workflows to perform CRUD operations on CRM objects, records, lists, and other data entities.","capabilities":["List, Create, Get, Update objects","List, Create, Get, Update, Delete records","Manage attributes (List, Create, Get, Update)","Manage lists (List, Create, Get, Update)","Manage list entries (List, Create, Get, Update, Delete)","Create, Get, Update notes","Manage tasks (List, Create, Get, Update)","Create and manage comments on threads","List workspace members","Create and manage webhooks"],"authentication":"API token required (Attio API access token obtained from Workspace Settings → Developer → API)","commonUseCases":["Automating CRM data entry from other sources","Syncing customer data between systems","Building AI-powered CRM assistants","Managing tasks and notes within Attio","Integrating with n8n's AI Agent workflows"],"limitations":["Community node (not official n8n node)","Requires Attio API access token with appropriate permissions","MCP and AI Agent tool usage requires specific environment variable configuration"],"relatedNodes":["n8n-openapi-node","AI Agent node","MCP Server"]}


node_type: n8n-nodes-cnpj.cnpj
package_name: n8n-nodes-cnpj
display_name: cnpj
description: Search for details of a Brazilian company using a CNPJ. By https://integre.me/.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: integreme
author_github_url: git+https://github.com/Integreme/integreme-cnpj.git
npm_package_name: n8n-nodes-cnpj
npm_version: 1.0.0
community_fetched_at: 2026-03-25T21:19:41.778Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  Search for details of a Brazilian company using a CNPJ.

  Developed by [integre.me](https://integre.me/) 💚

ai_documentation_summary:
  {"purpose":"Retrieves detailed information about a Brazilian company by searching using its CNPJ (Cadastro Nacional da Pessoa Jurídica) number.","capabilities":["Search company details by CNPJ","Retrieve company registration information","Access company status and legal data"],"authentication":"None","commonUseCases":["Business verification in Brazil","Due diligence checks","Company research and validation"],"limitations":["Limited to Brazilian companies only","Depends on data availability from the source provider"],"relatedNodes":["http request","data filter","business data nodes"]}


node_type: n8n-nodes-bedrock-advanced.bedrockadvanced
package_name: n8n-nodes-bedrock-advanced
display_name: bedrockadvanced
description: n8n community node for AWS Bedrock Chat Model with prompt caching support
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-03-25 21:19:41
author_name: unbalanced
npm_package_name: n8n-nodes-bedrock-advanced
npm_version: 0.4.9
community_fetched_at: 2026-03-25T21:19:41.779Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-bedrock-advanced

  Advanced n8n community nodes for AWS Bedrock, providing features not available in the official n8n Bedrock node. This package includes two nodes:

  | Node | API | Best For |
  |------|-----|----------|
  | **AWS Bedrock Chat Model (Advanced)** | Converse API | Multi-model support (Claude, Nova, Titan) with prompt caching |
  | **Bedrock Claude** | InvokeModel API | Full access to Claude-specific features |

  ## Installation

  ### In n8n (community node)

  1. Go to **Settings > Community Nodes**
  2. Enter `n8n-nodes-bedrock-advanced`
  3. Click **Install**

  ### Manual installation

  ```bash
  cd ~/.n8n
  npm install n8n-nodes-bedrock-advanced
  ```

  Then restart n8n.

  ---

  ## Node 1: AWS Bedrock Chat Model (Advanced)

  A drop-in replacement for the official [n8n AWS Bedrock Chat Model node](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.lmchatawsbedrock/), adding **granular prompt caching** and **accurate token usage metrics** via the Bedrock Converse API.

  ### Features

  - **Granular prompt caching** — independently cache the system prompt, tool definitions, and conversation history
  - **Configurable cache TTL** — 5 minutes or 1 hour (where supported)
  - **Accurate token usage metrics** including cache read/write breakdowns
  - **Multi-model support** — works with Claude, Amazon Nova, Titan, and any Converse API-compatible model
  - On-demand models and inference profiles
  - Debug logging toggle

  ### Prompt Caching

  When enabled, you can independently target three parts of the request for caching:

  | Cache Target | Default | Description |
  |---|---|---|
  | **Cache System Prompt** | On | Injects a `cachePoint` after the system message |
  | **Cache Tool Definitions** | Off | Injects a `cachePoint` after the last tool definition. TTL is preserved accurately. |
  | **Cache Conversation History** | Off | Injects a `cachePoint` at the end of the most recent prior turn, reducing cost in multi-turn conversations as history grows |

  **Supported TTL options:**

  | TTL | Supported Models |
  |-----|-----------------|
  | 5 minutes | All cacheable models (Claude 3.5 Sonnet v2, Claude 3.7 Sonnet, Claude Sonnet 4, Amazon Nova, etc.) |
  | 1 hour | Claude Opus 4.5/4.6, Claude Sonnet 4.5/4.6, Claude Haiku 4.5 |

  > **Note:** Due to a LangChain limitation ([#9014](https://github.com/langchain-ai/langchainjs/issues/9014)), the TTL field is stripped from system and conversation history cache points at the LangChain conversion layer. These always use the 5-minute default regardless of the TTL setting. Tool cache points preserve the TTL correctly.

  **Requirements:**
  - Cached content must remain identical across requests for cache hits
  - Minimum token thresholds apply per model (1,024 for Sonnet/Nova, 4,096 for Opus/Haiku)

  ### Token Usage Metrics

  Every execution reports accurate token counts in n8n's AI panel:

  ```json
  {
    "tokenUsage": {
      "inputTokens": 150,
      "outputTokens": 500,
      "totalTokens": 650,
      "cacheReadInputTokens": 120,
      "cacheWriteInputTokens": 0
    }
  }
  ```

  ### Configuration

  1. Add the **AWS Bedrock Chat Model (Advanced)** node to your workflow
  2. Select your AWS credentials
  3. Choose your model (on-demand or inference profile)
  4. Under **Options**:
     - Toggle **Prompt Caching** and select TTL
     - Enable **Cache System Prompt**, **Cache Tool Definitions**, and/or **Cache Conversation History**
     - Adjust temperature and max tokens
     - Toggle **Debug Logs** to see detailed request/response logs

  ---

  ## Node 2: Bedrock Claude

  A Claude-specific node that uses the Bedrock **InvokeModel API** with the native Anthropic Messages API format. This bypasses the Converse API abstraction layer, giving full access to Claude-specific features.

  ### Features

  - **Granular prompt caching** — independently cache the system prompt, tool definitions, and conversation history, with full TTL control
  - **Built-in Claude tools** — web search, computer use, bash, text editor
  - **Tool search** — Claude dynamically discovers and loads tools on-demand from large tool sets
  - **Programmatic tool calling** — Claude calls tools from within code execution, reducing latency in multi-tool workflows
  - **Extended 1M context window** — for Claude Opus 4.6 and Sonnet 4.6
  - **Context compaction** — automatically summarizes older context when approaching the context window limit
  - **Streaming** support
  - **Tool calling** with full multi-turn conversation support
  - Debug logging toggle

  ### Why use this instead of the Advanced node?

  | Feature | Converse API (Advanced node) | InvokeModel (Bedrock Claude) |
  |---------|:---:|:---:|
  | Multi-model support | Yes | Claude only |
  | Standard tool calling | Yes | Yes |
  | Prompt caching — system prompt | Yes | Yes |
  | Prompt caching — tool definitions | Yes | Yes (full TTL control) |
  | Prompt caching — conversation history | Yes | Yes |
  | Web search tool | No | Yes |
  | Computer use tool | No | Yes |
  | Bash tool | No | Yes |
  | Text editor tool | No | Yes |
  | Tool search | No | Yes |
  | Programmatic tool calling | No | Yes |
  | 1M context window | No | Yes |
  | Context compaction | No | Yes |

  ### Prompt Caching

  When enabled, you can independently target three parts of the request:

  | Cache Target | Default | Description |
  |---|---|---|
  | **Cache System Prompt** | On | Adds `cache_control` to the last system message block |
  | **Cache Tool Definitions** | Off | Adds `cache_control` to the last non-deferred tool. Safe to use alongside Tool Search — deferred tools are excluded from the cache prefix automatically. |
  | **Cache Conversation History** | Off | Adds `cache_control` at the end of the most recent prior turn |

  **Cache TTL** (5m or 1h) is fully preserved for all three targets.

  ### Built-in Claude Tools

  Enable these directly in the node options — no external tool setup required:

  - **Web Search** — Claude can search the web during conversations
  - **Computer Use** — Claude can control mouse, keyboard, and take screenshots (configurable display dimensions)
  - **Bash** — Claude can execute shell commands
  - **Text Editor** — Claude can view and edit files

  ### Tool Search

  When enabled, agent tools are marked as `defer_loading: true`. Claude uses a search tool (regex or BM25) to discover and load only the tools relevant to each step — reducing prompt size and cost when working with large tool sets.

  Tool caching and tool search are fully compatible: `cache_control` is placed on the last non-deferred tool (built-in tools), and deferred agent tools follow after. This means the cache prefix is stable across calls even as Claude selectively loads different agent tools.

  ### Programmatic Tool Calling

  Allows Claude to call tools from within code execution (via the `code_execution` tool), chaining multiple tool uses in a single server-side step. Reduces round-trips and token usage in multi-tool workflows.

  ### Context Compaction

  Automatically summarizes older parts of the conversation when the input approaches the configured token threshold, allowing effective conversations beyond 200K tokens without hitting context limits.

  ### 1M Context Window

  Enables the extended 1M token context window (default is 200K). Supported on Claude Opus 4.6 and Sonnet 4.6.

  ### Configuration

  1. Add the **Bedrock Claude** node to your workflow
  2. Select your AWS credentials
  3. Choose your Claude model (the dropdown filters to Claude inference profiles only)
  4. Under **Options**:
     - Set **Max Tokens** and **Temperature**
     - Toggle **Prompt Caching** and select TTL
     - Enable **Cache System Prompt**, **Cache Tool Definitions**, and/or **Cache Conversation History**
     - Enable any **built-in tools** (web search, computer use, bash, text editor)
     - Toggle **Tool Search** and choose variant (regex or BM25)
     - Toggle **Programmatic Tool Calling**
     - Toggle **Enable 1M Context**
     - Toggle **Enable Compaction** and set trigger token threshold
     - Toggle **Debug Logs**

  ---

  ## AWS IAM Permissions

  Both nodes require the following IAM permissions:

  ```json
  {
    "Effect": "Allow",
    "Action": [
      "bedrock:InvokeModel",
      "bedrock:InvokeModelWithResponseStream",
      "bedrock:ListFoundationModels",
      "bedrock:ListInferenceProfiles",
      "bedrock:GetInferenceProfile"
    ],
    "Resource": "*"
  }
  ```

  ## Development

  ```bash
  # Install dependencies
  npm install

  # Build
  npm run build

  # Watch mode
  npm run dev
  ```

  ## License

  MIT

ai_documentation_summary:
  {"purpose":"Provides advanced AWS Bedrock integration with prompt caching support and multi-model capabilities for AI workflows.","capabilities":["Multi-model support (Claude, Nova, Titan)","Prompt caching with configurable TTL (5 minutes or 1 hour)","Detailed token usage metrics including cache read/write breakdowns","Built-in Claude tools (web search, computer use, bash, text editor)","Streaming support","Full multi-turn conversation support","Debug logging","On-demand models and inference profiles"],"authentication":"AWS IAM credentials via AWS credentials node","commonUseCases":["Cost optimization through prompt caching","Multi-model experimentation","Claude-specific tool integration","Detailed token tracking for billing analysis"],"limitations":["Programmatic tool calling is pending Bedrock support","Prompt caching TTL limits apply to some models","Minimum token thresholds required for caching","Bedrock Claude node only supports Claude models"],"relatedNodes":["AWS Bedrock Chat Model (official)","AWS Credentials","HTTP Request"]}


node_type: n8n-nodes-playwright.playwright
package_name: n8n-nodes-playwright
display_name: playwright
description: n8n-community-node-package for browser automation using Playwright
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-16 09:43:37
author_name: toema
author_github_url: git+https://github.com/toema/n8n-playwright.git
npm_package_name: n8n-nodes-playwright
npm_version: 0.2.21
community_fetched_at: 2026-04-16T09:43:37.371Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-playwright

  This is an n8n community node. It lets you automate browser actions using Playwright in your n8n workflows.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Custom Scripts](#custom-scripts)  
  [Compatibility](#compatibility)  
  [Resources](#resources)  
  [Version history](#version-history)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ```bash
  pnpm install n8n-nodes-playwright
  ```

  **Note:** The package will automatically download and set up the required browser binaries during installation. This requires approximately 1GB of disk space.

  If you need to manually trigger the browser setup:

  ```bash
  pnpm rebuild n8n-nodes-playwright
  ```

  ## Operations

  This node supports the following operations:

  ### Standard Operations

  - **Navigate**: Go to a specified URL and retrieve page content
  - **Take Screenshot**: Capture a screenshot of a webpage (full page or viewport)
  - **Get Text**: Extract text from an element using CSS selector or XPath
  - **Click Element**: Click on an element using CSS selector or XPath
  - **Fill Form**: Fill a form field using CSS selector or XPath
  - **Run Custom Script**: Execute custom JavaScript code with full Playwright API access

  ### Browser Options

  - Choose between **Chromium**, **Firefox**, or **WebKit**
  - Configure **headless mode**
  - Adjust operation speed with **slow motion** option

  ### Selector Options

  For `Get Text`, `Click Element`, and `Fill Form` operations, you can choose between:

  - **CSS Selector**: Standard CSS selectors (e.g., `#submit-button`, `.my-class`, `button[type="submit"]`)
  - **XPath**: XPath expressions (e.g., `//button[@id="submit"]`, `//div[contains(@class, "content")]`)

  ### Screenshot Options

  - Full page capture
  - Custom save path
  - Base64 output

  ## Custom Scripts

  The **Run Custom Script** operation gives you complete control over Playwright to automate complex browser interactions, scrape data, generate PDFs/screenshots, and more. Scripts run in a sandboxed environment with access to the full Playwright API and n8n's Code node features.

  ### Available Variables

  Access Playwright-specific objects using:

  - `$page` - Current page instance
  - `$browser` - Browser instance
  - `$playwright` - Playwright library
  - `$helpers` - n8n helper methods (including `prepareBinaryData`)

  Plus all special variables and methods from the Code node are available:
  - `$json` - Current item's JSON data
  - `$input` - Access to input data
  - `$getNodeParameter()` - Get node parameters
  - And more from [n8n documentation](https://docs.n8n.io/code-examples/methods-variables-reference/)

  ### Script Examples

  #### Basic Navigation and Data Extraction

  ```javascript
  // Navigate to a URL
  await $page.goto('https://example.com');

  // Get page title and content
  const title = await $page.title();
  const content = await $page.textContent('body');

  console.log('Page title:', title);

  // Return results
  return [{
      json: { 
          title,
          content,
          url: $page.url()
      }
  }];
  ```

  #### Web Scraping with Selectors

  ```javascript
  await $page.goto('https://news.ycombinator.com');

  // Scrape all story titles
  const stories = await $page.$$eval('.titleline > a', elements => 
      elements.map(el => ({
          title: el.textContent,
          url: el.href
      }))
  );

  console.log(`Found ${stories.length} stories`);

  return stories.map(story => ({ json: story }));
  ```

  #### Form Automation

  ```javascript
  await $page.goto('https://example.com/login');

  // Fill form fields
  await $page.fill('#username', 'myuser');
  await $page.fill('#password', 'mypass');

  // Click submit button
  await $page.click('button[type="submit"]');

  // Wait for navigation
  await $page.waitForNavigation();

  console.log('Logged in successfully');

  return [{
      json: {
          success: true,
          finalUrl: $page.url()
      }
  }];
  ```

  #### Taking Screenshots as Binary Data

  ```javascript
  await $page.goto('https://www.google.com');

  // Take screenshot
  const screenshot = await $page.screenshot({ 
      type: 'png',
      fullPage: true 
  });

  // Prepare binary data
  const binaryData = await $helpers.prepareBinaryData(
      Buffer.from(screenshot),
      'screenshot.png',
      'image/png'
  );

  return [{
      json: {
          url: $page.url(),
          timestamp: new Date().toISOString()
      },
      binary: {
          screenshot: binaryData
      }
  }];
  ```

  #### Storing and Reusing Cookies

  **Script 1 - Login and Save Cookies**

  ```javascript
  await $page.goto('https://www.example.com/login');

  // Perform login
  await $page.fill('#login-username', 'user');
  await $page.fill('#login-password', 'pass');
  await $page.click('#login-button');

  // Wait for login to complete
  await $page.waitForNavigation();

  // Get browser context and save cookies
  const context = $page.context();
  const cookies = await context.cookies();

  console.log('Login successful, cookies saved');

  return [{
      json: { 
          cookies,
          loginSuccess: true
      }
  }];
  ```

  **Script 2 - Restore Cookies and Access Protected Page**

  ```javascript
  const { cookies } = $input.first().json;

  // Create new context with saved cookies
  const context = $page.context();
  await context.addCookies(cookies);

  // Navigate to authenticated page
  await $page.goto('https://example.com/protected-page');

  // Perform authenticated operations
  const data = await $page.textContent('.protected-content');

  console.log('Accessed protected page successfully');

  return [{
      json: { 
          data,
          authenticated: true
      }
  }];
  ```

  #### Advanced: Multiple Operations

  ```javascript
  await $page.goto('https://example.com/products');

  // Wait for products to load
  await $page.waitForSelector('.product-item');

  // Get all product data
  const products = await $page.$$eval('.product-item', items =>
      items.map(item => ({
          name: item.querySelector('.product-name')?.textContent,
          price: item.querySelector('.product-price')?.textContent,
          image: item.querySelector('img')?.src
      }))
  );

  // Take a screenshot
  const screenshot = await $page.screenshot({ type: 'png' });
  const screenshotBinary = await $helpers.prepareBinaryData(
      Buffer.from(screenshot),
      'products.png',
      'image/png'
  );

  console.log(`Scraped ${products.length} products`);

  return [{
      json: { 
          products,
          scrapedAt: new Date().toISOString(),
          totalProducts: products.length
      },
      binary: {
          screenshot: screenshotBinary
      }
  }];
  ```

  #### Using XPath Selectors

  ```javascript
  await $page.goto('https://example.com');

  // Use XPath to find elements
  const button = await $page.locator('xpath=//button[contains(text(), "Submit")]');
  await button.click();

  // XPath for complex selections
  const items = await $page.locator('xpath=//div[@class="item" and @data-active="true"]').all();
  const itemTexts = await Promise.all(items.map(item => item.textContent()));

  console.log(`Found ${itemTexts.length} active items`);

  return [{
      json: {
          activeItems: itemTexts
      }
  }];
  ```

  #### Error Handling

  ```javascript
  try {
      await $page.goto('https://example.com');
      
      // Try to find element with timeout
      const element = await $page.waitForSelector('.my-element', { 
          timeout: 5000 
      });
      
      const text = await element.textContent();
      
      return [{
          json: { 
              success: true,
              text 
          }
      }];
  } catch (error) {
      console.error('Error occurred:', error.message);
      
      return [{
          json: {
              success: false,
              error: error.message
          }
      }];
  }
  ```

  #### Working with Multiple Pages

  ```javascript
  // Open a new page
  const newPage = await $browser.newPage();
  await newPage.goto('https://example.com/page2');

  // Work with both pages
  const page1Title = await $page.title();
  const page2Title = await newPage.title();

  console.log('Page 1:', page1Title);
  console.log('Page 2:', page2Title);

  // Close the new page
  await newPage.close();

  return [{
      json: {
          page1Title,
          page2Title
      }
  }];
  ```

  #### Generating PDFs

  ```javascript
  await $page.goto('https://example.com');

  // Generate PDF
  const pdf = await $page.pdf({
      format: 'A4',
      printBackground: true,
      margin: {
          top: '20px',
          right: '20px',
          bottom: '20px',
          left: '20px'
      }
  });

  // Prepare binary data
  const binaryData = await $helpers.prepareBinaryData(
      Buffer.from(pdf),
      'document.pdf',
      'application/pdf'
  );

  return [{
      json: {
          url: $page.url(),
          timestamp: new Date().toISOString()
      },
      binary: {
          pdf: binaryData
      }
  }];
  ```

  #### Waiting for Dynamic Content

  ```javascript
  await $page.goto('https://example.com');

  // Wait for network to be idle
  await $page.waitForLoadState('networkidle');

  // Wait for specific element to appear
  await $page.waitForSelector('.dynamic-content', { timeout: 10000 });

  // Wait for element to be visible
  await $page.locator('.modal').waitFor({ state: 'visible' });

  // Extract data after everything has loaded
  const content = await $page.textContent('.dynamic-content');

  return [{
      json: { content }
  }];
  ```

  #### Handling File Downloads

  ```javascript
  await $page.goto('https://example.com/downloads');

  // Start waiting for download before clicking
  const downloadPromise = $page.waitForEvent('download');
  await $page.click('#download-button');

  const download = await downloadPromise;

  // Get download details
  const fileName = download.suggestedFilename();
  const downloadPath = await download.path();

  console.log(`Downloaded: ${fileName}`);

  return [{
      json: {
          fileName,
          downloadPath,
          success: true
      }
  }];
  ```

  ### Custom Script Tips

  1. **Always return an array**: Your script must return an array of objects like `return [{ json: {...} }];`
  2. **Use console.log()**: Debug by logging to the console - output appears in n8n UI during manual execution
  3. **Handle errors**: Use try-catch for robust scripts
  4. **Binary data**: Use `$helpers.prepareBinaryData()` for images, PDFs, or other files
  5. **Async/await**: All Playwright operations are async, always use `await`
  6. **Access input data**: Use `$json` or `$input` to access data from previous nodes
  7. **Browser cleanup**: The browser is automatically closed after script execution

  ## Compatibility

  - Requires n8n version 1.0.0 or later
  - Tested with Playwright version 1.49.0
  - Supports Windows, macOS, and Linux

  ### System Requirements

  - Node.js 18.10 or later
  - Approximately 1GB disk space for browser binaries
  - Additional system dependencies may be required for browser automation

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Playwright documentation](https://playwright.dev/docs/intro)
  - [Playwright API Reference](https://playwright.dev/docs/api/class-playwright)

  ## Version history

  ### 0.3.0

  - Added **Run Custom Script** operation with full Playwright API access
  - Added **XPath selector** support for Get Text, Click Element, and Fill Form operations
  - Added sandboxed JavaScript execution environment
  - Improved error handling and user feedback
  - Fixed navigate operation to return page content properly

  ### 0.2.*

  - Added selector-based operations (getText, clickElement, fillForm)
  - Improved browser binary installation process
  - Bug fixes and performance improvements

  ### 0.1.*

  - Initial release
  - Basic browser automation operations
  - Support for Chromium, Firefox, and WebKit
  - Screenshot and navigation capabilities

  ## Troubleshooting

  ### Browsers Not Installed

  If browsers are not installed correctly:

  1. Clean the installation:

  ```bash
  rm -rf ~/.cache/ms-playwright
  # or for Windows:
  rmdir /s /q %USERPROFILE%\AppData\Local\ms-playwright
  ```

  2. Rebuild the package:

  ```bash
  pnpm rebuild n8n-nodes-playwright
  ```

  ### Custom Script Errors

  If your custom script fails:

  1. Check that you're returning an array: `return [{ json: {...} }];`
  2. Use `console.log()` to debug and see output in n8n UI
  3. Wrap code in try-catch blocks for better error handling
  4. Verify all Playwright operations use `await`

  ### Selector Not Found

  If elements can't be found:

  1. Try using XPath instead of CSS selector (or vice versa)
  2. Use `await $page.waitForSelector('selector')` to wait for elements
  3. Check if content is in an iframe: `await $page.frameLocator('iframe').locator('selector')`
  4. Verify the page has fully loaded: `await $page.waitForLoadState('networkidle')`

  ## License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

  ---

  ## Contributing

  Contributions are welcome! Please feel free to submit a Pull Request.

  ## Support

  If you encounter any issues or have questions:

  1. Check the [Troubleshooting](#troubleshooting) section
  2. Review the [Playwright documentation](https://playwright.dev/docs/intro)
  3. Open an issue on [GitHub](https://github.com/toema/n8n-playwright/issues)

  ## Author

  **Mohamed Toema**  
  Email: m.toema20@gmail.com  
  GitHub: [@toema](https://github.com/toema)

ai_documentation_summary:
  {"purpose":"Automates browser actions in n8n workflows using Playwright for tasks like navigation, data extraction, form filling, and screenshot capture.","capabilities":["Navigate to URLs and retrieve page content","Take full-page or viewport screenshots (including Base64 output)","Extract text from elements using CSS selectors or XPath","Click elements using CSS selectors or XPath","Fill form fields using CSS selectors or XPath","Execute custom JavaScript with full Playwright API access","Support multiple browsers (Chromium, Firefox, WebKit)","Configure headless mode and slow motion","Handle binary data output","Manage cookies for session persistence"],"authentication":"None","commonUseCases":["Web scraping and data extraction","Form automation and login workflows","Screenshot generation for reports","Browser-based testing within n8n","Automated data collection from websites"],"limitations":["Requires approximately 1GB of disk space for browser binaries","Manual browser setup may be needed if not automatic","Custom scripts require JavaScript knowledge"],"relatedNodes":["Code","HTTP Request","Binary Data"]}


node_type: n8n-nodes-asaas-v2.asaasv2
package_name: n8n-nodes-asaas-v2
display_name: asaasv2
description: Nó n8n para integração com a API do Asaas
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-16 09:43:37
author_name: degoisrs
author_github_url: git+https://github.com/analixbi/n8n-nodes-asaas-v2.git
npm_package_name: n8n-nodes-asaas-v2
npm_version: 1.0.15
community_fetched_at: 2026-04-16T09:43:37.374Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-asaas-v2

  Este é um nó não oficial do n8n para integração com a API do Asaas v3.

  ## Sobre a Analix Business Intelligence

  A Analix Business Intelligence é uma empresa especializada em soluções tecnológicas para negócios, oferecendo:

  - Desenvolvimento de agentes de atendimento para redes sociais com IA
  - Sistemas de notificação automático para WooCommerce
  - Sistema de atendimento multi atendente
  - Desenvolvimento de sites WordPress com WooCommerce para venda

  ## Contato

  - Website: [analixbi.com.br](https://analixbi.com.br)
  - Email: contato@analixbi.com.br
  - Telefone: +55 (54) 99135-7745

  ## Recursos

  - Clientes
    - Criar
    - Listar
    - Buscar
    - Atualizar
    - Remover

  - Pagamentos
    - Criar
    - Listar
    - Buscar
    - Atualizar
    - Remover

  - Assinaturas
    - Criar
    - Listar
    - Buscar
    - Atualizar
    - Remover

  - Links de Pagamento
    - Criar
    - Listar
    - Buscar
    - Atualizar
    - Remover

  - PIX
    - Criar
    - Listar
    - Buscar
    - Remover

  ## Instalação

  ```bash
  npm install n8n-nodes-asaas-v2
  ```

  ## Configuração

  1. Acesse [Asaas](https://www.asaas.com)
  2. Faça login na sua conta
  3. Vá em Configurações > API
  4. Gere uma nova API Key
  5. Configure no n8n:
     - Nome: Asaas API
     - API Key: sua_api_key
     - Ambiente: Produção ou Sandbox

  ## Ambiente Sandbox

  Para testar sem custos reais, use o ambiente sandbox:

  - API Key de sandbox
  - Dados fictícios seguros
  - Sem cobranças reais

  ## Suporte

  Para suporte técnico:

  - Email: contato@analixbi.com.br
  - Telefone: +55 (54) 99135-7745
  - Website: [analixbi.com.br](https://analixbi.com.br)

  ## Licença

  MIT 

ai_documentation_summary:
  {"purpose":"An unofficial n8n node for integrating with the Asaas v3 API to manage financial operations like clients, payments, subscriptions, and PIX.","capabilities":["Create clients","List clients","Search clients","Update clients","Delete clients","Create payments","List payments","Search payments","Update payments","Delete payments"],"authentication":"API Key required","commonUseCases":["Automating client management in Brazilian businesses","Processing and tracking payments via Asaas","Managing subscription billing cycles","Handling PIX payments for instant transfers","Integrating Asaas API into n8n workflows for data processing"],"limitations":["Unofficial node (not maintained by Asaas or n8n core)","Support depends on the third-party developer (Analix Business Intelligence)"],"relatedNodes":["n8n-nodes-base.httpRequest","n8n-nodes-base.code"]}


node_type: n8n-nodes-llamacloud.llamacloud
package_name: n8n-nodes-llamacloud
display_name: llamacloud
description: LlamaCloud integration with n8n
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-16 09:43:37
author_name: ibrahho
author_github_url: git+https://github.com/Hossam-Dev-AI/n8n-llamacloud.git
npm_package_name: n8n-nodes-llamacloud
npm_version: 1.0.2
community_fetched_at: 2026-04-16T09:43:37.375Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n LlamaCloud Nodes

  This repository contains custom n8n nodes for integrating with [LlamaCloud](https://cloud.llamaindex.ai/?utm_source=demo&utm_medium=n8n), providing powerful document processing and retrieval capabilities within your n8n workflows.

  ## 🚀 Features

  This package includes three custom nodes:

  ### 📄 **[LlamaParse](https://www.llamaindex.ai/llamaparse?utm_source=demo&utm_medium=n8n)**
  - Parse PDF files and extract their content in markdown format
  - Uses LlamaCloud's document parsing capabilities
  - Perfect for document preprocessing workflows

  ### 🔍 **[LlamaExtract](https://www.llamaindex.ai/llamaextract?utm_source=demo&utm_medium=n8n)** 
  - Extract structured data from files using LlamaCloud extraction agents
  - Get elegant, structured information from documents
  - Ideal for data extraction and analysis workflows

  ### 💬 **[LlamaCloud](https://www.llamaindex.ai/llamacloud?utm_source=demo&utm_medium=n8)**
  - Retrieve context from your LlamaCloud indexes
  - Chat with your indexed documents
  - Great for building RAG (Retrieval-Augmented Generation) applications

  ## 📋 Prerequisites

  Before using these nodes, you need:

  1. **Node.js and npm** (Minimum version Node 20)
  > You can find instructions on how to install both using 
  nvm (Node Version Manager) for Linux, Mac, and WSL [here](https://github.com/nvm-sh/nvm). For 
  Windows users, refer to Microsoft's guide to [Install NodeJS on Windows](https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows).

  2. **n8n** installed globally
     ```bash
     npm install n8n -g
     ```

  3. **LlamaCloud API Key**
     - Sign up at [cloud.llamaindex.ai](https://cloud.llamaindex.ai/?utm_source=demo&utm_medium=n8n)
     - Get your API key from the dashboard

  ## 🛠️ Installation

  ### Option 1: Local Development (Recommended)

  1. **Clone this repository**
     ```bash
     git clone https://github.com/run-llama/n8n-llamacloud.git
     cd n8n-llamacloud
     ```

  2. **Install dependencies**
     ```bash
     npm install
     ```

  3. **Build the nodes and publish locally**
     ```bash
     npm run build
     npm link
     ```

  4. **Link to n8n custom nodes directory**
     ```bash
     # Create custom nodes directory if it doesn't exist
     mkdir -p ~/.n8n/custom
     npm link n8n-llamacloud
     ```

  5. **Restart n8n**
     ```bash
     n8n stop
     n8n start
     ```

  ### Option 2: Global Installation

  1. **Install globally**
     ```bash
     npm install -g n8n-llamacloud
     npm link
     ```

  2. **Restart n8n**
     ```bash
     n8n stop
     n8n start
     ```

  ## 🔧 Setup

  ### 1. Configure LlamaCloud Credentials

  1. Open n8n in your browser (usually `http://localhost:5678`)
  2. Go to **Settings** → **Credentials**
  3. Click **Add Credential**
  4. Search for **"LlamaCloud API Key"**
  5. Enter your LlamaCloud API key 
  6. Test the connection and save

  ### 2. Create LlamaCloud Indexes (for LlamaCloud node)

  1. Go to [cloud.llamaindex.ai](https://cloud.llamaindex.ai/?utm_source=demo&utm_medium=n8n)
  2. Create a new project
  3. Upload documents to create an index
  4. Note the index name for use in the LlamaCloud node

  ## 📚 Resources
  - [LlamaCloud Documentation](https://docs.cloud.llamaindex.ai/utm_source=demo&utm_medium=n8n)
  - [LlamaIndex Documentation](https://docs.llamaindex.ai/utm_source=demo&utm_medium=n8n)
  - [n8n Documentation](https://docs.n8n.io/)
  - [n8n Community](https://community.n8n.io/)


  ## 📖 Usage Examples

  ### Example 1: Document Processing Pipeline

  ```mermaid
  graph LR
      A[PDF File] --> B[LlamaParse]
      B --> C[LlamaExtract]
      C --> D[Structured Data]
  ```

  **Workflow:**
  1. **LlamaParse** node: Parse a PDF file to markdown
  2. **LlamaExtract** node: Extract structured data using an extraction agent
  3. Use the structured data in subsequent nodes

  ### Example 2: RAG Chat Application

  ```mermaid
  graph LR
      A[User Query] --> B[LlamaCloud]
      B --> C[Retrieved Context]
      C --> D[AI Response]
  ```

  **Workflow:**
  1. **HTTP Request** node: Receive user query
  2. **LlamaCloud** node: Retrieve relevant context from your index
  3. **OpenAI** node: Generate response using the retrieved context

  ### Example 3: Document Analysis

  ```mermaid
  graph LR
      A[Document] --> B[LlamaParse]
      B --> C[LlamaExtract]
      C --> D[Analysis Results]
  ```

  **Workflow:**
  1. **LlamaParse** node: Convert document to markdown
  2. **LlamaExtract** node: Extract specific information (e.g., dates, amounts, entities)
  3. **Code** node: Process and analyze the extracted data

  ## 🔍 Node Details

  ### LlamaParse Node

  **Purpose:** Parse PDF files and extract content in markdown format

  **Parameters:**
  - **File Path** (required): Path to the PDF file to parse
    - Example: `/Users/username/Documents/document.pdf`

  **Output:** Markdown content of the parsed document

  ### LlamaExtract Node

  **Purpose:** Extract structured data from files using LlamaCloud extraction agents

  **Parameters:**
  - **Agent ID** (required): The ID of your LlamaCloud extraction agent
  - **File Path** (required): Path to the file to extract data from

  **Output:** Structured data based on your extraction agent's configuration

  ### LlamaCloud Node

  **Purpose:** Retrieve context from your LlamaCloud indexes

  **Parameters:**
  - **Index Name** (required): Name of your LlamaCloud index
  - **Chat Input** (from previous node): The query to search for in your index

  **Output:** Retrieved context from your index

ai_documentation_summary:
  {"purpose":"This n8n node package integrates with LlamaCloud to provide document processing, structured data extraction, and retrieval capabilities for building RAG applications.","capabilities":["Parse PDF files and extract content in markdown format","Extract structured data from files using LlamaCloud extraction agents","Retrieve context from LlamaCloud indexes for chat applications","Support document preprocessing workflows","Enable Retrieval-Augmented Generation (RAG) workflows"],"authentication":"LlamaCloud API Key","commonUseCases":["Document preprocessing pipelines","Data extraction and analysis from documents","RAG chat applications","Document analysis workflows"],"limitations":["Requires Node.js version 20 or higher","Requires n8n installed globally","Requires local development build or global installation","Requires manual setup of LlamaCloud indexes"],"relatedNodes":["LlamaParse","LlamaExtract","LlamaCloud","HTTP Request","OpenAI"]}


node_type: n8n-nodes-highlevelv2.highlevelv2
package_name: n8n-nodes-highlevelv2
display_name: highlevelv2
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-16 09:43:37
author_name: marioaldayuz
author_github_url: git+https://github.com/marioaldayuz/n8n-highlevel.git
npm_package_name: n8n-nodes-highlevelv2
npm_version: 1.0.16
community_fetched_at: 2026-04-16T09:43:37.385Z
ai_summary_generated_at: 2026-05-02 08:57:17
description:
  n8n community node for HighLevel v2 API integration - comprehensive CRM, marketing automation, and business management platform

npm_readme:
  # n8n-nodes-highlevelv2 (BETA)

  This is an n8n community node that provides **comprehensive integration** with the HighLevel API v2, featuring **30 resources** with **100+ operations**. It allows you to seamlessly connect your n8n workflows with HighLevel's powerful CRM, marketing automation, and business management platform.

  Get your 30 Day FREE Trial of [HighLevel](https://www.gohighlevel.com/marioaldayuz) by clicking [HERE](https://www.gohighlevel.com/marioaldayuz)!

  [HighLevel](https://www.gohighlevel.com/marioaldayuz) is an all-in-one business platform that combines CRM, marketing automation, website building, funnel creation, appointment scheduling, and more into a single unified system.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  ## Table of Contents

  [Installation](#installation)  
  [Resources & Operations](#resources--operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Features](#features)  
  [Usage Examples](#usage-examples)  
  [Testing](#testing)  
  [Development](#development)  
  [Resources](#resources)  

  ## 🚀 Full Feature Overview

  This comprehensive n8n community node provides complete coverage of the HighLevel API v2 with:

  ### **30 Core Resources**
  Auth • Blog • Business • Calendar • Calendar Event • Calendar Group • Calendar Resource • Contact • Conversation • Coupon • Custom Field • Custom Objects • Custom Values • Email • Form • Funnel • Media • Notes • Appointment Notes • Object Associations • Opportunity • Product • Redirect • SaaS • Social Planner • Sub-Account • Survey • Task • Tags • User

  ### **100+ Operations** Including:
  - **Full CRUD Operations** across all resources
  - **Advanced Search & Filtering** with pagination
  - **Bulk Operations** for efficiency
  - **File Management** (upload, organize, delete)
  - **Relationship Management** (object associations)
  - **Marketing Automation** (email templates, social posts, funnels)
  - **E-commerce Features** (products, coupons, redirects)
  - **Business Management** (sub-accounts, users, SaaS)
  - **CRM Features** (contacts, conversations, notes, tags)
  - **Analytics & Reporting** (social analytics, funnel metrics)

  ### **Advanced Features**
  - 🔄 **Automatic Pagination** for large datasets
  - 🏷️ **Dynamic Custom Fields** with live search
  - 🌍 **Timezone Management** with location awareness
  - 📧 **Email/Phone Validation** with format checking
  - 🔗 **Location-aware Operations** with automatic context injection
  - 🎯 **Flexible Tag Processing** (comma-separated or array formats)
  - 📁 **File Upload Support** with metadata management
  - ⚡ **Comprehensive Error Handling** with detailed responses
  - 🔍 **Advanced Search Capabilities** across multiple resources

  ## Installation

  Simply go to N8N Settings > Community Nodes > Install > `n8n-nodes-highlevelv2` and you're off to the races!

  ## Resources & Operations

  This node provides access to the following HighLevel resources and operations:

  ### 🔐 Authentication
  - **Get Location Access Token**: Retrieve location-specific access tokens for API operations

  ### 📝 Blog Management
  - **Create**: Create new blog posts
  - **Update**: Modify existing blog posts
  - **Get**: Retrieve specific blog posts
  - **Get All**: List all blog posts
  - **Delete**: Remove blog posts

  ### 🏢 Business Management
  - **Create**: Create new businesses with complete contact information
  - **Get**: Retrieve specific business details and contact information
  - **Get Many**: List multiple businesses with filtering and search capabilities
  - **Update**: Modify existing business information including contact details
  - **Delete**: Remove businesses from the system

  ### 📅 Calendar Management
  - **Create**: Create new calendars
  - **Get**: Retrieve specific calendar details
  - **Get Many**: List multiple calendars with filtering options
  - **Update**: Modify existing calendar information
  - **Delete**: Remove calendars from the system
  - **Get Free Slots**: Retrieve available calendar slots for scheduling

  ### 📅 Calendar Event Management  
  - **Create Appointment**: Schedule new appointments with full contact and calendar integration
  - **Update Appointment**: Modify existing appointment details, times, and status
  - **Get Appointment**: Retrieve specific appointment details by ID
  - **Create Block Slot**: Block calendar time slots to prevent bookings
  - **Update Block Slot**: Modify existing blocked time slots
  - **Get Blocked Slots**: List all blocked time slots with filtering options
  - **Delete Event**: Remove appointments or calendar events from the system

  ### 📅 Calendar Group Management
  - **Create**: Create new calendar groups to organize multiple calendars
  - **Get Many**: List all calendar groups with filtering and search capabilities
  - **Update**: Modify existing calendar group settings and assignments
  - **Delete**: Remove calendar groups from the system
  - **Disable**: Temporarily disable calendar groups
  - **Validate Slug**: Check if a calendar group slug is available for use

  ### 🔧 Calendar Resource Management
  - **Create**: Create new calendar resources like rooms, equipment, or other bookable items
  - **Get**: Retrieve specific calendar resource details by ID
  - **Get Many**: List all calendar resources with pagination and filtering
  - **Update**: Modify existing calendar resource information and settings
  - **Delete**: Remove calendar resources from the system

  ### 👥 Contact Management
  - **Create or Update**: Create new contacts or update existing ones (upsert operation)
  - **Get**: Retrieve specific contact details
  - **Get Many**: List multiple contacts with filtering options
  - **Update**: Modify existing contact information
  - **Delete**: Remove contacts from the system

  ### 💬 Conversation Management
  - **Create Conversation**: Start new conversations
  - **Get Conversation**: Retrieve conversation details
  - **Update Conversation**: Modify conversation properties
  - **Delete Conversation**: Remove conversations
  - **Send Message**: Send messages within conversations
  - **Get Messages**: Retrieve conversation messages
  - **Add Inbound Message**: Process incoming messages
  - **Add External Outbound Call**: Log external calls
  - **Cancel Scheduled Email/Message**: Cancel pending communications
  - **Upload File Attachment**: Add files to conversations
  - **Get Email/Recording/Transcription**: Retrieve communication assets
  - **Download Transcription**: Download call transcriptions
  - **Update Message Status**: Modify message delivery status
  - **Search Conversations**: Find conversations using filters

  ### 🎫 Coupon Management
  - **Create**: Create new discount coupons
  - **Get**: Retrieve specific coupon details
  - **Get Many**: List multiple coupons with filtering options
  - **Update**: Modify existing coupon information
  - **Delete**: Remove coupons from the system

  ### 🏷️ Custom Fields Management
  - **Create**: Add new custom fields
  - **Update**: Modify existing custom fields
  - **Get**: Retrieve custom field details
  - **Delete**: Remove custom fields
  - **Create Folder**: Organize custom fields in folders
  - **Get Folder**: Retrieve folder information
  - **Update Folder**: Modify folder properties
  - **Delete Folder**: Remove custom field folders

  ### 🗂️ Custom Objects Management
  - **Create Custom Object**: Define new custom object schemas
  - **Get Object Schema**: Retrieve custom object schema details
  - **Get All Objects**: List all custom objects for a location
  - **Update Object Schema**: Modify existing custom object schemas
  - **Create Record**: Add new records to custom objects
  - **Get Record**: Retrieve specific custom object records
  - **Update Record**: Modify existing custom object records
  - **Delete Record**: Remove records from custom objects
  - **Search Records**: Find records using filters and queries

  ### 📊 Custom Values Management
  - **Create**: Add new custom values with various data types
  - **Get**: Retrieve specific custom value details
  - **Get All**: List all custom values with filtering options
  - **Update**: Modify existing custom value properties
  - **Delete**: Remove custom values from the system

  ### 📧 Email Management
  - **Create Template**: Design email templates
  - **Update Template**: Modify existing templates
  - **Delete Template**: Remove email templates
  - **Get Templates**: List available templates
  - **Get Campaigns**: Retrieve email campaign data

  ### 📋 Forms Management
  - **Get Forms**: List available forms
  - **Get Form Submissions**: Retrieve form responses
  - **Upload File**: Handle form file uploads

  ### 🕳️ Funnel Management
  - **Get All Funnels**: List all funnels with filtering and search
  - **Get Funnel Pages**: Retrieve all pages within a specific funnel
  - **Get Page Count**: Get detailed count statistics for funnel pages

  ### 📁 Media Management
  - **Get List of Files**: Retrieve all files and folders in the media library
  - **Upload File**: Upload files to the media library with metadata
  - **Delete File or Folder**: Remove files or folders from the media library

  ### 📝 Notes Management
  - **Create**: Add new notes to contacts
  - **Get**: Retrieve specific note details
  - **Get All**: List all notes for a contact with pagination
  - **Update**: Modify existing note content
  - **Delete**: Remove notes from contacts

  ### 📝 Appointment Notes Management
  - **Create**: Add new appointment-specific notes to track appointment details
  - **Get Many**: List all appointment notes with filtering by contact, user, or appointment
  - **Update**: Modify existing appointment note content
  - **Delete**: Remove appointment notes from the system

  ### 🔗 Object Associations Management
  - **Create Association**: Define relationships between different object types
  - **Get Association by ID**: Retrieve association details by ID
  - **Get Association by Object Keys**: Find associations between specific objects
  - **Get Association Key by Key Name**: Retrieve association keys by name
  - **Update Association**: Modify existing association definitions
  - **Delete Association**: Remove association definitions
  - **Get All Associations**: List all associations for a location
  - **Create Relation**: Establish relations between specific object instances
  - **Get All Relations by Record ID**: Retrieve relations for specific records
  - **Delete Relation**: Remove specific object relations

  ### 🎯 Opportunity Management
  - **Create**: Add new opportunities
  - **Update**: Modify opportunity details
  - **Get**: Retrieve specific opportunities
  - **Get All**: List multiple opportunities

  ### 🛍️ Product Management
  - **Create**: Add new products to inventory
  - **Get**: Retrieve specific product details
  - **Get Many**: List multiple products with filtering options
  - **Update**: Modify existing product information
  - **Delete**: Remove products from inventory
  - **Bulk Update**: Update multiple products at once

  ### 🔀 Redirect Management
  - **Create**: Create new URL redirects (301/302)
  - **Get All**: List all redirects with filtering options
  - **Update**: Modify existing redirect rules
  - **Delete**: Remove redirects from the system

  ### 🏢 SaaS Management
  - **Enable SaaS**: Activate SaaS features for locations
  - **Disable SaaS**: Deactivate SaaS features
  - **Bulk Enable SaaS**: Enable SaaS for multiple locations
  - **Get SaaS Locations**: List SaaS-enabled locations
  - **Get SaaS Plan**: Retrieve plan information
  - **Get Agency Plans**: List available agency plans
  - **Get Location Subscription Details**: Retrieve subscription info
  - **Get Locations by Stripe ID**: Find locations by payment ID
  - **Update Subscription**: Modify subscription settings
  - **Update Rebilling**: Adjust billing configurations
  - **Pause Location**: Temporarily suspend location access

  ### 📱 Social Planner Management
  - **Create Post**: Create social media posts
  - **Schedule Post**: Schedule posts for later publication
  - **Get Posts**: Retrieve social media posts
  - **Get Post**: Get a specific social media post
  - **Update Post**: Update existing social media posts
  - **Delete Post**: Delete social media posts
  - **Get Social Accounts**: List connected social accounts
  - **Get Analytics**: Retrieve social media analytics and performance data

  ### 🏢 Sub-Account Management
  - **Create Sub-Account**: Add new sub-accounts
  - **Get Sub-Accounts**: List sub-accounts
  - **Create User**: Add users to sub-accounts
  - **Get Users**: List sub-account users

  ### 📊 Survey Management
  - **Get Surveys**: List available surveys
  - **Get Survey Submissions**: Retrieve survey responses

  ### ✅ Task Management
  - **Create**: Add new tasks to the system
  - **Get**: Retrieve specific task details
  - **Get Many**: List tasks for a contact
  - **Update**: Modify existing tasks
  - **Delete**: Remove tasks
  - **Search**: Search tasks with advanced filters

  ### 🏷️ Tags Management
  - **Add Tags**: Add multiple tags to contacts
  - **Remove Tags**: Remove specific tags from contacts

  ### 👤 User Management
  - **Create User**: Add new users
  - **Get User**: Retrieve user details
  - **Get Users by Location**: List users for specific locations
  - **Update User**: Modify user information
  - **Delete User**: Remove users from the system

  ## Credentials

  This node uses OAuth2 authentication with the HighLevel API. You'll need to:

  1. **Create a HighLevel App**: Register your application in the HighLevel Developer Portal
  2. **Get OAuth2 Credentials**: Obtain your Client ID and Client Secret
  3. **Configure Authentication**: Set up OAuth2 credentials in n8n with:
     - Client ID
     - Client Secret
     - Authorization URL: `https://marketplace.leadconnectorhq.com/oauth/chooselocation`
     - Access Token URL: `https://services.leadconnectorhq.com/oauth/token`
     - Scope: As required by your use case

  The node automatically handles location-specific token management and API versioning.

  ## Compatibility

  - **Minimum n8n version**: 1.0.0
  - **Node.js version**: >=20.15
  - **API Version**: HighLevel API v2 (2021-07-28)

  ## Features

  ### 🔧 Core Functionality
  - **30 Resource Types**: Complete coverage of HighLevel API v2
  - **100+ Operations**: Full CRUD operations across all resources
  - **Advanced Search**: Powerful filtering and search capabilities
  - **Bulk Operations**: Efficient handling of multiple records
  - **Real-time Data**: Live integration with HighLevel platform

  ### 🚀 Advanced Automation
  - **Automatic Pagination**: Seamlessly handles large datasets
  - **Location-aware Operations**: Automatic location context injection
  - **Dynamic Field Mapping**: Smart custom field integration with live search
  - **Timezone Management**: Automatic timezone handling and conversion
  - **Email/Phone Validation**: Built-in format validation and verification
  - **Tag Processing**: Flexible tag management (comma-separated or array formats)
  - **File Upload Support**: Handle attachments in conversations, forms, and media library
  - **Error Handling**: Comprehensive error handling with detailed reporting

  ### 📊 Data Management
  - **Custom Objects & Fields**: Create and manage custom data structures
  - **Object Associations**: Define relationships between different data types
  - **Custom Values**: Typed custom values with categories and organization
  - **Media Library**: Complete file and folder management
  - **Notes & Tags**: Rich contact annotation and categorization

  ### 🎯 Marketing & Sales
  - **Contact Management**: Complete CRM with custom fields and validation
  - **Conversation Handling**: SMS, email, calls with file attachments
  - **Social Media Planning**: Multi-platform post creation and scheduling
  - **Email Campaigns**: Template management and campaign tracking
  - **Funnel Analytics**: Page performance and conversion tracking
  - **Product Catalog**: Inventory management with bulk operations
  - **Coupon System**: Discount management with usage tracking

  ### 🏢 Business Operations
  - **Sub-Account Management**: Multi-location business support
  - **User Administration**: Role-based access and user management
  - **SaaS Integration**: Subscription and billing management
  - **Task Management**: Project tracking with advanced search
  - **Survey Collection**: Form submission and response handling
  - **Redirect Management**: URL management and traffic routing

  ### 🔒 Security & Authentication
  - **OAuth2 Integration**: Secure token-based authentication
  - **Location Scoping**: Automatic location context for all operations
  - **API Versioning**: Consistent API version management
  - **Rate Limit Handling**: Intelligent request throttling

  ## Usage Examples

  ### Create or Update Contact
  ```javascript
  // Basic contact creation with email validation
  {
    "resource": "contact",
    "operation": "create",
    "email": "john@example.com",
    "firstName": "John",
    "lastName": "Doe",
    "phone": "+1234567890",
    "tags": "prospect,website-lead"
  }
  ```

  ### Create Calendar Resource
  ```javascript
  // Create a calendar resource (room, equipment, etc.)
  {
    "resource": "calendarResource",
    "operation": "create",
    "name": "Conference Room A",
    "additionalFields": {
      "description": "Large conference room with projector and video conferencing",
      "type": "room",
      "quantity": 1,
      "isActive": true
    }
  }
  ```

  ### Create Appointment
  ```javascript
  // Create a new appointment
  {
    "resource": "calendarEvent",
    "operation": "createAppointment",
    "calendarId": "cal_123456789",
    "contactId": "contact_123456789", 
    "startTime": "2023-12-01T10:00:00.000Z",
    "endTime": "2023-12-01T11:00:00.000Z",
    "additionalFields": {
      "title": "Sales Consultation",
      "appointmentStatus": "confirmed",
      "assignedUserId": "user_123456789",
      "address": "123 Main St, City, State 12345",
      "notes": "Initial sales consultation meeting"
    }
  }
  ```

  ### Social Media Management
  ```javascript
  // Create a social media post
  {
    "resource": "socialPlanner",
    "operation": "createPost",
    "locationId": "loc_123",
    "content": "Check out our latest offer! #sale #discount",
    "socialAccounts": ["facebook", "instagram"],
    "additionalFields": {
      "mediaUrls": "https://example.com/image1.jpg,https://example.com/image2.jpg",
      "hashtags": "sale,discount,promotion",
      "postType": "post",
      "postImmediately": true
    }
  }
  ```

  ### Create Product
  ```javascript
  // Create a new product
  {
    "resource": "product",
    "operation": "create",
    "name": "Premium T-Shirt",
    "price": 29.99,
    "description": "High-quality cotton t-shirt",
    "category": "Clothing",
    "sku": "TSHIRT-001",
    "stockQuantity": 100,
    "status": "active",
    "trackInventory": true,
    "tags": "clothing,premium,cotton",
    "weight": 0.3,
    "taxRate": 8.5
  }
  ```

  ### Notes Management
  ```javascript
  // Create a note for a contact
  {
    "resource": "notes",
    "operation": "create",
    "contactId": "contact_123",
    "body": "Follow up with customer regarding their inquiry about pricing.",
    "additionalFields": {
      "userId": "user_456"
    }
  }
  ```

  ### Tags Management
  ```javascript
  // Add tags to a contact
  {
    "resource": "tags",
    "operation": "addTags",
    "contactId": "contact_123",
    "tags": "vip,priority-follow-up,interested-in-premium",
    "additionalFields": {
      "userId": "user_456",
      "source": "workflow"
    }
  }
  ```

  ## Testing

  The node includes comprehensive test coverage for all API operations, data validation, error handling, authentication flows, and pagination functionality.

  Run tests with:
  ```bash
  npm test
  ```

  ## Development

  ### Project Structure
  ```
  nodes/HighLevelV2/
  ├── __schema__/           # JSON schemas for all operations
  ├── v2/
  │   ├── description/      # Operation descriptions
  │   ├── test/            # Test files
  │   ├── GenericFunctions.ts
  │   └── HighLevelV2.node.ts
  ├── HighLevel.node.json
  └── highLevel.svg
  ```

  ### Building
  ```bash
  npm run build
  ```

  ### Development Mode
  ```bash
  npm run dev
  ```

  ### Linting
  ```bash
  npm run lint
  npm run lintfix
  ```

  ## Resources

  - [n8n Community Nodes Documentation](https://docs.n8n.io/integrations/#community-nodes)
  - [HighLevel API Documentation](https://highlevel.stoplight.io/docs/integrations)
  - [HighLevel Developer Portal](https://marketplace.leadconnectorhq.com/)
  - [n8n Workflow Automation](https://n8n.io/)
  - [Project Repository](https://github.com/marioaldayuz/n8n-highlevel)

  ## Contributing

  This is an open-source project. Contributions are welcome! Please:

  1. Fork the repository at [https://github.com/marioaldayuz/n8n-highlevel](https://github.com/marioaldayuz/n8n-highlevel)
  2. Create a feature branch
  3. Add tests for new functionality
  4. Ensure all tests pass
  5. Submit a pull request

  ## License

  MIT License - See [LICENSE.md](LICENSE.md) for details.

ai_documentation_summary:
  {"purpose":"Provides comprehensive integration with the HighLevel API v2, enabling automation for CRM, marketing, calendar management, and business operations through 30 resources and 100+ operations.","capabilities":["Full CRUD operations across 30 resources","Advanced search and filtering with pagination","Bulk operations for efficiency","File management (upload, organize, delete)","Relationship management via object associations","Marketing automation (emails, social posts, funnels)","E-commerce features (products, coupons, redirects)","Business management (sub-accounts, users, SaaS)","CRM features (contacts, conversations, notes, tags)","Analytics and reporting (social analytics, funnel metrics)"],"authentication":"API key required","commonUseCases":["Automating lead capture and contact management","Scheduling appointments and managing calendars","Running marketing campaigns via email and social media","Managing e-commerce products and coupons","Tracking opportunities and business metrics"],"limitations":["Node is currently in BETA status","Requires a HighLevel account and API access"],"relatedNodes":[]}


node_type: n8n-nodes-oxsr-technical-utils.oxsrtechnicalutils
package_name: n8n-nodes-oxsr-technical-utils
display_name: oxsrtechnicalutils
description: OXSR Technical Utils: complete WordPress monitoring and management via OXSR Monitor plugin
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-16 09:43:37
author_name: oxsr
npm_package_name: n8n-nodes-oxsr-technical-utils
npm_version: 4.2.26
community_fetched_at: 2026-04-16T09:43:37.389Z
npm_readme: ERROR: No README data found!
ai_summary_generated_at: 2026-05-02 08:57:17
ai_documentation_summary:
  {"purpose":"Provides technical utilities for monitoring and managing WordPress sites through the OXSR Monitor plugin.","capabilities":["WordPress site monitoring","Site management operations","Integration with OXSR Monitor plugin"],"authentication":"None","commonUseCases":["Automated WordPress health checks","Server resource monitoring","Site performance tracking"],"limitations":["Requires OXSR Monitor plugin installation on target WordPress sites","Limited to WordPress environments only"],"relatedNodes":[]}


node_type: @formbricks/n8n-nodes-formbricks.formbricks
package_name: @formbricks/n8n-nodes-formbricks
display_name: formbricks
description: A n8n node to connect Formbricks and send survey data to hundreds of other apps.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-28 21:47:41
author_name: matthiasnannt
author_github_url: git+https://github.com/formbricks/formbricks.git
npm_package_name: @formbricks/n8n-nodes-formbricks
npm_version: 1.0.2
community_fetched_at: 2026-04-28T21:47:41.640Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-formbricks

  This is an n8n community node. It lets you use Formbricks in your n8n workflows.

  Formbricks is an open-source experience management solution that lets you understand what customers think & feel about your product by running highly targeted surveys inside your product.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials) <!-- delete if no auth needed -->  
  [Compatibility](#compatibility)  
  [Usage](#usage) <!-- delete if not using this section -->  
  [Resources](#resources)

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Operations

  Run workflows on new responses you receive for your surveys.

  ## Credentials

  You can use this integration in Formbricks Cloud as well as self-hosted instances of Formbricks. You only need a Formbricks API Key for this. Please check out the [Formbricks Docs]() for more information.

  ## Compatibility

  This package was developed & tested with n8n > 1.4.0.

  ## Usage

  Please check out the [Formbricks Docs](https://formbricks.com/docs/api/api-key-setup) for more information on how to use the integration.

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Formbricks Docs](https://formbricks.com/docs/integrations/n8n)

ai_documentation_summary:
  {"purpose":"Connects Formbricks to n8n workflows to trigger actions based on new survey responses and send data to other applications.","capabilities":["Trigger workflows on new survey responses","Send survey data to hundreds of connected apps"],"authentication":"API key required","commonUseCases":["Automate customer feedback collection","Integrate survey responses into CRM or analytics tools"],"limitations":[],"relatedNodes":[]}


node_type: n8n-nodes-hyperspacedb.hyperspacedb
package_name: n8n-nodes-hyperspacedb
display_name: hyperspacedb
description: HyperspaceDB integration for n8n (Vector Store, Embeddings, API)
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-28 21:47:41
author_name: yarlabs
author_github_url: git+https://github.com/YARlabs/hyperspace-db.git
npm_package_name: n8n-nodes-hyperspacedb
npm_version: 3.0.15
community_fetched_at: 2026-04-28T21:47:41.643Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-hyperspacedb

  This is an n8n community node for [HyperspaceDB](https://github.com/yarlabs/hyperspace-db) — a high-performance, multi-geometry vector database designed for advanced Agentic AI and cognitive modeling.
  # HyperspaceDB n8n Integration

  The world's first Hyperbolic Vector Database integration for n8n. Build advanced Spatial AI workflows with native Poincaré and Lorentz geometry support.

  ## Features

  - **Hyperbolic & Euclidean Spaces**: Support for Lorentz, Poincaré, Cosine, and L2 metrics.
  - **Standalone Architecture**: No external LangChain library conflicts. Logic is internalized for stability.
  - **Auto-Syncing**: Automatically detects collection dimensions and metrics - no more manual configuration errors.
  - **Universal SDK**: Powered by the official `hyperspace-sdk-ts`.
  - **RAG Ready**: Seamlessly integrates with n8n AI Agent and Chains.

  ## Nodes

  ### 1. HyperspaceDB Vector Store
  The primary node for document storage and similarity search.
  - **Dynamic Collection Selection**: Select your database from a dropdown list.
  - **Zero-Config Metadata**: Dimensions and geometry are fetched automatically from the server.

  ### 2. HyperspaceDB Embeddings
  Server-side vectorization node.
  - **Geometry Matching**: Automatically matches the space of your target collection.

  ### 3. HyperspaceDB (Standalone)
  Direct API access for management tasks:
  - Create/Delete Collections
  - Get Stats
  - Direct Vector/Text Insertion
  - Graph Traversals

  ## Installation

  Install via the n8n Community Nodes panel:
  `n8n-nodes-hyperspacedb`

  ## Credentials

  Requires `HyperspaceDB API` credentials:
  - **Host**: Your server address
  - **Port**: gRPC port (default 50051)
  - **API Key**: Your secure access key

  ---
  Built with ❤️ by the YARlabs.

  ## 🤝 SDK Integration
  This node works alongside the [hyperspace-sdk-ts](https://www.npmjs.com/package/hyperspace-sdk-ts). While the n8n node uses the REST API (port 50050), the SDK provides full gRPC (port 50051) support for high-throughput applications.

  ## 📜 License
  MIT

ai_documentation_summary:
  {"purpose":"Provides integration for HyperspaceDB, a high-performance hyperbolic vector database, enabling advanced spatial AI workflows, document storage, similarity search, and server-side embeddings within n8n.","capabilities":["Store and retrieve vectors using Lorentz, Poincaré, Cosine, and L2 metrics","Perform similarity search with hyperbolic and Euclidean spaces","Generate server-side embeddings with automatic geometry matching","Create, delete, and manage database collections","Execute direct vector and text insertion","Perform graph traversals","Auto-detect collection dimensions and metrics","Integrate with n8n AI Agent and Chains for RAG"],"authentication":"API key required (Host, Port, and API Key credentials)","commonUseCases":["Building RAG (Retrieval-Augmented Generation) systems with hyperbolic geometry","Advanced spatial AI and cognitive modeling workflows","Agentic AI applications requiring high-performance vector storage","Document similarity search and classification"],"limitations":["n8n node uses REST API (port 50050) while full gRPC support requires the separate hyperspace-sdk-ts library","Requires manual setup of HyperspaceDB server (Host, Port, API Key)"],"relatedNodes":[]}


node_type: n8n-nodes-fachkraftfreund.fachkraftfreund
package_name: n8n-nodes-fachkraftfreund
display_name: fachkraftfreund
description: n8n community nodes for Fachkraftfreund - WaliChat and Ringover integrations
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-04-28 21:47:41
author_name: immanuelbecker
npm_package_name: n8n-nodes-fachkraftfreund
npm_version: 0.7.11
community_fetched_at: 2026-04-28T21:47:41.644Z
npm_readme: ERROR: No README data found!
ai_summary_generated_at: 2026-05-02 08:57:17
ai_documentation_summary:
  {"purpose":"Provides n8n community node integrations for the Fachkraftfreund platform, specifically supporting connections to WaliChat and Ringover services.","capabilities":["WaliChat integration","Ringover integration"],"authentication":"None","commonUseCases":["Automating communication workflows with WaliChat","Integrating Ringover telephony features into n8n workflows"],"limitations":[],"relatedNodes":[]}


node_type: @flarelight/n8n-nodes-flarelight.flarelight
package_name: @flarelight/n8n-nodes-flarelight
display_name: Flarelight
description: Interact with Flarelight API
category: Community
development_style: declarative
version: 1
credentials_required: []
outputs:
  [
  "main"
  ]

updated_at: 2026-05-02 08:43:00
author_name: goranstjepanovic
author_github_url: https://github.com/flarelight-io/n8n-nodes-flarelight.git
npm_package_name: @flarelight/n8n-nodes-flarelight
npm_version: 1.0.3
community_fetched_at: 2026-05-02T08:43:00.435Z
ai_summary_generated_at: 2026-03-25 22:51:43
properties_schema:
  [
    {
      "name": "resource",
      "type": "options",
      "default": "import",
      "options": [
        {
          "name": "Automation",
          "value": "automation"
        },
        {
          "name": "Import",
          "value": "import"
        },
        {
          "name": "Preparation",
          "value": "preparation"
        },
        {
          "name": "Report",
          "value": "report"
        }
      ],
      "displayName": "Resource",
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "execute",
      "options": [
        {
          "name": "Execute Automation",
          "value": "execute",
          "action": "Execute automation",
          "routing": {
            "request": {
              "url": "=/Automation/{{$parameter[\"automationId\"]}}/Execute",
              "method": "POST"
            }
          },
          "description": "Execute an automation by ID"
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "automation"
          ]
        }
      },
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "getAll",
      "options": [
        {
          "name": "Get Many",
          "value": "getAll",
          "action": "Get many imports",
          "routing": {
            "request": {
              "url": "/Import/All",
              "method": "GET"
            }
          },
          "description": "Get many available imports"
        },
        {
          "name": "Get Import Data",
          "value": "getData",
          "action": "Get import data",
          "routing": {
            "request": {
              "url": "=/Import/{{$parameter[\"importId\"]}}/Data?start={{ $parameter.start }}&count={{ $parameter.count }}",
              "method": "GET"
            }
          },
          "description": "Get data from a specific import"
        },
        {
          "name": "Create Import",
          "value": "create",
          "action": "Create import",
          "routing": {
            "request": {
              "url": "/Import/Data",
              "body": "={{ JSON.parse($parameter.importRequest) }}",
              "method": "POST"
            }
          },
          "description": "Create a new data import"
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "import"
          ]
        }
      },
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "getAll",
      "options": [
        {
          "name": "Get Many",
          "value": "getAll",
          "action": "Get many preparations",
          "routing": {
            "request": {
              "url": "/Preparation/All",
              "method": "GET"
            }
          },
          "description": "Get many available data preparations"
        },
        {
          "name": "Get Preparation Data",
          "value": "getData",
          "action": "Get preparation data",
          "routing": {
            "request": {
              "url": "=/Preparation/{{$parameter[\"preparationId\"]}}/Data?start={{ $parameter.start }}&count={{ $parameter.count }}",
              "method": "GET"
            }
          },
          "description": "Get data from a specific preparation"
        },
        {
          "name": "Execute Preparation",
          "value": "execute",
          "action": "Execute preparation",
          "routing": {
            "request": {
              "url": "=/Preparation/{{$parameter[\"preparationId\"]}}/Execute",
              "method": "POST"
            }
          },
          "description": "Execute a data preparation by ID"
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "preparation"
          ]
        }
      },
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "getAll",
      "options": [
        {
          "name": "Get Many",
          "value": "getAll",
          "action": "Get many reports",
          "routing": {
            "request": {
              "url": "/Report/All",
              "method": "GET"
            }
          },
          "description": "Get many available reports"
        },
        {
          "name": "Get Report",
          "value": "get",
          "action": "Get report",
          "routing": {
            "request": {
              "url": "=/Report/{{$parameter[\"reportId\"]}}",
              "method": "GET"
            }
          },
          "description": "Get a specific report by ID"
        },
        {
          "name": "Generate Report",
          "value": "generate",
          "action": "Generate report",
          "routing": {
            "request": {
              "url": "=/Report/{{$parameter[\"reportId\"]}}/Generate",
              "method": "POST"
            }
          },
          "description": "Generate a report by ID"
        },
        {
          "name": "Get Chart Data",
          "value": "getChartData",
          "action": "Get chart data",
          "routing": {
            "request": {
              "url": "/Report/ChartData",
              "body": "={{ JSON.parse($parameter.chartDataRequest) }}",
              "method": "POST"
            }
          },
          "description": "Get chart data for reports"
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "report"
          ]
        }
      },
      "noDataExpression": true
    }
  ]

operations:
  [
    {
      "name": "Execute Automation",
      "value": "execute",
      "action": "Execute automation",
      "routing": {
        "request": {
          "url": "=/Automation/{{$parameter[\"automationId\"]}}/Execute",
          "method": "POST"
        }
      },
      "description": "Execute an automation by ID",
      "resource": "automation"
    },
    {
      "name": "Get Many",
      "value": "getAll",
      "action": "Get many imports",
      "routing": {
        "request": {
          "url": "/Import/All",
          "method": "GET"
        }
      },
      "description": "Get many available imports",
      "resource": "import"
    },
    {
      "name": "Get Import Data",
      "value": "getData",
      "action": "Get import data",
      "routing": {
        "request": {
          "url": "=/Import/{{$parameter[\"importId\"]}}/Data?start={{ $parameter.start }}&count={{ $parameter.count }}",
          "method": "GET"
        }
      },
      "description": "Get data from a specific import",
      "resource": "import"
    },
    {
      "name": "Create Import",
      "value": "create",
      "action": "Create import",
      "routing": {
        "request": {
          "url": "/Import/Data",
          "body": "={{ JSON.parse($parameter.importRequest) }}",
          "method": "POST"
        }
      },
      "description": "Create a new data import",
      "resource": "import"
    },
    {
      "name": "Get Many",
      "value": "getAll",
      "action": "Get many preparations",
      "routing": {
        "request": {
          "url": "/Preparation/All",
          "method": "GET"
        }
      },
      "description": "Get many available data preparations",
      "resource": "preparation"
    },
    {
      "name": "Get Preparation Data",
      "value": "getData",
      "action": "Get preparation data",
      "routing": {
        "request": {
          "url": "=/Preparation/{{$parameter[\"preparationId\"]}}/Data?start={{ $parameter.start }}&count={{ $parameter.count }}",
          "method": "GET"
        }
      },
      "description": "Get data from a specific preparation",
      "resource": "preparation"
    },
    {
      "name": "Execute Preparation",
      "value": "execute",
      "action": "Execute preparation",
      "routing": {
        "request": {
          "url": "=/Preparation/{{$parameter[\"preparationId\"]}}/Execute",
          "method": "POST"
        }
      },
      "description": "Execute a data preparation by ID",
      "resource": "preparation"
    },
    {
      "name": "Get Many",
      "value": "getAll",
      "action": "Get many reports",
      "routing": {
        "request": {
          "url": "/Report/All",
          "method": "GET"
        }
      },
      "description": "Get many available reports",
      "resource": "report"
    },
    {
      "name": "Get Report",
      "value": "get",
      "action": "Get report",
      "routing": {
        "request": {
          "url": "=/Report/{{$parameter[\"reportId\"]}}",
          "method": "GET"
        }
      },
      "description": "Get a specific report by ID",
      "resource": "report"
    },
    {
      "name": "Generate Report",
      "value": "generate",
      "action": "Generate report",
      "routing": {
        "request": {
          "url": "=/Report/{{$parameter[\"reportId\"]}}/Generate",
          "method": "POST"
        }
      },
      "description": "Generate a report by ID",
      "resource": "report"
    },
    {
      "name": "Get Chart Data",
      "value": "getChartData",
      "action": "Get chart data",
      "routing": {
        "request": {
          "url": "/Report/ChartData",
          "body": "={{ JSON.parse($parameter.chartDataRequest) }}",
          "method": "POST"
        }
      },
      "description": "Get chart data for reports",
      "resource": "report"
    }
  ]

npm_readme:
  # n8n-nodes-flarelight

  This is an n8n community node that lets you use [Flarelight](https://www.flarelight.io) APIs in your n8n workflows.

  Flarelight is a modern no-code Business Intelligence (BI) platform designed for micro-businesses, professionals, and small teams that enables users to import, prepare, analyze, automate, and report on data in a streamlined, easy-to-use workflow. The platform combines simplicity, automation, and AI-assisted insights, giving smaller organizations access to capabilities traditionally reserved for enterprise BI tools.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  
  [Version history](#version-history)

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  1. Go to **Settings > Community Nodes**.
  2. Select **Install**.
  3. Enter `n8n-nodes-flarelight` in **Enter npm package name**.
  4. Agree to the [risks](https://docs.n8n.io/integrations/community-nodes/risks/) of using community nodes: select **I understand the risks of installing unverified code from a public source**.
  5. Select **Install**.

  After installing the node, you can use it like any other node. n8n displays the node in search results in the **Nodes** panel.

  ## Operations

  The node mirrors the primary resource groups exposed by the Flarelight API so you can:

  - Run automations to orchestrate Flarelight workflows.
  - Manage imports, including creating new imports and retrieving their data.
  - Handle preparation pipelines to transform datasets before downstream use.
  - Generate and retrieve reports, including chart data extraction.

  For the full list of endpoints and payloads, refer to the [Flarelight API specification](https://integration.eu1.flarelight.cloud/swagger/index.html).

  ## Credentials

  Create a Flarelight credential in n8n using the values supplied by your Flarelight workspace:

  - `Subscription ID` (sent as `X-Subscription-Id`)
  - `Integration Key` (sent as `X-Api-Key`)
  - Optional custom API base URL (defaults to `https://integration.eu1.flarelight.cloud`)

  Store credentials in n8n and reference them from every Flarelight node instance.

  ## Compatibility

  Tested against n8n version **1.120.4**.

  ## Usage

  1. Install the community node and configure the Flarelight credential once per n8n instance.
  2. Add the **Flarelight** node to a workflow and pick a resource (`Automation`, `Import`, `Preparation`, or `Report`).
  3. Choose an operation, supply required IDs or payloads, and optionally enable pagination or JSON body inputs where available.
  4. Chain the Flarelight node with other n8n nodes to automate end-to-end BI and reporting workflows.

  Review `n8nNodeDocPortal.md` in this repository for deeper, operation-by-operation guidance.

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Flarelight website](https://www.flarelight.io)
  - [Flarelight API documentation](https://docs.flarelight.cloud/docs/integration-api/)

  ## Version history

  | Version | Date       | Notes                    |
  |---------|------------|--------------------------|
  | 1.0.3   | 2025-11-27 | POST Requests fix |
  | 1.0.2   | 2025-11-25 | Fixed gulp file copy which corrupted the icon  |
  | 1.0.1   | 2025-11-25 | Clean up template files  |
  | 1.0.0   | 2025-11-25 | Initial community release |

ai_documentation_summary:
  {"purpose":"This n8n community node enables workflow automation by interacting with the Flarelight Business Intelligence (BI) platform API to manage data imports, preparation pipelines, automations, and reporting.","capabilities":["Run Flarelight automations","Create and retrieve data imports","Manage data preparation pipelines","Generate and retrieve reports","Extract chart data from reports","Support pagination for API responses"],"authentication":"API Key required (Integration Key sent as X-Api-Key header) and Subscription ID (sent as X-Subscription-Id header)","commonUseCases":["Automating data import and transformation workflows","Generating automated BI reports for micro-businesses","Orchestrating data analysis pipelines within n8n","Extracting visual data from Flarelight charts"],"limitations":["Community node (unverified code from public source)","Requires valid Flarelight workspace credentials","Tested only against n8n version 1.120.4"],"relatedNodes":["n8n HTTP Request node","n8n Code node","n8n Function node"]}


node_type: @rightech/n8n-nodes-ric.rightechIotCloud
package_name: @rightech/n8n-nodes-ric
display_name: Rightech IoT Cloud
description: Interact with the Rightech IoT Cloud API
category: Community
development_style: declarative
version: 1
credentials_required: []
outputs:
  [
  "main"
  ]

updated_at: 2026-05-02 08:43:01
author_name: prohazko
author_github_url: https://github.com/Rightech/n8n-nodes-ric.git
npm_package_name: @rightech/n8n-nodes-ric
npm_version: 0.0.3
community_fetched_at: 2026-05-02T08:43:01.536Z
ai_summary_generated_at: 2026-05-02 08:57:17
properties_schema:
  [
    {
      "name": "resource",
      "type": "options",
      "default": "object",
      "options": [
        {
          "name": "Object",
          "value": "object",
          "description": "Objects bound to your IoT devices"
        },
        {
          "name": "Scenario",
          "value": "scenario",
          "description": "Automation scenarios"
        }
      ],
      "displayName": "Resource",
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "start",
      "options": [
        {
          "name": "Start Scenario",
          "value": "start",
          "action": "Start scenario on an object",
          "routing": {
            "request": {
              "url": "=/objects/{{$parameter.objectId}}/automatons/{{$parameter.scenarioId}}/start",
              "method": "POST"
            }
          },
          "description": "Starts a new scenario execution on the object. More at https://rightech.io/en/developers/http/logic#execute-start."
        },
        {
          "name": "Stop Scenario",
          "value": "stop",
          "action": "Stop scenario on an object",
          "routing": {
            "request": {
              "url": "=/objects/{{$parameter.objectId}}/automatons/{{$parameter.scenarioId}}/stop",
              "method": "POST"
            }
          },
          "description": "Stops a running scenario execution on an object. More at https://rightech.io/en/developers/http/logic#execute-stop."
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "scenario"
          ]
        }
      },
      "noDataExpression": true
    },
    {
      "name": "operation",
      "type": "options",
      "default": "get",
      "options": [
        {
          "name": "Get",
          "value": "get",
          "action": "Get object data and state",
          "routing": {
            "request": {
              "url": "=/objects/{{$parameter.objectId}}",
              "method": "GET"
            }
          },
          "description": "Reads an entire object configuration and recorded state params. More at https://rightech.io/en/developers/http/objects#get-one."
        },
        {
          "name": "Send Command",
          "value": "sendCommand",
          "action": "Send command to the object",
          "routing": {
            "request": {
              "url": "=/objects/{{$parameter.objectId}}/commands/{{$parameter.commandId}}",
              "body": "={{$parameter.commandAuxiliaryData}}",
              "method": "POST"
            }
          },
          "description": "Sends any assigned command of the object to the device. More at https://rightech.io/en/developers/http/objects#send-command."
        }
      ],
      "displayName": "Operation",
      "displayOptions": {
        "show": {
          "resource": [
            "object"
          ]
        }
      },
      "noDataExpression": true
    }
  ]

operations:
  [
    {
      "name": "Start Scenario",
      "value": "start",
      "action": "Start scenario on an object",
      "routing": {
        "request": {
          "url": "=/objects/{{$parameter.objectId}}/automatons/{{$parameter.scenarioId}}/start",
          "method": "POST"
        }
      },
      "description": "Starts a new scenario execution on the object. More at https://rightech.io/en/developers/http/logic#execute-start.",
      "resource": "scenario"
    },
    {
      "name": "Stop Scenario",
      "value": "stop",
      "action": "Stop scenario on an object",
      "routing": {
        "request": {
          "url": "=/objects/{{$parameter.objectId}}/automatons/{{$parameter.scenarioId}}/stop",
          "method": "POST"
        }
      },
      "description": "Stops a running scenario execution on an object. More at https://rightech.io/en/developers/http/logic#execute-stop.",
      "resource": "scenario"
    },
    {
      "name": "Get",
      "value": "get",
      "action": "Get object data and state",
      "routing": {
        "request": {
          "url": "=/objects/{{$parameter.objectId}}",
          "method": "GET"
        }
      },
      "description": "Reads an entire object configuration and recorded state params. More at https://rightech.io/en/developers/http/objects#get-one.",
      "resource": "object"
    },
    {
      "name": "Send Command",
      "value": "sendCommand",
      "action": "Send command to the object",
      "routing": {
        "request": {
          "url": "=/objects/{{$parameter.objectId}}/commands/{{$parameter.commandId}}",
          "body": "={{$parameter.commandAuxiliaryData}}",
          "method": "POST"
        }
      },
      "description": "Sends any assigned command of the object to the device. More at https://rightech.io/en/developers/http/objects#send-command.",
      "resource": "object"
    }
  ]

npm_readme:
  # n8n Nodes - <img src="logo.svg" width="32" height="32" alt="Rightech IoT Core" align="center"> Rightech IoT Core

  This is an n8n community node that provides some basic integration with [<img src="logo.svg" width="16" height="16" alt="Rightech IoT Core" align="center"> Rightech IoT Core (aka RIC)](https://rightech.io).
  It lets you interact with your IoT devices and automations through the platform.

  The [<img src="logo.svg" width="16" height="16" alt="Rightech IoT Core" align="center"> RIC](https://rightech.io) platform is an intermediate link between devices (sensors, actuators, etc.) on the one hand, and applications on the other.
  Platform tools allow developers to create IoT solutions without extra code and developers reuse 90% of that solution to launch similar cases.
  RIC is independent of specific equipment and protocols. So, it is easy to combine different devices under one solution.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/sustainable-use-license/) workflow automation platform.

  ## Contents

  - [Installation](#installation)
  - [Operations](#operations)
  - [Credentials](#credentials)
  - [Compatibility](#compatibility)
  - [Resources](#resources)

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Operations

  Supported operations organized by resource type:

  ### Objects

  Objects represent your IoT devices

  - **Get configuration data and state**: Reads an entire object configuration and recorded state params.
  - **Get multiple objects**: Get configuration and state of multiple objects at once.
  - **Create object configuration**: Creates and configures IoT device connection object.
  - **Updates object configuration**: Updates object configuration parameters based on its model.
  - **Get object event log**: Get events related to the object.
  - **Send command to the object**: Sends any assigned command of the object to the device.
  - **Get object telemetry history**: Get historic telemetry packets for a specific time range.
  - **Send telemetry packet to the object**: Sends a customizable telemetry packet to the object, simulating device data.

  ### Models

  Models define your object configuration shapes

  - **Get model configuration**: Reads an entire model configuration tree.

  ### Scenarios

  Automation scenarios enable stateful automations with visual tools

  - **Start scenario on an object**: Starts a new scenario execution on the object.
  - **Stop scenario on an object**: Stops a running scenario execution on an object.

  ### Tables

  Data tables define arbitrary data shapes and store data

  - **Get data table declaration**: Returns table declaration with column properties.
  - **Get table row**: Returns a specific table row.
  - **Get table rows**: Returns table rows matching selected conditions.

  ### Events

  Event log stores all occurred events

  - **Get multiple events**: Get filtered events from the global event log.

  ### Users

  Users of the platform instance

  - **Get a user**: Loads platform user information
  - **Get multiple users**: Loads multiple platform users at once
  - **Create a user**: Creates a new platform user
  - **Update a user**: Updates an existing platform user

  ### Tasks

  Maintenance tasks assignable to platform users. Tasks can have different kinds, statuses, and properties defined by kinds.
  Tasks expose temporary access to object commands for users in the related service app to enable maintenance scenarios.

  - **Get a task**: Loads task information
  - **Get multiple tasks**: Loads multiple tasks at once
  - **Create a task**: Creates a new task
  - **Update a task**: Updates task parameters

  ### Report builds

  Build and load reports designed on the platform.

  - **Get a report build**: Loads report build status
  - **Get multiple report builds**: Loads multiple builds at once
  - **Create a new report build**: You can order to build a previously designed report, which takes some time to prepare data for you
  - **Cancel a report build**: Sometimes you may realize that your report build order was too large or simply a mistake
  - **Export a report build**: When report is ready you can export the built data in various formats, like tables or JSON

  ## Credentials

  This node supports API Bearer auth credentials using [`rightechIotCoreApi`](credentials/RightechIotCoreApi.credentials.ts) credential.
  By default, credentials point to the public development and demo server at [`dev.rightech.io`](https://dev.rightech.io).
  You can change server to point at your own instance of the platform.

  An API token is required to use the platform's HTTP API.
  It is used as a standard [Bearer authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Guides/Authentication#bearer) token in [Authorization header](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Authorization): `Authorization: Bearer <ACCESS_TOKEN>`.

  To create an API token, open the platform web UI and navigate to "Project settings" > "API tokens".
  Select an appropriate expiration time - otherwise the new token will be short-lived.
  Select the "Scopes" of the API you need for you automation.

  > [!TIP]
  > A "Scope" is a set of URI available in the API. Each resource and operation in this node requires a certain "Scope" to work.

  Click "Issue", and the newly created token will be copied to your clipboard, and also displayed in the window.
  Make sure to save it where it's needed since you won't be able to get unencrypted token later.

  > [!IMPORTANT]
  > The token only works for requests that were marked when it was created.
  > If you use other methods, you will get an error `HTTP 403 Forbidden`.
  > For security reasons it is not recommended to include "All" methods - instead keep selection as narrow as possible.
  > By selecting only certain methods you minimize attack surface if accidentally leak the token.

  ## Compatibility

  This node is developed on and tested to work with the following configuration:

  - **n8n**: Version 2.15.0 and higher
  - **Node.js**: 24.25.0 or higher
  - **npm**: 11.12.1 or higher

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
  - [<img src="logo.svg" width="16" height="16" alt="Rightech IoT Core" align="center"> RIC resources](https://rightech.io)
    - [Platform introduction](/docs/intro.md)
    - [Glossary](/docs/terms.md)
    - [Forums](https://forum.rightech.io/)
    - [Solutions](https://store.rightech.io/solutions)
    - [Tech Support](mailto:development@rightech.io)
    - [Cases and examples](https://github.com/Rightech/ric-public)
    - [Trial version](/docs/trial.md)

ai_documentation_summary:
  {"purpose":"Enables interaction with the Rightech IoT Core (RIC) platform to manage IoT devices, automations, and data through n8n workflows.","capabilities":["Get configuration data and state for a single object","Retrieve configuration and state for multiple objects simultaneously","Update object configuration parameters","Send commands to IoT devices","Read model configuration trees","Start scenario execution on an object","Stop running scenario execution on an object","Get table declaration with column properties","Retrieve specific table rows by ID","Query table rows based on selected conditions"],"authentication":"API Bearer token required","commonUseCases":["Monitoring and controlling IoT sensors and actuators","Automating device configurations based on workflow triggers","Executing predefined automation scenarios on devices","Aggregating and querying device data from tables"],"limitations":["Currently supports only a bare minimum of operations for interacting with IoT devices","Default configuration points to the public development server (dev.rightech.io) unless manually changed"],"relatedNodes":[]}


node_type: n8n-nodes-kipps.kippsAiChatbot
package_name: n8n-nodes-kipps
display_name: Kipps.AI Chatbot
description: Interact with a Kipps.AI Chatbot to send and receive messages.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
outputs:
  [
  "main"
  ]

updated_at: 2026-05-02 08:43:01
author_name: kipps.ai
author_github_url: https://github.com/KIPPS-AI/
npm_package_name: n8n-nodes-kipps
npm_version: 0.0.7
community_fetched_at: 2026-05-02T08:43:01.891Z
ai_summary_generated_at: 2026-03-25 22:51:43
npm_readme:
  # n8n Nodes for Kipps.AI

  This package provides production-ready custom n8n nodes for integrating with the Kipps.AI platform.

  It supports:

  * **Chatbot Agents** — conversational AI workflows
  * **Voice Agents** — outbound/inbound AI voice calls
  * **WhatsApp Agents** — template messaging via WhatsApp Business

  ---

  # Features

  ## Supported Nodes

  ### 1. Kipps.AI Chatbot

  Send messages to Kipps chatbot agents and receive contextual responses.

  ### 2. Kipps.AI Voice Agent

  Initiate voice calls using Kipps voice agents.

  ### 3. Kipps.AI WhatsApp Agent

  Send approved WhatsApp templates through agent-linked WhatsApp integrations.

  ### 4. Dynamic Agent Discovery

  Agents are automatically loaded from the authenticated organization.

  No manual UUID lookup is required.

  Agents are loaded using:

  ```http
  GET /kipps/agents/
  ```

  and automatically filtered into:

  * Chatbots
  * Voice Agents
  * WhatsApp Agents

  ---

  # Installation

  ---

  ## Docker (Recommended for Local Testing)

  ### Step 1: Clone Repository

  ```bash
  git clone https://github.com/KIPPS-AI/n8n-nodes-kipps.git
  cd n8n-nodes-kipps
  ```

  ---

  ### Step 2: Install Dependencies

  ```bash
  npm install
  ```

  ---

  ### Step 3: Build Node

  ```bash
  npm run build
  ```

  ---

  ### Step 4: Verify Build Output

  ```bash
  ls dist/nodes/KippsAi/
  ```

  Expected:

  ```bash
  KippsAi.node.js
  kipps-light.png
  kipps-dark.png
  ```

  ---

  ### Step 5: Run n8n with Docker

  ## Windows PowerShell

  ```powershell
  docker run -it --rm -p 5678:5678 `
    -v "${PWD}:/home/node/.n8n/custom" `
    -e N8N_CUSTOM_EXTENSIONS_MODE=paths `
    -e N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom `
    n8nio/n8n
  ```

  ---

  ## Windows CMD

  ```cmd
  docker run -it --rm -p 5678:5678 -v "%cd%:/home/node/.n8n/custom" -e N8N_CUSTOM_EXTENSIONS_MODE=paths -e N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom n8nio/n8n
  ```

  ---

  ## Linux/macOS

  ```bash
  docker run -it --rm -p 5678:5678 \
    -v "$(pwd):/home/node/.n8n/custom" \
    -e N8N_CUSTOM_EXTENSIONS_MODE=paths \
    -e N8N_CUSTOM_EXTENSIONS=/home/node/.n8n/custom \
    n8nio/n8n
  ```

  ---

  ### Step 6: Open n8n

  ```txt
  http://localhost:5678
  ```

  ---

  # Production Installation (npm)

  ```bash
  npm install n8n-nodes-kipps
  ```

  Restart n8n after installation.

  ---

  # Docker Compose Mount

  ```yaml
  volumes:
    - ./n8n-nodes-kipps:/home/node/.n8n/custom
  ```

  ---

  # Authentication Setup

  Kipps.AI nodes use API Key authentication.

  ## Credential Fields

  ### Required

  * API Key

  ### Optional

  * Base URL

  Production:

  ```txt
  https://backend.kipps.ai
  ```

  Local Development:

  ```txt
  http://host.docker.internal:8000
  ```

  If Base URL is left empty, the node automatically uses:

  ```txt
  https://backend.kipps.ai
  ```

  ---

  # Credential Verification

  Credential validation uses:

  ```http
  GET /kipps/agents/
  ```

  A successful response confirms:

  * API key is valid
  * Organization access is available
  * Agent discovery is working

  ---

  # Node Types and Parameters

  ---

  # Kipps.AI Chatbot

  ### Parameters

  * **Agent Name or ID** — Automatically loaded from your organization
  * **Message** — User input
  * **Session ID** — Optional conversation continuity

  ### APIs Used

  ```http
  POST /v2/kipps/conversation/
  POST /v2/kipps/reply/
  ```

  ---

  # Kipps.AI Voice Agent

  ### Parameters

  * **Voicebot Name or ID** — Automatically loaded from your organization
  * **Phone Number**
  * **Room Name**

  ### API Used

  ```http
  POST /speech/phone-call/
  ```

  ---

  # Kipps.AI WhatsApp Agent

  ### Parameters

  * **WhatsApp Agent Name or ID** — Automatically loaded from your organization
  * **Recipient Number**
  * **Template Name**
  * **Template Parameters**

  ---

  # WhatsApp Template Architecture

  ## Template Fetch Endpoint

  ```http
  GET /integrations/get-whatsapp-templates/
  ```

  ### Requirements

  * Authenticated organization
  * Valid API key

  ---

  ## Send Template Endpoint

  ```http
  POST /integrations/whatsapp-agent/send-template/
  ```

  ### Required Payload

  ```json
  {
    "to": "+1234567890",
    "template_name": "hello_world",
    "parameters": {}
  }
  ```

  ---

  # Local Development Notes

  If testing against a local Django backend:

  ### Base URL

  ```txt
  http://host.docker.internal:8000
  ```

  ---

  ### Django Run Command

  ```bash
  python manage.py runserver 0.0.0.0:8000
  ```

  ---

  ### Local Authentication

  Use a valid local API Key and configure:

  ```txt
  Base URL = http://host.docker.internal:8000
  ```

  ---

  # Common Issues

  ---

  ## Node Not Appearing

  ### Causes

  * Build failure
  * Wrong mount path
  * Missing package.json configuration

  ### Fix

  ```bash
  npm run build
  ```

  ---

  ## Broken Icon

  ### Causes

  * Missing icon files
  * Wrong filenames

  ### Required

  ```txt
  kipps-light.png
  kipps-dark.png
  ```

  ---

  ## Agent Dropdown Not Loading

  ### Causes

  * Invalid API key
  * Wrong backend URL
  * Missing organization access
  * Stale Docker build

  ### Fix

  * Verify credentials
  * Verify API key permissions
  * Rebuild node
  * Restart n8n container

  ---

  ## Template Dropdown Not Loading

  ### Causes

  * Invalid WhatsApp agent
  * Missing approved templates
  * Wrong backend URL
  * Stale Docker build

  ### Fix

  * Verify credentials
  * Verify WhatsApp agent configuration
  * Rebuild
  * Restart container

  ---

  ## Docker Errors

  ### Port already allocated

  ```bash
  docker ps
  docker stop <container_id>
  ```

  ---

  ### Permission denied scanning host

  Mount the correct project directory only.

  ---

  # Build Commands

  ```bash
  npm install
  npm run build
  ```

  ---

  # Publishing to npm

  ### First time setup

  ```bash
  # Login to npm
  npm login

  # Generate a Granular Access Token on npmjs.com:
  # Avatar → Access Tokens → Generate New Token → Granular Access Token
  # Permissions: Read and write | Packages: All packages

  # Set the token
  npm set //registry.npmjs.org/:_authToken YOUR_TOKEN_HERE
  ```

  ### Publish manually

  ```bash
  npm run build
  npm publish --access public
  ```

  ### Version bumping rules

  Every publish needs a new version in `package.json`:

  | Change type | Example           | When to use               |
  | ----------- | ----------------- | ------------------------- |
  | Patch       | `1.0.0` → `1.0.1` | Bug fix, lint fix         |
  | Minor       | `1.0.0` → `1.1.0` | New agent type, new field |
  | Major       | `1.0.0` → `2.0.0` | Breaking change           |

  ---

  ## GitHub Actions — Automated Publish

  After the initial setup, **never publish manually**. All publishes go through GitHub Actions for npm provenance (required for n8n verification).

  ### How it works

  ```
  You push code changes
        ↓
  Update version in package.json
        ↓
  git push to master
        ↓
  GitHub → Releases → Create new release
  Tag: v1.0.2 (must match package.json version,always new version)
        ↓
  GitHub Actions automatically runs:
    - npm install
    - npm run build
    - npm publish --provenance
        ↓
  npm email confirmation received ✅
  ```

  ### Setup (one time only)

  **1. Add NPM_TOKEN to GitHub secrets:**

  - Repo → Settings → Secrets and variables → Actions
  - New repository secret
      - Name: `NPM_TOKEN`
      - Value: your npmjs.com Granular Access Token

  **2. Workflow file is already in repo:**
  `.github/workflows/publish.yml`

  ### Creating a release

  1. Update `version` in `package.json` (e.g. `1.0.2`)
  2. Commit and push
  3. GitHub repo → **Releases** → **Create a new release**
  4. Tag: `v1.0.2` (create new tag)
  5. Title: `v1.0.2`
  6. Click **Publish release**
  7. Watch **Actions** tab — should go green in ~2 minutes

  ---

  # Recommended Testing Flow

  ## Before Production

  Verify:

  * Credential authentication
  * Chatbot dropdown
  * Voicebot dropdown
  * WhatsApp dropdown
  * Template dropdown
  * Template parameter mapper
  * Chatbot execution
  * Voice call execution
  * WhatsApp template execution
  * Docker loading
  * Icon rendering

  ---

  # Support

  ## Kipps Platform

  ```txt
  https://app.kipps.ai
  ```

  ## Backend API

  ```txt
  https://backend.kipps.ai
  ```

  ---

  # Final Notes

  This package is designed for:

  * Workflow automation
  * Lead generation
  * WhatsApp campaigns
  * AI voice automation
  * Enterprise chatbot integrations

  For production deployment, always validate:

  * API credentials
  * Organization permissions
  * WhatsApp integrations
  * Template approval status

  ---

  # License

  MIT

ai_documentation_summary:
  {"purpose":"This n8n node enables interaction with Kipps.AI chatbots and voicebots by sending messages, initiating calls, and managing conversation sessions within n8n workflows.","capabilities":["Send and receive text messages to a Kipps.AI chatbot","Manage conversation context using Session IDs","Initiate voice calls to a Kipps.AI voicebot","Send audio or text messages during an active voice call","End voice calls","Integrate with Kipps.AI API via OAuth2 or API key credentials"],"authentication":"API key required (configured via n8n Credentials section)","commonUseCases":["Automated customer support chatbots","Voice-based customer service interactions","Multi-step conversational workflows","Integration of AI agents into business processes"],"limitations":["Requires manual installation via npm or Docker for custom n8n instances","Audio input requires a local file path for the audio file","Voicebot call actions depend on specific Room Name and Phone Number configuration"],"relatedNodes":["n8n-nodes-kipps.kippsAiVoicebot","n8n-nodes-kipps.kippsAiChatbot"]}


node_type: @mercadopago/n8n-nodes-mercadopago.mercadopago
package_name: @mercadopago/n8n-nodes-mercadopago
display_name: mercadopago
description: Community node for Mercado Pago
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: samher
author_github_url: git+https://github.com/mercadopago/n8n-nodes-mercadopago.git
npm_package_name: @mercadopago/n8n-nodes-mercadopago
npm_version: 0.2.0
community_fetched_at: 2026-05-02T08:43:03.187Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  <div align="center">

  <img src="nodes/MercadoPago/icon-mercadopago.svg" width="80" alt="MercadoPago" />

  # n8n-nodes-mercadopago

  **The official Mercado Pago community node for n8n**

  Connect your workflows to Mercado Pago — create payment links, configure automated reports, and download your financial data, all without leaving n8n.

  [![npm version](https://img.shields.io/npm/v/@mercadopago/n8n-nodes-mercadopago?color=blue&label=npm)](https://www.npmjs.com/package/@mercadopago/n8n-nodes-mercadopago)
  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
  [![Node.js](https://img.shields.io/badge/node-%3E%3D20.15-brightgreen)](https://nodejs.org)
  [![n8n community node](https://img.shields.io/badge/n8n-community%20node-orange)](https://docs.n8n.io/integrations/community-nodes/)

  </div>

  ---

  ## ✨ What can you do with this node?

  | Resource | What you get |
  |----------|-------------|
  | 💳 **Payments** | Create Checkout Preference links with items, back URLs, expiration dates and more |
  | 📊 **Reporting** | Configure, list and download Release & Settlement reports |

  ---

  ## 🗺️ Operations at a glance

  ### 💳 Payments

  | Operation | Method | Description |
  |-----------|--------|-------------|
  | **Create Payment Link** | `POST` | Generate a Checkout Preference link to accept payments |

  ### 📊 Reporting — Release Reports

  | Operation | Method | Description |
  |-----------|--------|-------------|
  | **List Release Reports** | `GET` | List generated report files (supports pagination & returnAll) |
  | **Configure Release Report** | `POST / PUT` | Create **or** update preferences — columns, frequency, SFTP delivery |
  | **Get Release Report Config** | `GET` | Read the current configuration for your account |
  | **Download Release Report** | `GET` | Download a specific report file as CSV |

  ### 📊 Reporting — Settlement Reports

  | Operation | Method | Description |
  |-----------|--------|-------------|
  | **List Settlement Reports** | `GET` | List generated settlement report files |
  | **Configure Settlement Report** | `POST / PUT` | Create **or** update preferences — columns, frequency, SFTP delivery |
  | **Get Settlement Report Config** | `GET` | Read the current configuration for your account |
  | **Download Settlement Report** | `GET` | Download a specific settlement report file as CSV |

  > **💡 Smart configure:** The Configure operations are _upsert_ — they automatically create the config if it doesn't exist yet, or update it if it does. No need to know what state you're in.

  ---

  ## 🚀 Quick start

  ### 1. Install the node

  In your n8n instance go to **Settings → Community Nodes → Install** and enter:

  ```
  @mercadopago/n8n-nodes-mercadopago
  ```

  ### 2. Set up your credential

  1. In n8n go to **Credentials → New** → search for **MercadoPago API**
  2. Paste your **Access Token** (found in the [Mercado Pago Developer Portal](https://www.mercadopago.com.br/developers))
  3. Click **Test credential** — you'll get a green ✅ if it's valid

  > **Optional — SFTP delivery:** If you want reports delivered automatically to an SFTP server, create a **MercadoPago SFTP** credential with the connection details and attach it to the node.

  ### 3. Build your first workflow

  ```
  Trigger → MercadoPago (Create Payment Link) → Send email with payment URL
  ```

  ```
  Schedule → MercadoPago (List Release Reports) → Filter → Save to Google Sheets
  ```

  ---

  ## 📋 Operation details

  <details>
  <summary><strong>💳 Create Payment Link</strong></summary>

  Creates a [Checkout Preference](https://www.mercadopago.com.br/developers/en/reference/preferences/_checkout_preferences/post) — a hosted payment page with your items.

  **Required:**
  - At least one **Item** (title, quantity, currency, unit price)

  **Optional fields:**
  - `external_reference` — your internal order ID (max 64 chars)
  - `notification_url` — HTTPS webhook for payment status updates
  - `back_urls` — redirect URLs for success / pending / failure
  - `auto_return` — auto-redirect after approved payment
  - `expiration_date_from` / `expiration_date_to` — limit when the link is valid
  - `statement_descriptor` — text on the buyer's bank statement (max 13 chars)
  - `binary_mode` — only approved/rejected (no pending)

  </details>

  <details>
  <summary><strong>📊 Configure Release Report</strong></summary>

  Sets up automatic Release Report generation for your account. Works as an **upsert** — safe to run multiple times.

  **Required:**
  - **Columns** — at least one column key (e.g. `DATE`, `SOURCE_ID`, `NET_CREDIT_AMOUNT`)
  - **File Name Prefix** — prefix for generated file names
  - **Frequency** — hour (0–23), interval value, and type (`daily` / `weekly` / `monthly`)

  **Optional:**
  - SFTP credential for automatic file delivery
  - `separator`, `display_timezone`, `report_translation`
  - Email notification list
  - Boolean flags: `include_withdrawal_at_end`, `check_available_balance`, `compensate_detail`, `execute_after_withdrawal`, `scheduled`

  </details>

  <details>
  <summary><strong>📊 Configure Settlement Report</strong></summary>

  Same as Configure Release Report but for Settlement Reports. Supports a different set of columns and fewer boolean flags.

  </details>

  <details>
  <summary><strong>⬇️ Download Report (Release or Settlement)</strong></summary>

  Downloads a generated report file by name.

  - Returns a JSON object with a `content` field containing the raw CSV string
  - Pipe this into a **Write Binary File** node or a **Code** node to process it

  </details>

  ---

  ## 🔐 Credentials

  ### MercadoPago API _(required)_

  | Field | Description |
  |-------|-------------|
  | **Access Token** | Your Bearer token from the Mercado Pago Developer Portal |

  Get your token at: [mercadopago.com.br/developers → Your integrations → Credentials](https://www.mercadopago.com.br/developers)

  ### MercadoPago SFTP _(optional)_

  Only needed if you configure SFTP delivery for reports.

  | Field | Description |
  |-------|-------------|
  | **Server** | SFTP hostname or IP |
  | **Username** | SFTP login |
  | **Password** | SFTP password (stored encrypted) |
  | **Remote Dir** | Destination directory on the SFTP server |
  | **Port** | Default: 22 |

  ---

  ## 🏗️ Architecture

  The node follows a modular handler pattern where each operation lives in its own file.

  ```
  credentials/
    MercadoPagoApi.credentials.ts    ← API access token credential
    MercadoPagoSftp.credentials.ts   ← Optional SFTP credential

  nodes/MercadoPago/
    MercadoPago.node.ts              ← Node definition, UI properties, request wrapper
    MercadoPago.node.json            ← Metadata (categories, docs links)
    icon-mercadopago.svg
    icon-mercadopago.dark.svg
    operations/
      index.ts                       ← Handler registry + shared types (HandlerCtx)
      utils.ts                       ← Shared parsing helpers
      createPaymentLink.ts
      listReleaseReports.ts
      configureReleaseReport.ts      ← Upsert: POST → fallback PUT on 409
      getReleaseReportConfig.ts
      downloadReleaseReport.ts
      listSettlementReports.ts
      configureSettlementReport.ts   ← Upsert: POST → fallback PUT on 409
      getSettlementReportConfig.ts
      downloadSettlementReport.ts

  tests/operations/                  ← Vitest unit tests (one per operation)
  ```

  **How operations work:**

  ```
  execute() in MercadoPago.node.ts
    └── builds HandlerCtx (credential, request wrapper, helpers)
    └── dispatches to operations[operationName](ctx)
        └── handler validates input → builds body → calls ctx.request()
            └── makeRequest() adds Auth header, handles httpRequest
  ```

  ---

  ## 🛠️ Development

  ### Prerequisites
  - Node.js >= 20.15
  - npm

  ### Commands

  ```bash
  npm install          # Install dependencies
  npm run build        # Compile TypeScript → dist/
  npm run test:unit    # Run unit tests once
  npm run test         # Run tests in watch mode
  npm run test:coverage # Generate coverage report
  npm run lint         # ESLint
  npm run format       # Prettier
  ```

  ### Adding a new operation

  1. Create `nodes/MercadoPago/operations/myOperation.ts`
  2. Implement the handler using `HandlerCtx`
  3. Register it in `operations/index.ts`
  4. Add UI properties to `MercadoPago.node.ts`
  5. Write tests in `tests/operations/myOperation.test.ts`

  ---

  ## 🤝 Contributing

  Contributions are welcome! Read [CONTRIBUTING.md](CONTRIBUTING.md) to learn about the development process, branching model, and how to submit a pull request.

  ---

  ## 📄 License

  [MIT](LICENSE) — maintained by the **Tech Stuff IXF** team at Mercado Pago.

ai_documentation_summary:
  {"purpose":"A community n8n node that integrates Mercado Pago APIs to handle payment link creation and reporting operations (release and settlement reports).","capabilities":["Create payment links (preferences)","List release reports with pagination","Configure release reports","Edit release report configuration","Download release reports as CSV","List settlement reports with pagination","Configure settlement reports","Edit settlement report configuration","Download settlement reports as CSV","Return raw CSV content for CSV download operations"],"authentication":"Personal Access Token (Bearer token) via MercadoPagoApi credential","commonUseCases":["Automating payment link generation for e-commerce workflows","Automating financial reporting and reconciliation","Downloading settlement data for accounting systems","Configuring automated report delivery via SFTP"],"limitations":["Requires manual installation via npm build and symlinking (not a native n8n node)","Requires Node.js version >= 20.15","CSV downloads return raw text content that requires additional processing to be saved to files"],"relatedNodes":["n8n HTTP Request","n8n CSV","n8n File"]}


node_type: n8n-nodes-efibank.efibank
package_name: n8n-nodes-efibank
display_name: efibank
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: consultoria-efi
author_github_url: git+https://github.com/efipay/n8n-nodes-efibank.git
npm_package_name: n8n-nodes-efibank
npm_version: 1.0.10
community_fetched_at: 2026-05-02T08:43:03.196Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  Nó personalizado para integração com as APIs Cobranças e Pix do Efi Bank, permitindo operações de pagamentos, recebimentos e gerenciamento de transações financeiras.

npm_readme:
  ![Banner image](https://gnetbr.com/BJgSIUhlYs)

  # n8n-nodes-efibank

  O n8n-nodes-efibank é um nó personalizado para o n8n que simplifica a integração com a API Cobranças e a API Pix do Efibank, permitindo a automação de fluxos financeiros, como pagamentos, recebimentos e transações.

  [Requisitos](#requisitos) 

  [Instalação](#instalação)

  [Instalação do nó](#instalação-do-nó)  

  [Configuração do nó](#configuração-do-nó)  

  ## Requisitos

  ### Versão do Node.js
  Este nó personalizado requer uma versão do Node.js compatível com o n8n. A versão mínima necessária é **18.17**, e a versão máxima suportada é **22**.

  ## Instalação

  Para instalar o nó em uma instalação existente do n8n, utilize uma das opções abaixo:

  ### Instalação via NPM

  ```bash
  $ npm install n8n-nodes-efibank
  ```

  ### Instalação via [GIT](https://github.com/efipay/n8n-nodes-efibank)

  ```bash
  $ git clone https://github.com/efipay/n8n-nodes-efibank.git
  ```


  ## Instalação do nó

  Para instalar corretamente o nó personalizado, siga estas etapas:

  1. Instale as dependências:
  ```bash
  npm install
  ```

  2. Compile o código:
  ```bash
  npm run build
  ```

  3. Configure o link para uso local (desenvolvimento):
  ```bash
  npm link
  ```

  4. Inicie o n8n:
  ```bash
  n8n
  ```

  ## Configuração do nó

  No ambiente do <strong>n8n</strong>, acesse seu workflow e busque pelos nós **Efí Bank Cobranças** e **Efí Bank Pix**

  ### Configuração do Nó da API Cobranças
  Na interface do n8n, configure suas credenciais:
  1. Selecione o ambiente (Homologação/Produção);
  2. Configure as credenciais Client ID e Client Secret para os dois ambientes. Para obter as credencias da aplicação, você pode acessar [esse tutorial](https://dev.efipay.com.br/docs/api-cobrancas/credenciais#obtendo-as-credenciais-da-aplica%C3%A7%C3%A3o);
  3. Clique em Save.

  ### Configuração do Nó da API Pix
  Na interface do n8n, configure suas credenciais:
  1. Selecione o ambiente (Homologação/Produção);
  2. Configure as credenciais Client ID e Client Secret para os dois ambientes. Para obter as credencias da aplicação, você pode acessar [esse tutorial](https://dev.efipay.com.br/docs/api-cobrancas/credenciais#obtendo-as-credenciais-da-aplica%C3%A7%C3%A3o);
  3. Configure o certificado:
     - Gere um certificado em sua conta Efí, seguindo [este guia](https://sejaefi.com.br/central-de-ajuda/api/como-gerar-o-certificado-para-usar-a-api-pix?_gl=1*96b3d4*_gcl_au*MTgzNDQxMDgyMi4xNzQzNTA2MDI5#conteudo);
     - Converta o certificado .p12 fazendo o upload na [página de conversão](https://efipay.github.io/encode-credentials/certificado.html) e clique em "Codificar e Exibir" para obter os dados necessários;
     - Copie o conteúdo do Certificado e cole no campo "Certificado";
     - Copie o conteúdo da Key e cole no campo "Key";
  4. Clique em Save.

ai_documentation_summary:
  {"purpose":"A custom n8n node for integrating with Efi Bank's Payment and Pix APIs to automate financial operations including payments, receipts, and transaction management.","capabilities":["Payment processing via Efi Bank API","Pix payment integration","Receipt management","Transaction management","Support for both Sandbox (Homologação) and Production environments"],"authentication":"OAuth2 (Client ID and Client Secret required for both environments; Pix requires additional certificate configuration)","commonUseCases":["Automating customer payments","Processing Pix transfers","Managing financial transactions in n8n workflows","Automated receipt generation"],"limitations":["Requires Node.js version 18.17 to 22","Pix integration requires manual certificate generation and conversion (.p12 to base64)","Requires local compilation and linking for development use"],"relatedNodes":["n8n-nodes-webhook","n8n-nodes-http-request","n8n-nodes-credentials"]}


node_type: @nectopro/n8n-nodes-nano-banana.nanobanana
package_name: @nectopro/n8n-nodes-nano-banana
display_name: nanobanana
description: Nano Banana Node for n8n
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: necto-pro
author_github_url: git+https://github.com/necto-pro/n8n-nodes-nano-banana.git
npm_package_name: @nectopro/n8n-nodes-nano-banana
npm_version: 0.1.12
community_fetched_at: 2026-05-02T08:43:03.197Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-nano-banana

  This is an n8n community node that integrates Google's Gemini AI models for advanced text and image generation capabilities. It lets you use Nano Banana (powered by Gemini AI) in your n8n workflows for creating images, analyzing visual content, and generating text responses.

  Google Gemini AI is a powerful multimodal AI platform that can understand and generate both text and images, making it perfect for creative workflows, content generation, and AI-powered automation.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  ## Table of Contents

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Getting Started](#getting-started)  
  [Usage Examples](#usage-examples)  
  [Compatibility](#compatibility)  
  [Resources](#resources)  
  [Contributing](#contributing)  
  [License](#license)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ### Install via npm

  ```bash
  npm install @nectopro/n8n-nodes-nano-banana
  ```

  ### Install in n8n

  1. Go to **Settings > Community Nodes**
  2. Select **Install**
  3. Enter `@nectopro/n8n-nodes-nano-banana`
  4. Agree to the risks of using community nodes
  5. Select **Install**

  After installation restart n8n to use the new nodes.

  ## Operations

  The Nano Banana node supports the following operations:

  ### Generate Content
  - **Text Generation**: Create written content, stories, code, and more
  - **Image Generation**: Generate images from text descriptions
  - **Image Analysis**: Analyze and describe uploaded images
  - **Multimodal Conversations**: Combine text and images in interactive dialogues
  - **Creative Tasks**: Logo design, artwork, technical diagrams, and illustrations
  - **JSON Input Format**: Provide message history and current message as JSON for programmatic workflows

  ### Key Features
  - Support for multiple content types (text, images via URL or base64)
  - Conversation history management
  - Streaming responses for real-time processing
  - Multiple response modalities (text, images, or both)
  - Advanced configuration options (temperature, tokens, etc.)
  - Comprehensive error handling
  - Flexible input formats (Manual UI mapping or JSON)

  ## Credentials

  To use this node, you need a Google AI Studio API key.

  ### Getting Your API Key

  1. **Visit Google AI Studio**
     - Go to [Google AI Studio](https://makersuite.google.com/app/apikey)
     - Sign in with your Google account

  2. **Create API Key**
     - Click "Create API Key"
     - Choose "Create API key in new project" or select an existing project
     - Copy the generated API key (starts with `AIza...`)

  3. **Configure in n8n**
     - In your n8n workflow, add the Nano Banana node
     - Click on the credential field
     - Select "Create New"
     - Choose "AI Studio Credentials API"
     - Paste your API key
     - Save the credential

  ### Important Notes
  - Keep your API key secure and never share it publicly
  - Google AI Studio has usage limits and quotas
  - Some features may require billing to be enabled in Google Cloud
  - The API key provides access to Gemini models including image generation capabilities

  ## Getting Started

  ### Input Format Options

  The node supports two input formats that can be selected in the node settings:

  1. **Manual Mapping**: Use the UI fields to define message history and current message
  2. **JSON Format**: Provide all input data as a JSON object in the "JSON Input" field

  ### JSON Input Format

  When using JSON format, provide a JSON object with the following structure:

  ```json
  {
    "messageHistory": [
      {
        "contentType": "text",
        "text": "What's in this image?",
        "role": "user"
      },
      {
        "contentType": "imageUrl",
        "imageUrl": "https://example.com/image.jpg",
        "mimeType": "image/jpeg",
        "role": "user"
      },
      {
        "contentType": "text",
        "text": "This is a beautiful landscape with mountains and a lake.",
        "role": "model"
      }
    ],
    "currentMessage": "Can you describe the colors in more detail?"
  }
  ```

  ### Basic Text Generation

  1. Add a **Nano Banana** node to your workflow
  2. Set up your **AI Studio Credentials**
  3. Select **Generate Image** operation
  4. Choose **Nano Banana Image** model
  5. Select **JSON Format** if you want to use JSON input, or keep **Manual Mapping**
  6. Enter your prompt in **Current Message** (Manual) or **JSON Input** (JSON)
  7. Set **Response Modalities** to **TEXT**
  8. Execute the node

  ### Basic Image Generation

  1. Follow steps 1-5 from above
  2. Enter an image description prompt
  3. Set **Response Modalities** to **IMAGE**
  4. Execute to generate an image

  ### Image Analysis

  1. Add the node and configure credentials
  2. Select input format (Manual or JSON)
  3. For Manual: In **Message History**, add a message with:
     - **Content Type**: Image (URL) or Image (Base64)
     - **Image URL** or **Image Base64** data
     - **Role**: User
  4. For JSON: Include image data in the JSON input
  5. Set **Current Message** to your question about the image
  6. Set **Response Modalities** to **TEXT**
  7. Execute to get image analysis

  ## Usage Examples

  ### Example 1: Creative Writing
  ```json
  {
    "operation": "generateContent",
    "model": "gemini-2.5-flash-image-preview",
    "currentMessage": "Write a short story about a robot learning to paint",
    "responseModalities": ["TEXT"]
  }
  ```

  ### Example 2: Logo Design
  ```json
  {
    "operation": "generateContent", 
    "model": "gemini-2.5-flash-image-preview",
    "currentMessage": "Create a modern, minimalist logo for a coffee shop called 'Morning Brew'",
    "responseModalities": ["IMAGE", "TEXT"]
  }
  ```

  ### Example 3: Image Analysis
  ```json
  {
    "operation": "generateContent",
    "model": "gemini-2.5-flash-image-preview",
    "messageHistory": {
      "messages": [{
        "role": "user",
        "contentType": "imageUrl",
        "imageUrl": "https://example.com/photo.jpg",
        "mimeType": "image/jpeg"
      }]
    },
    "currentMessage": "What objects do you see in this image?",
    "responseModalities": ["TEXT"]
  }
  ```

  ### Example 4: Conversation with Context
  ```json
  {
    "operation": "generateContent",
    "model": "gemini-2.5-flash-image-preview", 
    "messageHistory": {
      "messages": [
        {
          "role": "user",
          "contentType": "text",
          "text": "I need help designing a website"
        },
        {
          "role": "model", 
          "contentType": "text",
          "text": "I'd be happy to help! What type of website are you looking to create?"
        }
      ]
    },
    "currentMessage": "It's for a photography portfolio",
    "responseModalities": ["TEXT"]
  }
  ```

  ### Example 5: JSON Input Format
  ```json
  {
    "operation": "generateContent",
    "model": "gemini-2.5-flash-image-preview",
    "inputFormat": "json",
    "jsonInput": "{\n  \"messageHistory\": [\n    {\n      \"contentType\": \"text\",\n      \"text\": \"What's in this image?\",\n      \"role\": \"user\"\n    },\n    {\n      \"contentType\": \"imageUrl\",\n      \"imageUrl\": \"https://example.com/image.jpg\",\n      \"mimeType\": \"image/jpeg\",\n      \"role\": \"user\"\n    }\n  ],\n  \"currentMessage\": \"Can you describe the colors in more detail?\"\n}",
    "responseModalities": ["TEXT"]
  }
  ```

  ## Advanced Configuration

  The node supports advanced parameters for fine-tuning:

  - **Temperature**: Controls creativity (0.0-1.0)
  - **Max Output Tokens**: Limits response length
  - **Top P**: Nucleus sampling parameter
  - **Top K**: Top-k sampling parameter
  - **Stream Response**: Enable real-time streaming

  ## Compatibility

  - **Minimum n8n version**: 0.227.0
  - **Node.js**: 20.15 or higher
  - **Tested with**: n8n 1.0+

  ### Known Limitations
  - Image generation requires sufficient API quotas
  - Large images may take longer to process
  - Rate limits apply based on your Google AI Studio plan

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
  - [Google AI Studio](https://makersuite.google.com/)
  - [Gemini API Documentation](https://ai.google.dev/gemini-api/docs)
  - [Google AI Studio API Key Management](https://makersuite.google.com/app/apikey)
  - [Node GitHub Repository](https://github.com/necto-pro/n8n-nodes-nano-banana)

  ## Contributing

  Contributions are welcome! Please feel free to submit a Pull Request.

  ### Development Setup

  1. Clone the repository:
     ```bash
     git clone https://github.com/necto-pro/n8n-nodes-nano-banana.git
     cd n8n-nodes-nano-banana
     ```

  2. Install dependencies:
     ```bash
     npm install
     ```

  3. Build the project:
     ```bash
     npm run build
     ```

  4. Lint the code:
     ```bash
     npm run lint
     npm run lintfix  # To auto-fix issues
     ```

  5. Test locally:
     ```bash
     npm run dev
     ```

  ## License

  [MIT](LICENSE.md)

  ---

  **Created by [Necto Pro](https://necto.pro)** | **Questions?** [Open an issue](https://github.com/necto-pro/n8n-nodes-nano-banana/issues)

ai_documentation_summary:
  {"purpose":"Integrates Google's Gemini AI models into n8n workflows to enable text generation, image creation, and multimodal analysis capabilities.","capabilities":["Text generation (stories, code, creative writing)","Image generation from text descriptions","Image analysis and visual content description","Multimodal conversations combining text and images","Conversation history management","Streaming responses for real-time processing","Flexible input formats (Manual UI mapping or JSON)","Advanced configuration (temperature, tokens, response modalities)"],"authentication":"API key required (Google AI Studio API key)","commonUseCases":["Creative content generation and storytelling","Logo design and artwork creation","Visual content analysis and description","AI-powered customer support with image context","Technical diagram generation"],"limitations":["Requires Google AI Studio API key with proper billing setup for all features","Subject to Google AI Studio usage limits and quotas","Some features may require enabling billing in Google Cloud"],"relatedNodes":[]}


node_type: n8n-nodes-perfex.perfex
package_name: n8n-nodes-perfex
display_name: perfex
description: Nó n8n para integração com o Perfex CRM através do módulo WON API
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: matheusgrifohub
author_github_url: git+https://github.com/Matheusbaiense/nodeperfex.git
npm_package_name: n8n-nodes-perfex
npm_version: 0.2.0
community_fetched_at: 2026-05-02T08:43:03.199Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-perfex

  Um nó n8n para integração com o **Perfex CRM** através do módulo WON API.

  ## Instalação

  Para instalar este nó n8n:

  ```bash
  npm install n8n-nodes-perfex
  ```

  ## Configuração

  Para usar este nó, você precisará configurar as credenciais do Perfex CRM:

  1. **URL Base**: A URL base do seu Perfex CRM (ex: `https://seu-perfex.com`)
  2. **API Token**: O token da API do Perfex CRM (único campo necessário para autenticação)

  ### Como obter o API Token

  1. Acesse seu Perfex CRM
  2. Vá em **Setup** → **Staff**
  3. Edite um usuário staff
  4. Na aba **API**, gere ou copie o token de API existente

  ## Recursos Disponíveis

  Este nó oferece operações completas para os seguintes recursos do Perfex:

  ### 📋 Clients (Clientes)
  - **Create**: Criar novo cliente
  - **Read**: Obter dados de um cliente específico
  - **Update**: Atualizar dados de um cliente
  - **Delete**: Remover um cliente
  - **List**: Listar todos os clientes

  ### 👤 Contacts (Contatos)
  - **Create**: Criar novo contato
  - **Read**: Obter dados de um contato específico
  - **Update**: Atualizar dados de um contato
  - **Delete**: Remover um contato
  - **List**: Listar todos os contatos

  ### 🎯 Leads (Leads)
  - **Create**: Criar novo lead
  - **Read**: Obter dados de um lead específico
  - **Update**: Atualizar dados de um lead
  - **Delete**: Remover um lead
  - **List**: Listar todos os leads

  ### 📊 Projects (Projetos)
  - **Create**: Criar novo projeto
  - **Read**: Obter dados de um projeto específico
  - **Update**: Atualizar dados de um projeto
  - **Delete**: Remover um projeto
  - **List**: Listar todos os projetos

  ### ✅ Tasks (Tarefas)
  - **Create**: Criar nova tarefa
  - **Read**: Obter dados de uma tarefa específica
  - **Update**: Atualizar dados de uma tarefa
  - **Delete**: Remover uma tarefa
  - **List**: Listar todas as tarefas

  ### 💰 Invoices (Faturas)
  - **Create**: Criar nova fatura
  - **Read**: Obter dados de uma fatura específica
  - **Update**: Atualizar dados de uma fatura
  - **Delete**: Remover uma fatura
  - **List**: Listar todas as faturas

  ## Como Usar

  1. **Adicionar Credenciais**: Configure sua URL base e API Token do Perfex
  2. **Escolher Recurso**: Selecione o recurso desejado (Client, Contact, Lead, etc.)
  3. **Escolher Operação**: Selecione a operação (Create, Read, Update, Delete, List)
  4. **Preencher Parâmetros**: Complete os campos necessários para a operação

  ## Características Técnicas

  - **Total de Operações**: 30 operações (6 recursos × 5 operações cada)
  - **Autenticação**: Via API Token com header `X-API-TOKEN`
  - **Dependências**: axios para requisições HTTP
  - **Compatibilidade**: n8n versão 0.107.0+
  - **Node.js**: Versão 16.0.0 ou superior

  ## Exemplos de Uso

  ### Criar um Cliente
  1. Selecione **Recurso**: Client
  2. Selecione **Operação**: Create
  3. Preencha os campos obrigatórios como nome da empresa
  4. Execute o workflow

  ### Listar Leads
  1. Selecione **Recurso**: Lead
  2. Selecione **Operação**: List
  3. Execute para obter todos os leads

  ### Atualizar Projeto
  1. Selecione **Recurso**: Project
  2. Selecione **Operação**: Update
  3. Forneça o ID do projeto e os campos a serem atualizados
  4. Execute o workflow

  ## Suporte

  - **Documentação da API**: [Perfex CRM API Documentation](https://docs.perfexcrm.com/api/)
  - **Repositório**: [GitHub](https://github.com/Matheusbaiense/nodeperfex)
  - **Issues**: [GitHub Issues](https://github.com/Matheusbaiense/nodeperfex/issues)

  ## Licença

  MIT License

  ## Autor

  **Matheus Baiense**
  - Email: matheusbaiense@gmail.com
  - GitHub: [@Matheusbaiense](https://github.com/Matheusbaiense)

  ## Agradecimentos

  - Equipe do n8n por criar uma plataforma incrível
  - Equipe do Perfex CRM por desenvolver um CRM robusto
  - Todos os contribuidores que ajudaram no projeto

ai_documentation_summary:
  {"purpose":"Integra com o Perfex CRM através da API WON, permitindo CRUD completo para clientes, contatos, leads, projetos, tarefas e faturas.","capabilities":["Criar clientes, contatos, leads, projetos, tarefas e faturas","Ler dados específicos de clientes, contatos, leads, projetos, tarefas e faturas","Atualizar clientes, contatos, leads, projetos, tarefas e faturas","Excluir clientes, contatos, leads, projetos, tarefas e faturas","Listar todos os clientes, contatos, leads, projetos, tarefas e faturas"],"authentication":"API Token via header X-API-TOKEN","commonUseCases":["Gestão de relacionamento com clientes (CRM)","Automação de criação e acompanhamento de leads","Gestão de projetos e tarefas de equipe","Emissão e gestão de faturas"],"limitations":[],"relatedNodes":[]}


node_type: n8n-nodes-asaas-pagamentos.asaaspagamentos
package_name: n8n-nodes-asaas-pagamentos
display_name: asaaspagamentos
description: Node n8n para integração da plataforma de pagamento Asaas
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: 99lab.dev
author_github_url: git+https://github.com/99labdev/n8n-nodes-asaas.git
npm_package_name: n8n-nodes-asaas-pagamentos
npm_version: 0.1.2
community_fetched_at: 2026-05-02T08:43:03.211Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-asaas-pagamentos

  ![Asaas Logo](logo.png)

  Este é um nó da comunidade n8n. Ele permite que você use o Asaas em seus fluxos de trabalho n8n.

  O Asaas é uma plataforma de pagamentos brasileira que oferece soluções completas para cobrança, recebimento e pagamento, incluindo PIX, boleto bancário, cartão de crédito e débito, TED, além de funcionalidades como gestão de assinaturas, split de pagamentos, antecipação de recebíveis e muito mais.

  [n8n](https://n8n.io/) é uma plataforma de automação de fluxo de trabalho [licenciada fair-code](https://docs.n8n.io/reference/license/).

  ## Instalação

  Siga o [guia de instalação](https://docs.n8n.io/integrations/community-nodes/installation/) na documentação de nós da comunidade n8n.

  ```bash
  npm install n8n-nodes-asaas-pagamentos
  ```

  ## Operações

  ### Recursos Implementados da API Asaas

  #### ✅ Clientes

  - [x] **Listar clientes** - Recuperar lista de clientes com filtros opcionais
  - [x] **Criar novo cliente** - Criar um novo cliente com dados pessoais, de contato e endereço
  - [x] **Recuperar cliente específico** - Obter detalhes completos de um cliente pelo ID
  - [x] **Atualizar cliente existente** - Modificar dados de um cliente já cadastrado
  - [x] **Deletar cliente** - Remover cliente do sistema permanentemente
  - [x] **Restaurar cliente removido** - Reativar cliente que foi deletado anteriormente

  #### ⏳ Cobranças (Payments)

  - [ ] **Criar nova cobrança** - Criar cobrança com diversas formas de pagamento
  - [ ] **Listar cobranças** - Recuperar lista de cobranças com filtros avançados
  - [ ] **Criar cobrança com cartão de crédito** - Cobrança direta com cartão
  - [ ] **Capturar cobrança com Pré-Autorização** - Finalizar pagamento pré-autorizado
  - [ ] **Pagar cobrança com cartão de crédito** - Processar pagamento de cobrança existente
  - [ ] **Recuperar informações de pagamento** - Obter dados de billing de uma cobrança
  - [ ] **Informações sobre visualização** - Dados de quando a cobrança foi visualizada
  - [ ] **Recuperar cobrança específica** - Obter detalhes de uma cobrança
  - [ ] **Atualizar cobrança existente** - Modificar dados de cobrança pendente
  - [ ] **Excluir cobrança** - Remover cobrança do sistema
  - [ ] **Restaurar cobrança removida** - Reativar cobrança excluída
  - [ ] **Recuperar status de cobrança** - Verificar status atual da cobrança
  - [ ] **Estornar cobrança** - Realizar estorno total ou parcial
  - [ ] **Obter linha digitável do boleto** - Código de barras para pagamento
  - [ ] **Obter QR Code PIX** - Gerar QR Code para pagamento via PIX
  - [ ] **Confirmar recebimento em dinheiro** - Marcar como pago em dinheiro
  - [ ] **Desfazer confirmação em dinheiro** - Cancelar confirmação de pagamento em dinheiro
  - [ ] **Simulador de vendas** - Simular cenários de pagamento

  #### ⏳ Ações em Sandbox

  - [ ] **Confirmar pagamento** - Simular confirmação de pagamento no ambiente de teste
  - [ ] **Adicionar saldo** - Adicionar crédito para testes na conta sandbox

  #### ⏳ Cobranças com Dados Resumidos

  - [ ] **Criar cobrança com dados resumidos** - Retorna resposta simplificada para performance

  #### ⏳ Cartão de Crédito

  - [ ] **Tokenização de cartão de crédito** - Gerar token seguro para cartão
  - [ ] **Criar cobrança com cartão tokenizado** - Usar token para criar cobrança
  - [ ] **Validar dados do cartão** - Verificar se cartão é válido
  - [ ] **Listar cartões tokenizados** - Recuperar cartões salvos do cliente

  #### ⏳ Estornos

  - [ ] **Listar estornos de uma cobrança** - Histórico de estornos
  - [ ] **Criar estorno total** - Estornar valor completo da cobrança
  - [ ] **Criar estorno parcial** - Estornar parte do valor da cobrança
  - [ ] **Recuperar detalhes do estorno** - Informações específicas do estorno

  #### ⏳ Splits de Pagamento

  - [ ] **Recuperar split pago** - Informações de divisão de pagamento realizada
  - [ ] **Configurar splits** - Definir divisão de valores entre contas
  - [ ] **Listar splits** - Histórico de divisões de pagamento
  - [ ] **Cancelar split** - Desfazer divisão configurada

  #### ⏳ Conta Escrow

  - [ ] **Encerrar garantia da cobrança** - Finalizar processo de garantia
  - [ ] **Configurar conta escrow** - Ativar sistema de garantia
  - [ ] **Consultar status escrow** - Verificar situação da garantia

  #### ⏳ Documentos de Cobranças

  - [ ] **Upload de documentos da cobrança** - Anexar arquivos à cobrança
  - [ ] **Listar documentos** - Recuperar arquivos anexados
  - [ ] **Deletar documento** - Remover arquivo anexado
  - [ ] **Download de documento** - Baixar arquivo específico

  #### ⏳ Notificações

  - [ ] **Atualizar notificação existente** - Modificar configurações de notificação
  - [ ] **Configurar notificações** - Definir tipos de notificações ativas
  - [ ] **Listar notificações** - Recuperar histórico de notificações enviadas
  - [ ] **Criar nova notificação** - Configurar nova regra de notificação
  - [ ] **Deletar notificação** - Remover configuração de notificação

  #### ⏳ Parcelamentos

  - [ ] **Criar parcelamento** - Dividir cobrança em múltiplas parcelas
  - [ ] **Listar parcelamentos** - Recuperar parcelamentos criados
  - [ ] **Recuperar parcelamento específico** - Detalhes de um parcelamento
  - [ ] **Atualizar parcelamento** - Modificar parcelamento existente
  - [ ] **Deletar parcelamento** - Cancelar parcelamento

  #### ⏳ Assinaturas (Recorrência)

  - [ ] **Criar nova assinatura** - Configurar cobrança recorrente
  - [ ] **Listar assinaturas** - Recuperar assinaturas ativas e inativas
  - [ ] **Recuperar assinatura específica** - Detalhes de uma assinatura
  - [ ] **Atualizar assinatura** - Modificar dados da assinatura
  - [ ] **Cancelar assinatura** - Encerrar cobrança recorrente
  - [ ] **Listar cobranças da assinatura** - Histórico de cobranças geradas
  - [ ] **Listar faturas da assinatura** - Faturas relacionadas à assinatura

  #### ⏳ PIX

  - [ ] **Criar chave PIX** - Registrar nova chave PIX na conta
  - [ ] **Listar chaves PIX** - Recuperar chaves PIX cadastradas
  - [ ] **Deletar chave PIX** - Remover chave PIX da conta
  - [ ] **Criar cobrança PIX** - Gerar cobrança específica para PIX
  - [ ] **Gerar QR Code estático** - QR Code reutilizável para recebimentos
  - [ ] **Gerar QR Code dinâmico** - QR Code para valor específico
  - [ ] **Decodificar QR Code** - Extrair informações de QR Code PIX

  #### ⏳ Transações PIX

  - [ ] **Pagar QR Code** - Efetuar pagamento via QR Code PIX
  - [ ] **Listar transações PIX** - Histórico de transações PIX
  - [ ] **Cancelar transação PIX** - Estornar transação PIX quando possível
  - [ ] **Recuperar comprovante PIX** - Obter comprovante da transação
  - [ ] **Consultar status transação** - Verificar situação da transação PIX

  #### ⏳ PIX Recorrente

  - [ ] **Listar recorrências PIX** - Recuperar PIX programados
  - [ ] **Criar recorrência PIX** - Agendar PIX recorrente
  - [ ] **Cancelar recorrência PIX** - Interromper PIX programado
  - [ ] **Atualizar recorrência PIX** - Modificar agendamento PIX

  #### ⏳ Link de Pagamentos

  - [ ] **Criar link de pagamentos** - Gerar link para recebimento online
  - [ ] **Listar links de pagamentos** - Recuperar links criados
  - [ ] **Atualizar link de pagamentos** - Modificar configurações do link
  - [ ] **Recuperar link específico** - Detalhes de um link de pagamento
  - [ ] **Deletar link de pagamentos** - Remover link criado
  - [ ] **Recuperar QR Code do link** - QR Code para compartilhamento

  #### ⏳ Checkout

  - [ ] **Criar novo checkout** - Página de checkout personalizada
  - [ ] **Configurar checkout** - Definir aparência e comportamento
  - [ ] **Recuperar configurações** - Obter configurações do checkout
  - [ ] **Atualizar configurações** - Modificar checkout existente

  #### ⏳ Transferências

  - [ ] **Transferir para conta de outra instituição** - TED/DOC para outros bancos
  - [ ] **Transferir via chave PIX** - Transferência instantânea via PIX
  - [ ] **Listar transferências** - Histórico de transferências realizadas
  - [ ] **Recuperar transferência específica** - Detalhes de uma transferência
  - [ ] **Cancelar transferência** - Cancelar transferência agendada
  - [ ] **Transferir para conta Asaas** - Transferência entre contas Asaas

  #### ⏳ Antecipações

  - [ ] **Recuperar antecipação** - Informações sobre antecipação específica
  - [ ] **Solicitar antecipação** - Antecipar recebíveis disponíveis
  - [ ] **Listar antecipações** - Histórico de antecipações
  - [ ] **Simular antecipação** - Calcular valores de antecipação
  - [ ] **Cancelar antecipação** - Cancelar solicitação pendente

  #### ⏳ Negativações

  - [ ] **Criar negativação** - Registrar negativação de cliente
  - [ ] **Listar negativações** - Recuperar negativações realizadas
  - [ ] **Recuperar negativação específica** - Detalhes de uma negativação
  - [ ] **Cancelar negativação** - Remover negativação ativa
  - [ ] **Consultar situação CPF/CNPJ** - Verificar restrições existentes

  #### ⏳ Pagamento de Contas

  - [ ] **Criar pagamento de conta** - Pagar boletos e contas
  - [ ] **Listar pagamentos de contas** - Histórico de pagamentos
  - [ ] **Recuperar pagamento específico** - Detalhes de um pagamento
  - [ ] **Cancelar pagamento** - Cancelar pagamento agendado
  - [ ] **Consultar código de barras** - Verificar dados do boleto
  - [ ] **Simular pagamento** - Calcular taxas e prazos

  #### ⏳ Recargas de Celular

  - [ ] **Solicitar recarga** - Fazer recarga de celular pré-pago
  - [ ] **Listar recargas** - Histórico de recargas realizadas
  - [ ] **Recuperar recarga específica** - Detalhes de uma recarga
  - [ ] **Consultar operadoras** - Listar operadoras disponíveis
  - [ ] **Consultar valores** - Valores de recarga disponíveis

  #### ⏳ Consulta Serasa

  - [ ] **Realizar consulta Serasa** - Consultar CPF/CNPJ no Serasa
  - [ ] **Listar consultas** - Histórico de consultas realizadas
  - [ ] **Recuperar consulta específica** - Resultado de uma consulta
  - [ ] **Consultar score** - Verificar score de crédito

  #### ⏳ Extrato

  - [ ] **Recuperar extrato** - Extrato financeiro da conta
  - [ ] **Filtrar por período** - Extrato de período específico
  - [ ] **Exportar extrato** - Download do extrato em PDF/Excel
  - [ ] **Extrato detalhado** - Informações completas das transações

  #### ⏳ Informações Financeiras

  - [ ] **Recuperar saldo da conta** - Saldo atual e disponível
  - [ ] **Obter informações financeiras** - Dados financeiros consolidados
  - [ ] **Estatísticas de faturamento** - Métricas de recebimento
  - [ ] **Previsão de recebimentos** - Valores a receber por período

  #### ⏳ Informações da Conta

  - [ ] **Recuperar dados comerciais** - Informações da empresa
  - [ ] **Atualizar informações da conta** - Modificar dados cadastrais
  - [ ] **Configurar personalização** - White label e customizações
  - [ ] **Recuperar configurações** - Configurações atuais da conta
  - [ ] **Upload de logo** - Personalizar logotipo da conta

  #### ⏳ Notas Fiscais

  - [ ] **Agendar nota fiscal** - Programar emissão de NF
  - [ ] **Listar notas fiscais** - Histórico de notas emitidas
  - [ ] **Recuperar nota específica** - Detalhes de uma nota fiscal
  - [ ] **Cancelar nota fiscal** - Cancelar nota já emitida
  - [ ] **Download de XML** - Baixar arquivo XML da nota
  - [ ] **Enviar por email** - Enviar nota fiscal por email

  #### ⏳ Informações Fiscais

  - [ ] **Listar configurações municipais** - Configurações fiscais por cidade
  - [ ] **Configurar informações fiscais** - Definir dados para emissão de NF
  - [ ] **Atualizar configurações** - Modificar configurações fiscais
  - [ ] **Consultar alíquotas** - Verificar alíquotas municipais

  #### ⏳ Webhooks

  - [ ] **Criar novo webhook** - Configurar notificação via HTTP
  - [ ] **Listar webhooks** - Recuperar webhooks configurados
  - [ ] **Atualizar webhook** - Modificar configurações de webhook
  - [ ] **Deletar webhook** - Remover webhook configurado
  - [ ] **Testar webhook** - Enviar evento de teste
  - [ ] **Reenviar evento** - Reprocessar evento específico
  - [ ] **Listar eventos** - Histórico de eventos enviados

  #### ⏳ Subcontas

  - [ ] **Criar subconta** - Criar conta filha
  - [ ] **Listar subcontas** - Recuperar subcontas criadas
  - [ ] **Configurar subconta** - Definir permissões e limites
  - [ ] **Atualizar subconta** - Modificar configurações
  - [ ] **Desativar subconta** - Suspender acesso da subconta
  - [ ] **Transferir entre subcontas** - Movimentar valores

  #### ⏳ Documentos White Label

  - [ ] **Verificar documentos pendentes** - Documentos aguardando aprovação
  - [ ] **Enviar documentos** - Upload de documentos para análise
  - [ ] **Consultar status** - Situação da análise de documentos
  - [ ] **Reenviar documentos** - Submeter novamente após rejeição

  #### ⏳ Chargeback

  - [ ] **Criar disputa de chargeback** - Contestar chargeback recebido
  - [ ] **Listar chargebacks** - Histórico de chargebacks
  - [ ] **Recuperar chargeback específico** - Detalhes de uma disputa
  - [ ] **Anexar documentos** - Adicionar evidências à disputa
  - [ ] **Acompanhar processo** - Status da contestação

  #### ⏳ Cidades e Localização

  - [ ] **Listar estados** - Estados brasileiros disponíveis
  - [ ] **Listar cidades por estado** - Cidades de um estado específico
  - [ ] **Consultar CEP** - Buscar endereço por CEP
  - [ ] **Validar endereço** - Verificar validade de endereço

  #### ⏳ Relatórios e Analytics

  - [ ] **Relatório de vendas** - Análise de faturamento por período
  - [ ] **Relatório de inadimplência** - Cobranças em atraso
  - [ ] **Métricas de conversão** - Taxa de conversão de pagamentos
  - [ ] **Dashboard financeiro** - Visão geral dos indicadores

  ## Credenciais

  Para usar este nó, você precisa se autenticar com o Asaas. Você deve incluir os pré-requisitos (como criar uma conta no serviço), métodos de autenticação disponíveis e como configurá-los.

  ### Pré-requisitos

  1. Crie uma conta no [Asaas](https://asaas.com) ou no [Sandbox do Asaas](https://sandbox.asaas.com) para testes
  2. Gere sua chave de API no painel do Asaas

  ### Configuração de Autenticação

  1. No n8n, vá para **Credenciais** > **Criar Nova Credencial**
  2. Selecione **Asaas API**
  3. Configure os seguintes campos:
     - **Chave de API**: Sua chave de API do Asaas
     - **Ambiente**: Escolha entre Produção ou Sandbox
  4. Teste a conexão e salve

  ## Compatibilidade

  - **Versão mínima do n8n**: 1.0.0
  - **Versões testadas**: 1.0.0+
  - **Node.js**: >=20.15

  ## Uso

  Este nó permite integrar facilmente o Asaas aos seus fluxos de trabalho n8n. Comece criando clientes e depois avance para criação de cobranças e outras operações conforme suas necessidades.

  Para usuários iniciantes no n8n, consulte a documentação [Experimente](https://docs.n8n.io/try-it-out/) para começar.

  ## Recursos

  - [Documentação dos nós da comunidade n8n](https://docs.n8n.io/integrations/#community-nodes)
  - [Documentação da API do Asaas](https://docs.asaas.com/docs)
  - [Referência da API do Asaas](https://docs.asaas.com/reference)
  - [Portal de desenvolvedores Asaas](https://asaas.com/developers)
  - [Comunidade Discord Asaas](https://discord.gg/invite/X2kgZm69HV)

  ## Licença

  [MIT](LICENSE.md)

ai_documentation_summary:
  {"purpose":"A community n8n node for integrating with the Asaas Brazilian payment platform to manage customers, payments, subscriptions, and other financial operations.","capabilities":["List and create customers","Retrieve, update, and delete customers","Create and manage payments (invoices)","Process credit card payments","Generate QR Code for PIX","Manage recurring subscriptions","Handle payment splits","Manage escrow accounts","Upload and manage invoice documents","Configure notifications"],"authentication":"API key required (implied by standard Asaas integration pattern, not explicitly detailed in README)","commonUseCases":["Automating invoice creation and payment collection","Managing customer billing cycles","Processing recurring subscription payments","Splitting payments among multiple recipients","Handling PIX and credit card transactions"],"limitations":["Many payment-related operations are not yet implemented (indicated by unchecked checkboxes in README)","Documentation is incomplete (README truncated)"],"relatedNodes":["n8n-nodes-base.httpRequest","n8n-nodes-base.code"]}


node_type: @bitovi/n8n-nodes-markitdown.markitdown
package_name: @bitovi/n8n-nodes-markitdown
display_name: markitdown
description: n8n node to process files with Markitdown
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-markitdown.git
npm_package_name: @bitovi/n8n-nodes-markitdown
npm_version: 0.1.10
community_fetched_at: 2026-05-02T08:43:03.215Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # @bitovi/n8n-nodes-markitdown

  This is an n8n community node. It lets you use Microsoft's Markitdown in your n8n workflows.

  Microsoft's [Markitdown](https://github.com/microsoft/markitdown) is a powerful utility for converting various document formats (PDF, Word, PowerPoint, Excel, images, audio, and more) into clean, structured Markdown text. This makes it easy to extract and process content from different file types in your automation workflows.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  
  [Version history](#version-history)

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  #### Requirements

  - A self-hosted n8n instance.
     - n8n Cloud [does not support nodes with external dependencies](https://community.n8n.io/t/custom-node-approval/118559?utm_source=chatgpt.com)
  - Make sure you have [Markitdown](https://github.com/bitovi/n8n-nodes-markitdown) installed
     2. Simply update your own Dockerfile with the delcarations below
     1. You may use our [custom image](https://hub.docker.com/r/bitovi/n8n-nodes-markitdown)
  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-markitdown`

  ### Option 1 (Recommended) - Use our pre-built Docker image

  ```dockerfile
  # Use our custom image
  FROM bitovi/n8n-nodes-markitdown:latest

  # Optional, put your customization here
  ...
  ```

  ### Option 2 - Add to your existing Dockerfile
  ```dockerfile
  FROM n8nio/n8n:latest

  # Switch to the root user for installations
  USER root
  RUN npm install -g pnpm

  # === Python Dependencies for Alpine ===
  # This uses Alpine's 'apk' package manager.
  # 1. Create a temporary virtual package '.build-deps' with all build dependencies.
  # 2. Use pip to install markitdown globally, adding '--break-system-packages' to handle PEP 668.
  # 3. Ensure Python runtime packages remain installed.
  # 4. Remove only the build dependencies to keep the image smaller.
  RUN apk add --no-cache --virtual .build-deps git build-base python3-dev py3-pip && \
      apk add --no-cache python3 && \
      pip install markitdown --break-system-packages && \
      apk del .build-deps

  # Ensure the Python scripts directory is in PATH for all users
  ENV PATH="/usr/local/bin:$PATH"

  # Switch back to the non-privileged 'node' user for security
  USER node

  # Set the working directory to n8n's default
  WORKDIR /home/node/.n8n/nodes

  # Install the n8n Markitdown nodes package
  RUN npm install @bitovi/n8n-nodes-markitdown@latest --only=prod

  # Set the main working directory back to n8n's default
  WORKDIR /home/node
  ```

  ## Operations

  This node provides a single operation:

  **Convert to Markdown**: Takes any supported file format and converts it to clean, structured Markdown text.

  **Input Parameters:**
  - **Input Binary Field**: The name of the binary property containing the file to process (default: "data")

  **Output:**
  - **data**: The converted Markdown content as a string in the JSON output
  - **binary**: Empty binary object (the output is provided as text in the JSON data)

  ## Compatibility

  - **Minimum n8n version**: 1.0.0
  - **Node.js version**: >=18.10
  - **Python version**: 3.7+ (required for markitdown)
  - **Tested with**: n8n 1.14.1+

  This node requires Python and the markitdown package to be installed in your n8n environment. See the installation instructions above for proper setup.

  ## Usage

  ### Basic Workflow Setup

  1. **File Input**: Connect a node that provides binary file data (like "Read Binary File", "HTTP Request", or "Google Drive" nodes)
  2. **Markitdown Node**: Add the Markitdown node to your workflow
  3. **Configure**: Set the "Input Binary Field" parameter to match the binary property name from your input node (usually "data")
  4. **Output**: The converted Markdown will be available in the `data` field of the output JSON

  ### Example Use Cases

  - **Document Processing**: Convert Word documents, PDFs, or PowerPoint presentations to Markdown for further text processing
  - **Content Extraction**: Extract text content from images using OCR capabilities
  - **Data Pipeline**: Batch convert multiple documents as part of a larger data processing workflow
  - **Content Management**: Convert various document formats to Markdown for publishing or archival systems

  ### Tips

  - The node processes files by creating temporary files, so ensure your n8n instance has sufficient disk space
  - Large files may take longer to process depending on the complexity and type of document
  - If processing fails, check that the markitdown command is properly installed and accessible in your environment

  ### How to find the node

  You can search "markitdown" in the n8n node search bar. The node will appear with the Microsoft logo.

  ![Markitdown Node](markitdown.png)

  ## File Types Supported

  MarkItDown supports a wide variety of file formats:

  - **PDF**: Extract text and structure from PDF documents
  - **Microsoft Office**: PowerPoint (reading in top-to-bottom, left-to-right order), Word, Excel
  - **Images**: EXIF metadata extraction and OCR text recognition
  - **Audio**: EXIF metadata and speech transcription
  - **Web**: HTML pages and content
  - **Text-based formats**: CSV, JSON, XML
  - **Archives**: ZIP files (iterates over contents)
  - **Online content**: YouTube URLs
  - **And more!**

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Microsoft Markitdown GitHub repository](https://github.com/microsoft/markitdown)
  - [Bitovi's n8n-nodes-markitdown repository](https://github.com/bitovi/n8n-nodes-markitdown)
  - [Bitovi Docker Hub image](https://hub.docker.com/r/bitovi/n8n-nodes-markitdown)


  ## Need Help or Have Questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Converts various file formats including PDFs, Office documents, images, and audio into clean, structured Markdown text using Microsoft's Markitdown utility.","capabilities":["Convert PDF documents to Markdown","Extract text from Microsoft Word, PowerPoint, and Excel files","Perform OCR on images to extract text","Transcribe audio files and extract metadata","Parse HTML, CSV, JSON, and XML files","Extract content from ZIP archives","Fetch and convert content from YouTube URLs"],"authentication":"None","commonUseCases":["Document processing pipelines for content extraction","Converting legacy documents to Markdown for CMS integration","Batch processing of mixed-format files in data workflows","Extracting text from scanned images or PDFs for analysis"],"limitations":["Requires Python runtime and markitdown package to be installed in the n8n environment","Not supported on n8n Cloud due to external dependencies","Requires sufficient disk space for temporary file creation during processing","Large or complex files may experience longer processing times"],"relatedNodes":["Read Binary File","HTTP Request","Google Drive","Dropbox"]}


node_type: n8n-nodes-weld.weld
package_name: n8n-nodes-weld
display_name: weld
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: GitHub Actions
author_github_url: git+https://github.com/useweld/n8n-nodes-weld.git
npm_package_name: n8n-nodes-weld
npm_version: 1.1.4
community_fetched_at: 2026-05-02T08:43:03.216Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  n8n community node for Weld — web scraping across LinkedIn, Instagram, TikTok, Twitter/X, YouTube & Facebook

npm_readme:
  # n8n-nodes-weld

  n8n community node for [Weld](https://www.useweld.app) — web scraping across LinkedIn, Instagram, TikTok, Twitter/X, YouTube, Facebook, Indeed, Glassdoor, Yelp, GitHub & Crunchbase.

  ## Installation

  In your n8n instance, go to **Settings → Community Nodes → Install** and enter:

  ```
  n8n-nodes-weld
  ```

  ## Credentials

  1. Log in to [Weld](https://www.useweld.app)
  2. Go to **Settings → API Keys** and create a new key
  3. In n8n, add a **Weld API** credential with your API key and base URL

  ## Nodes

  ### Per-Platform Scraper Nodes

  Each scraper has its own dedicated node with tailored input fields and AI agent descriptions:

  | Node | Scraper | Input | Cost |
  | ---- | ------- | ----- | ---- |
  | **Weld LinkedIn Profiles** | `linkedin-profiles` | Profile URLs | 5 cr |
  | **Weld LinkedIn Companies** | `linkedin-companies` | Company URLs | 5 cr |
  | **Weld LinkedIn Posts** | `linkedin-posts` | Profile/Company/Post URLs | 3 cr |
  | **Weld Instagram Profiles** | `instagram-profiles` | Profile URLs | 4 cr |
  | **Weld Instagram Posts** | `instagram-posts` | Post URLs | 3 cr |
  | **Weld Instagram Comments** | `instagram-comments` | Post URLs | 2 cr |
  | **Weld TikTok Profiles** | `tiktok-profiles` | Profile URLs | 4 cr |
  | **Weld TikTok Videos** | `tiktok-posts` | Video URLs | 3 cr |
  | **Weld Twitter/X Profiles** | `twitter-profiles` | Profile URLs | 4 cr |
  | **Weld Twitter/X Posts** | `twitter-posts` | Post URLs | 3 cr |
  | **Weld YouTube Channels** | `youtube-channels` | Channel URLs | 4 cr |
  | **Weld YouTube Comments** | `youtube-comments` | Video URLs | 2 cr |
  | **Weld Facebook Profiles** | `facebook-profiles` | Profile URLs | 4 cr |
  | **Weld Facebook Groups** | `facebook-groups` | Group URLs | 3 cr |
  | **Weld Indeed Jobs** | `indeed-jobs` | Job listing URLs | 5 cr |
  | **Weld Indeed Companies** | `indeed-companies` | Company URLs | 5 cr |
  | **Weld Glassdoor Companies** | `glassdoor-companies` | Company URLs | 5 cr |
  | **Weld Glassdoor Reviews** | `glassdoor-reviews` | Review URLs | 5 cr |
  | **Weld Glassdoor Jobs** | `glassdoor-jobs` | Job listing URLs | 5 cr |
  | **Weld Yelp Businesses** | `yelp-businesses` | Business URLs | 5 cr |
  | **Weld Yelp Reviews** | `yelp-reviews` | Review URLs | 5 cr |
  | **Weld GitHub Repositories** | `github-repositories` | Repository URLs | 5 cr |
  | **Weld Crunchbase Companies** | `crunchbase-companies` | Company URLs | 5 cr |

  Each scraper node supports three operations:

  | Operation | Description |
  | --------- | ----------- |
  | **Create** | Start a new scrape job with URLs and optionally wait for completion |
  | **Get** | Get job status and details by ID |
  | **Get Results** | Retrieve scraped data from a completed job |

  ### Weld Jobs (Management Node)

  The **Weld Jobs** node handles cross-cutting job management and credits:

  | Resource | Operation | Description |
  | -------- | --------- | ----------- |
  | Job | **Get** | Get job status and details by ID |
  | Job | **Get Results** | Retrieve scraped data from a completed job |
  | Job | **List** | List recent scrape jobs with optional status filter |
  | Job | **Cancel** | Cancel a pending/processing job and refund credits |
  | Credits | **Get Balance** | Check your current credit balance |
  | Credits | **Get Transactions** | View your credit transaction history |

  ## Features

  - **AI Agent compatible** — each scraper node has a focused `usableAsTool` description for accurate tool selection
  - **Per-platform icons** — color-coded icons make it easy to identify scrapers on the canvas
  - **Return All toggle** — standard n8n pagination pattern for Get Results and List operations
  - **Exponential backoff** — automatic retry on transient 5xx, 429, and network errors during polling
  - **Data provenance** — every output item includes `pairedItem` for n8n's data tracking
  - **Dark mode** — icons adapt to n8n's light and dark themes

  ## Wait for Completion

  When creating a job with "Wait for Completion" enabled, the node polls until the job finishes and outputs each scraped record as a separate n8n item — ready to pipe into the next node in your workflow.

  For long-running jobs, prefer using the **Weld Jobs** node's Get/Get Results operations on a schedule to avoid holding an n8n worker.

ai_documentation_summary:
  {"purpose":"A community n8n node that enables web scraping across multiple platforms including LinkedIn, Instagram, TikTok, Twitter/X, YouTube, Facebook, Indeed, Glassdoor, Yelp, GitHub, and Crunchbase.","capabilities":["Scrape LinkedIn profiles, companies, and posts","Scrape Instagram profiles, posts, and comments","Scrape TikTok profiles and videos","Scrape Twitter/X profiles and posts","Scrape YouTube channels and comments","Scrape Facebook profiles and groups","Scrape Indeed job listings and companies","Scrape Glassdoor companies, reviews, and jobs","Scrape Yelp businesses and reviews","Scrape GitHub repositories"],"authentication":"API key required (Weld API key and base URL)","commonUseCases":["Gathering competitor data from social media platforms","Collecting job listings for recruitment automation","Monitoring company reviews and ratings","Extracting public profile information for lead generation","Tracking GitHub repository activity"],"limitations":["Requires paid credits for each scraping operation (costs vary by platform and data type)","Long-running jobs should be managed via the Weld Jobs node to avoid blocking n8n workers","Limited to public data accessible through Weld's scraping service","No built-in support for dynamic content or JavaScript-heavy sites beyond Weld's capabilities"],"relatedNodes":["n8n-nodes-base.httpRequest","n8n-nodes-base.code","n8n-nodes-base.waitUntil","n8n-nodes-base.splitInBatches"]}


node_type: n8n-nodes-convert-image.convertimage
package_name: n8n-nodes-convert-image
display_name: convertimage
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: mason276752
author_github_url: git+https://github.com/mason276752/n8n-nodes-convert-image.git
npm_package_name: n8n-nodes-convert-image
npm_version: 0.0.2
community_fetched_at: 2026-05-02T08:43:03.221Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  n8n node for converting image formats between JPG, PNG, BMP, TIFF, etc. Supports both base64 and file inputs/outputs

npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-convert-image

  Custom n8n node for converting images to different formats (JPG, PNG, BMP, TIFF, GIF).  
  Handles both base64 and file inputs, outputs base64 or file data, and allows setting image quality.

  ## Features

  - Convert images between common formats  
  - Input as file or base64  
  - Output as file or base64  
  - Adjustable quality for JPG output  

  ## Prerequisites

  - n8n (version 1.0.0 or later)
  - Node.js 16 or newer

  ## Installation

  ```bash
  npm install n8n-nodes-convert-image
  ```

  ## Usage

  1. Provide the input file or base64 data.
  2. Select the target format and output type.
  3. For JPEG, define the desired quality (0-100).
  4. The node returns the converted image in the chosen format.

  ## Example

  1. Add the “Image Format Converter” node to your workflow.
  2. Pass your image as base64 or file data.
  3. Set the output format to “PNG”, for example.
  4. Define output as “file” or “base64”.
  5. The result will be a converted image in the desired format.

  ## License

  [MIT](LICENSE.md)

ai_documentation_summary:
  {"purpose":"Converts images between common formats (JPG, PNG, BMP, TIFF, GIF) supporting both file and base64 inputs/outputs with adjustable quality settings.","capabilities":["Convert images to JPG, PNG, BMP, TIFF, GIF formats","Accept file inputs","Accept base64 inputs","Output as file data","Output as base64 data","Adjust image quality for JPG output (0-100)"],"authentication":"None","commonUseCases":["Converting uploaded image files to web-friendly formats like JPG or PNG","Transforming base64-encoded images within workflow data","Batch processing image format conversions in automated workflows"],"limitations":["Requires n8n version 1.0.0 or later","Requires Node.js 16 or newer for installation","Quality adjustment is only available for JPG output"],"relatedNodes":["n8n-nodes-base.code","n8n-nodes-base.httpRequest"]}


node_type: n8n-nodes-evolution-api-v2.evolutionapiv2
package_name: n8n-nodes-evolution-api-v2
display_name: evolutionapiv2
description: N8N Community Node for Evolution API v2
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: jfcardososantos
author_github_url: git+https://github.com/jfcardososantos/n8n-nodes-evolution-api-v2.git
npm_package_name: n8n-nodes-evolution-api-v2
npm_version: 1.1.11
community_fetched_at: 2026-05-02T08:43:03.227Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # N8N Evolution API v2 Community Node

  Este é um community node para o N8N que permite integração com a Evolution API v2 para WhatsApp.

  ## 🚀 Funcionalidades

  - **Gerenciamento de Instâncias**: Criar, conectar, desconectar e gerenciar instâncias do WhatsApp
  - **Envio de Mensagens**: Enviar mensagens de texto e mídia
  - **Gerenciamento de Grupos**: Criar grupos e buscar membros
  - **Verificação de Chat**: Verificar se um número é WhatsApp
  - **Webhooks**: Configurar webhooks para eventos
  - **Integrações**: Suporte para integração com Chatwoot

  ## 📦 Instalação

  ### Via NPM (Recomendado)

  ```bash
  npm install n8n-nodes-evolution-api-v2
  ```

  ### Via N8N Community Nodes

  1. Vá para **Settings** > **Community Nodes**
  2. Clique em **Install**
  3. Digite: `n8n-nodes-evolution-api-v2`
  4. Clique em **Install**

  ## 🔧 Configuração

  ### Credenciais

  1. Crie uma nova credencial do tipo **Evolution API**
  2. Configure:
     - **Server URL**: URL do seu servidor Evolution API
     - **API Token**: Token de autenticação da API

  ### Recursos Disponíveis

  #### Instância
  - **Criar Instância**: Cria uma nova instância do WhatsApp
  - **Buscar Instâncias**: Lista todas as instâncias disponíveis
  - **Conectar Instância**: Conecta a uma instância específica
  - **Reiniciar Instância**: Reinicia uma instância
  - **Estado da Conexão**: Verifica o estado da conexão
  - **Logout**: Faz logout de uma instância
  - **Deletar Instância**: Remove uma instância
  - **Definir Presença**: Define o status de presença

  #### Mensagem
  - **Enviar Texto**: Envia uma mensagem de texto
  - **Enviar Imagem**: Envia uma imagem com legenda

  #### Grupo
  - **Criar Grupo**: Cria um novo grupo
  - **Buscar Membros**: Lista membros de um grupo

  #### Chat
  - **Verificar WhatsApp**: Verifica se um número é WhatsApp

  #### Evento
  - **Webhook**: Configura webhooks para eventos

  #### Integração
  - **Chatwoot**: Configura integração com Chatwoot

  ## 🛠️ Desenvolvimento

  ### Pré-requisitos

  - Node.js 18+
  - npm ou yarn

  ### Instalação Local

  ```bash
  git clone https://github.com/jfcardososantos/n8n-nodes-evolution-api-v2.git
  cd n8n-nodes-evolution-api-v2
  npm install
  ```

  ### Scripts Disponíveis

  ```bash
  # Build do projeto
  npm run build

  # Desenvolvimento com watch
  npm run dev

  # Linting
  npm run lint

  # Formatação
  npm run format

  # Release (patch, minor, major)
  npm run release:patch
  npm run release:minor
  npm run release:major
  ```

  ## 📝 Exemplos de Uso

  ### Enviar Mensagem de Texto

  ```javascript
  // Configuração do node
  {
    "resource": "message",
    "operation": "sendText",
    "instanceName": "minha-instancia",
    "number": "5511999999999",
    "messageText": "Olá! Esta é uma mensagem de teste."
  }
  ```

  ### Criar Grupo

  ```javascript
  // Configuração do node
  {
    "resource": "group",
    "operation": "createGroup",
    "instanceName": "minha-instancia",
    "subject": "Grupo de Teste",
    "participants": ["5511999999999", "5511888888888"]
  }
  ```

  ## 🤝 Contribuição

  1. Faça um fork do projeto
  2. Crie uma branch para sua feature (`git checkout -b feature/AmazingFeature`)
  3. Commit suas mudanças (`git commit -m 'Add some AmazingFeature'`)
  4. Push para a branch (`git push origin feature/AmazingFeature`)
  5. Abra um Pull Request

  ## 📄 Licença

  Este projeto está licenciado sob a Licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.

  ## 👨‍💻 Autor

  **JF Cardoso Santos**
  - Email: jfcardososantos@gmail.com
  - GitHub: [@jfcardososantos](https://github.com/jfcardososantos)

  ## 🔗 Links

  - [N8N](https://n8n.io/)
  - [Evolution API](https://doc.evolution-api.com/)
  - [NPM Package](https://www.npmjs.com/package/n8n-nodes-evolution-api-v2)

  ## 📈 Versionamento

  Este projeto usa [SemVer](http://semver.org/) para versionamento. Para ver as versões disponíveis, veja as [tags neste repositório](https://github.com/jfcardososantos/n8n-nodes-evolution-api-v2/tags).

  ## 🆘 Suporte

  Se você encontrar algum problema ou tiver dúvidas, por favor:

  1. Verifique a [documentação da Evolution API](https://doc.evolution-api.com/)
  2. Abra uma [issue no GitHub](https://github.com/jfcardososantos/n8n-nodes-evolution-api-v2/issues)
  3. Entre em contato via email: jfcardososantos@gmail.com 

ai_documentation_summary:
  {"purpose":"Provides integration with Evolution API v2 for WhatsApp, enabling instance management, messaging, group operations, and event handling within n8n workflows.","capabilities":["Create, connect, disconnect, and delete WhatsApp instances","Send text messages","Send images with captions","Create WhatsApp groups","List group members","Verify if a phone number is a WhatsApp number","Configure webhooks for events","Integrate with Chatwoot","Set presence status"],"authentication":"API key required (Server URL and API Token)","commonUseCases":["Automated WhatsApp customer support","Sending notifications via WhatsApp","Managing WhatsApp groups programmatically","Two-factor authentication via WhatsApp","Integrating WhatsApp with Chatwoot support platform"],"limitations":["Requires a self-hosted Evolution API v2 server to function","Dependent on the availability and configuration of the external Evolution API service"],"relatedNodes":[]}


node_type: @inite/n8n-nodes-instagram-private-api.instagramprivateapi
package_name: @inite/n8n-nodes-instagram-private-api
display_name: instagramprivateapi
description: n8n node for Instagram Private API with 2FA support
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: mikefluff
author_github_url: git+https://github.com/inite-ai/n8n-nodes-instagram-private-api.git
npm_package_name: @inite/n8n-nodes-instagram-private-api
npm_version: 1.0.43
community_fetched_at: 2026-05-02T08:43:03.233Z
ai_summary_generated_at: 2026-05-02 09:02:16
npm_readme:
  ��# n8n-nodes-instagram-private-api
  
  
  
  This is an n8n community node for interacting with Instagram using the Instagram Private API. It provides comprehensive functionality for posting content, managing direct messages, handling comments, and monitoring Instagram activities.
  
  
  
  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.
  
  
  
  [Installation](#installation)  
  
  [Setup](#setup)  
  
  [Operations](#operations)  
  
  [Triggers](#triggers)  
  
  [Examples](#examples)  
  
  [Resources](#resources)  
  
  [Version history](#version-history)
  
  
  
  ## Installation
  
  
  
  Follow these steps to install the node:
  
  
  
  1. Open your n8n instance
  
  2. Go to **Settings** > **Community Nodes**
  
  3. Select **Install**
  
  4. Enter `@inite/n8n-nodes-instagram-private-api`
  
  5. Click **Install**
  
  
  
  Alternatively, you can install it using npm:
  
  
  
  ```bash
  
  npm install @inite/n8n-nodes-instagram-private-api
  
  ```
  
  
  
  ## Setup
  
  
  
  1. Create new credentials in n8n:
  
  
  
     - Go to **Credentials** > **New**
  
     - Search for "Instagram Private API"
  
     - Enter your Instagram username and password
  
  
  
  2. Important Security Notes:
  
     - Store your credentials securely
  
     - Use a dedicated Instagram account for automation
  
     - Follow Instagram's rate limits and usage guidelines
  
     - Consider using Instagram's official API for business accounts
  
  
  
  ## Features
  
  
  
  - Full Instagram Private API support
  
  - Two-Factor Authentication (2FA) support
  
  - Session storage for faster subsequent logins
  
  - Proxy support for enhanced security
  
  - Comprehensive error handling
  
  
  
  ## Operations
  
  
  
  ### Instagram Private API Node
  
  
  
  #### Content Publishing
  
  
  
  - **Post**: Post images or videos to your feed
  
  
  
    ```json
  
    {
  
      "operation": "post",
  
      "contentType": "image",
  
      "media": "https://example.com/image.jpg",
  
      "caption": "My awesome post!"
  
    }
  
    ```
  
  
  
  - **Post Story**: Share stories
  
  
  
    ```json
  
    {
  
      "operation": "postStory",
  
      "contentType": "video",
  
      "media": "https://example.com/video.mp4",
  
      "coverImage": "https://example.com/cover.jpg"
  
    }
  
    ```
  
  
  
  - **Post Reel**: Create engaging reels
  
    ```json
  
    {
  
      "operation": "postReel",
  
      "media": "https://example.com/reel.mp4",
  
      "caption": "Check out my new reel!",
  
      "coverImage": "https://example.com/cover.jpg"
  
    }
  
    ```
  
  
  
  #### Engagement
  
  
  
  - **Comment**: Interact with posts
  
  
  
    ```json
  
    {
  
      "operation": "comment",
  
      "mediaId": "12345",
  
      "commentText": "Great post!"
  
    }
  
    ```
  
  
  
  - **Send DM**: Message users directly
  
    ```json
  
    {
  
      "operation": "sendDM",
  
      "userId": "67890",
  
      "messageText": "Hello there!"
  
    }
  
    ```
  
  
  
  #### Information Retrieval
  
  
  
  - **Get User Info**: Fetch user details
  
  - **Get User Feed**: Access user's posts
  
  - **Get User Stories**: View user's stories
  
  
  
  ## Triggers
  
  
  
  ### Instagram Trigger Node
  
  
  
  Monitor Instagram activities in real-time:
  
  
  
  #### New DM Trigger
  
  
  
  ```json
  
  {
  
    "event": "newDM",
  
    "pollInterval": 60,
  
    "output": {
  
      "threadId": "123",
  
      "userId": "456",
  
      "username": "user",
  
      "message": "Hello!",
  
      "timestamp": 1234567890
  
    }
  
  }
  
  ```
  
  
  
  #### New Comment Trigger
  
  
  
  ```json
  
  {
  
    "event": "newComment",
  
    "pollInterval": 60,
  
    "output": {
  
      "mediaId": "789",
  
      "userId": "012",
  
      "username": "commenter",
  
      "text": "Nice!",
  
      "timestamp": 1234567890
  
    }
  
  }
  
  ```
  
  
  
  ## Examples
  
  
  
  ### Automated Story Sharing
  
  
  
  ```javascript
  
  // When a new image is uploaded to cloud storage
  
  // Post it as an Instagram story
  
  {
  
    "operation": "postStory",
  
    "contentType": "image",
  
    "media": "{{$node.trigger.json.imageUrl}}"
  
  }
  
  ```
  
  
  
  ### Comment Monitoring and Response
  
  
  
  ```javascript
  
  // When a new comment is received
  
  // Send a thank you DM to the commenter
  
  {
  
    "operation": "sendDM",
  
    "userId": "{{$node.instagramTrigger.json.userId}}",
  
    "messageText": "Thanks for your comment!"
  
  }
  
  ```
  
  
  
  ## Resources
  
  
  
  - [n8n Community Nodes Documentation](https://docs.n8n.io/integrations/community-nodes/)
  
  - [Instagram Private API Documentation](https://github.com/dilame/instagram-private-api)
  
  - [Instagram Rate Limits](https://developers.facebook.com/docs/instagram-api/reference/rate-limits)
  
  - [Best Practices for Instagram Automation](https://developers.facebook.com/docs/instagram-api/guides/content-publishing)
  
  
  
  ## Version history
  
  
  
  ### 1.0.0 (2024-04-07)
  
  
  
  - Initial release with comprehensive Instagram functionality
  
  - Content publishing (posts, stories, reels)
  
  - Direct messaging and commenting capabilities
  
  - User information and feed retrieval
  
  - Real-time triggers for DMs and comments
  
  - Extensive error handling and rate limit management
  
  
  
  ## License
  
  
  
  [MIT](LICENSE.md)
  
  

ai_documentation_summary:
  {"purpose":"This n8n community node enables interaction with Instagram using the Private API, supporting content publishing, engagement management, and real-time activity monitoring with 2FA support.","capabilities":["Post images and videos to feed","Post Stories","Post Reels","Comment on posts","Send Direct Messages (DMs)","Get user information","Get user feed","Get user stories","Monitor new DMs in real-time","Two-Factor Authentication (2FA) handling"],"authentication":"API key required (Instagram username and password stored in n8n credentials)","commonUseCases":["Automated social media posting","Engagement automation (comments and DMs)","Real-time DM monitoring","User profile and content retrieval"],"limitations":["Requires dedicated Instagram account for automation","Subject to Instagram's rate limits and usage guidelines","Relies on Private API which may be unstable or change without notice","Not recommended for business accounts (official API suggested instead)"],"relatedNodes":[]}


node_type: @bitovi/n8n-nodes-confluence.confluence
package_name: @bitovi/n8n-nodes-confluence
display_name: confluence
description: N8N node to connect to Confluence
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-confluence.git
npm_package_name: @bitovi/n8n-nodes-confluence
npm_version: 0.1.6
community_fetched_at: 2026-05-02T08:43:03.234Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  ~# @bitovi/n8n-nodes-confluence

  This is an n8n community node. It lets you use Atlassian Confluence in your n8n workflows.

  Confluence is a collaborative workspace and documentation platform by Atlassian, used for creating, organizing, and sharing content with your team.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  
  [Version history](#version-history)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-confluence`

  ## Operations

  - **Get Spaces**: List Confluence spaces.
  - **Get Pages in Space**: List pages within a space.
  - **Custom API call**: Use Confluence's REST API.

  ## Credentials

  This node requires authentication with Atlassian Confluence.

  - **Domain**: Your Atlassian site URL (e.g., `https://your-domain.atlassian.net`).
  - **User Name**: Your Atlassian account email.
  - **API Key**: Generate an API token from your Atlassian account ([API tokens](https://id.atlassian.com/manage-profile/security/api-tokens)).

  ## Compatibility

  - Node version: 1
  - Tested with latest n8n version (please update as needed)

  ## Usage

  This node provides extensive filtering and customization options for retrieving Confluence data:

  ### Basic Operations
  - **Get Spaces**: Retrieve all spaces or filter by specific space names using comma-separated values
  - **Get Pages in Space**: List pages within a specific space using the Space ID

  ### Filtering Options
  - **Title**: Filter pages by exact title match
  - **Status**: Choose page status:
    - `current` (default) - Active pages
    - `archived` - Archived pages
    - `deleted` - Deleted pages
    - `trashed` - Trashed pages

  ### Content Format Options
  - **Body Format**: Control how page content is returned:
    - `storage` (default) - Confluence's internal storage format
    - `atlas_doc_format` - Atlas document format for modern editing

  ### Organization Options
  - **Depth**: Control the hierarchy level of pages returned:
    - `all` (default) - All pages regardless of hierarchy level
    - `root` - Only top-level pages

  - **Sort**: Order results by various criteria:
    - `modified-date` (descending, default) - Most recently modified first
    - `created-date` - Creation date (ascending/descending)
    - `title` - Alphabetical by title (ascending/descending)
    - `id` - By page ID (ascending/descending)

  ### Pagination
  - **Return All**: Toggle to get all results or limit the number
  - **Limit**: Set maximum number of results when not returning all (default: 50)
  - Pagination is automatically handled for large result sets

  ## Resources

  * [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  * [Atlassian Confluence REST API documentation](https://developer.atlassian.com/cloud/confluence/rest/)

  ## Version history

  - v1.0.0: Initial release

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)
  ~

ai_documentation_summary:
  {"purpose":"Connects to Atlassian Confluence to retrieve spaces and pages within n8n workflows using REST API operations.","capabilities":["List Confluence spaces","List pages within a specific space","Custom API calls via Confluence REST API","Filter pages by title","Filter pages by status (current, archived, deleted, trashed)","Control content format (storage, atlas_doc_format)","Control page hierarchy depth (all, root)","Sort results by modified-date, created-date, title, or id","Pagination support with limit and return all options"],"authentication":"API Key required (Domain, User Name, API Token)","commonUseCases":["Automated documentation retrieval","Content migration between systems","Team workflow automation with Confluence data","Bulk page status management"],"limitations":["Community node (requires N8N_COMMUNITY_PACKAGES_ENABLED=true)","Requires manual API token generation in Atlassian account","Limited to Confluence REST API functionality"],"relatedNodes":["n8n HTTP Request node","n8n Community Nodes"]}


node_type: @bitovi/n8n-nodes-excel.excel
package_name: @bitovi/n8n-nodes-excel
display_name: excel
description: N8N node to work with Excel files
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-excel.git
npm_package_name: @bitovi/n8n-nodes-excel
npm_version: 0.2.1
community_fetched_at: 2026-05-02T08:43:03.235Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # @bitovi/n8n-nodes-excel

  This repo contains [N8N](https://n8n.io/) node to work with Excel files.

  ## Installation

  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-excel`

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Enables N8N workflows to read, write, and manipulate Excel files directly within the automation environment.","capabilities":["Read Excel files","Write Excel files","Parse Excel data into JSON","Convert JSON data to Excel format"],"authentication":"None","commonUseCases":["Importing spreadsheet data into workflows","Exporting workflow results to Excel reports","Processing and transforming tabular data","Integrating with legacy systems using Excel files"],"limitations":[],"relatedNodes":[]}


node_type: @bitovi/n8n-nodes-freshbooks.freshbooks
package_name: @bitovi/n8n-nodes-freshbooks
display_name: freshbooks
description: N8N node to connect to FreshBooks
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-freshbooks.git
npm_package_name: @bitovi/n8n-nodes-freshbooks
npm_version: 0.1.1
community_fetched_at: 2026-05-02T08:43:03.237Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # @bitovi/n8n-nodes-freshbooks

  This is an n8n community node. It lets you use FreshBooks in your n8n workflows.

  FreshBooks is a cloud-based accounting software designed for small businesses and freelancers, providing tools for invoicing, time tracking, expense management, and financial reporting.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  
  [Version history](#version-history)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-freshbooks`

  ## Operations

  ### Clients

  - **List Clients**: Retrieve all clients from your FreshBooks account

  ### Projects

  - **List Projects**: Get all projects for specified clients

  ### Services

  - **List Services**: Get available services for a specific project

  ### Time Tracking

  - **List Time Entries**: Retrieve time entries from your FreshBooks account
  - **Get Time Entry**: Retrieve a specific time entry by ID
  - **Create Time Entry**: Add a new time entry with client, project, service, note, date, and duration
  - **Update Time Entry**: Modify an existing time entry
  - **Delete Time Entry**: Remove a time entry

  ### User

  - **Get User Info**: Retrieve current user information

  ## Credentials

  This node requires OAuth2 authentication with FreshBooks.

  - **Client ID**: Your FreshBooks OAuth2 client ID from your app registration
  - **Client Secret**: Your FreshBooks OAuth2 client secret from your app registration  
  - **Authorization URL**: `https://my.freshbooks.com/service/auth/oauth/authorize`

  To set up OAuth2 credentials:

  1. Register your application in the FreshBooks Developer Portal
  2. Configure the redirect URI in your FreshBooks app settings
  3. Use the provided Client ID and Client Secret in your n8n credentials

  ## Compatibility

  - Node version: 1
  - Tested with latest n8n version

  ## Usage

  This node provides comprehensive access to FreshBooks functionality for accounting and time tracking:

  ### Time Tracking Operations

  #### Creating Time Entries

  - **Client ID**: Select the client for billing
  - **Project ID**: Associate with specific project
  - **Service ID**: Categorize the type of work performed
  - **Note**: Detailed description of work performed
  - **Date**: When the work was performed
  - **Duration**: Time spent in seconds (default: 28800 = 8 hours)
  - **Is Logged**: Whether the entry is marked as logged (default: true)

  #### Managing Time Entries

  - List all time entries with pagination support
  - Get specific time entries by ID
  - Update existing entries with new information
  - Delete time entries when needed

  ### Filtering and Options

  #### Client Operations

  - Filter by visibility state (active/archived)
  - Sort by various criteria (updated date, created date, etc.)

  #### Project Operations

  - Filter projects by specific client IDs
  - Show only active projects
  - Exclude completed projects from results

  ### Pagination Support

  - **Return All**: Get all results or limit the number returned
  - **Limit**: Set maximum number of results (default: 50)
  - Automatic pagination handling for large datasets

  ### User Information

  - Retrieve current authenticated user details
  - Access business and account information

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [FreshBooks API documentation](https://www.freshbooks.com/api)
  - [FreshBooks Developer Portal](https://www.freshbooks.com/developers)

  ## Version history

  - v0.1.0: Initial release
    - Client, Project, Service, Time Tracking, and User operations
    - Full CRUD support for time entries
    - OAuth2 authentication
    - Pagination support

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Connects n8n workflows to FreshBooks for accounting and time tracking operations, including client management, project tracking, service listing, and time entry CRUD.","capabilities":["List clients with filtering and sorting","List projects for specific clients","List available services for projects","Retrieve current user information","Create time entries with client, project, service, note, date, and duration","Update existing time entries","Delete time entries","Retrieve specific time entries by ID","List time entries with pagination support","Filter clients by visibility state (active/archived)"],"authentication":"OAuth2","commonUseCases":["Automating time tracking for freelancers","Generating invoices from FreshBooks data","Syncing project details between n8n and FreshBooks","Tracking billable hours automatically"],"limitations":["Community node (requires enabling in n8n settings)","Requires FreshBooks OAuth2 app registration before use"],"relatedNodes":["n8n HTTP Request","n8n Webhook","n8n Spreadsheet"]}


node_type: @bitovi/n8n-nodes-google-search.googlesearch
package_name: @bitovi/n8n-nodes-google-search
display_name: googlesearch
description: N8N node to connect to Google Search
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-google-search.git
npm_package_name: @bitovi/n8n-nodes-google-search
npm_version: 0.2.1
community_fetched_at: 2026-05-02T08:43:03.237Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # @bitovi/n8n-nodes-google-search

  This is an n8n community node. It lets you use Google Search in your n8n workflows.

  Google Search is a web search engine that allows you to find information on the internet. This node integrates with Google's Custom Search API to perform programmatic searches.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  Alternatively:

  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-google-search`

  ## Operations

  The Google Search node supports the following operations:

  ### Custom Search

  - **Search Query**: Perform searches using Google's Custom Search API
  - **Return All**: Option to return all results or limit to a specific number
  - **Limit**: Set maximum number of results to return (when Return All is disabled)

  ### Additional Search Parameters

  - **Date Restrict**: Restrict results to a specific time period (past 24 hours, week, month, or year)
  - **Exact Terms**: Search for exact phrases
  - **Exclude Terms**: Exclude specific terms from search results
  - **File Type**: Filter results by file type (e.g., pdf, doc, etc.)
  - **Filter**: Enable/disable duplicate content filter
  - **HQ**: Search for pages that link to a specific URL
  - **Image Color Type**: Filter images by color type (color, gray, black and white, transparent)
  - **Image Dominant Color**: Filter images by dominant color
  - **Image Size**: Filter images by size
  - **Image Type**: Filter by image type (clipart, face, lineart, stock, photo)
  - **Link Site**: Restrict results to pages linking to a specific site
  - **Or Terms**: Search for pages containing any of the specified terms
  - **Related Site**: Find pages related to a specific URL
  - **Rights**: Filter by usage rights
  - **Safe Search Level**: Enable safe search filtering
  - **Search Type**: Specify search type (image search, etc.)
  - **Site Search**: Restrict search to a specific site
  - **Site Search Filter**: Include or exclude results from site search
  - **Sort By**: Sort results by relevance (default) or date

  ## Credentials

  To use this node, you need to authenticate with Google's Custom Search API. You'll need:

  ### Prerequisites

  1. A Google Cloud Platform account
  2. A Google Custom Search Engine set up

  ### Setting up credentials

  1. **Create a Custom Search Engine**:
     - Go to [Google Programmable Search Engine](https://programmablesearchengine.google.com)
     - Create a new search engine
     - Note the Search Engine ID (cx parameter)

  2. **Get API Key**:
     - Go to [Google Cloud Console](https://console.cloud.google.com) or [Programmable Search Engine Guide](https://developers.google.com/custom-search/v1/introduction)
     - Enable the Custom Search API
     - Create an API key
     - Copy the API key

  3. **Configure in n8n**:
     - Search Engine ID: Enter your Custom Search Engine ID
     - API Key: Enter your Google Cloud API key

  ## Compatibility

  - **Minimum n8n version**: Compatible with n8n v0.198.0 and above
  - **Node.js version**: Requires Node.js 18.10 or higher
  - **n8n API version**: Uses n8n nodes API version 1

  This node has been tested with the latest versions of n8n and should work with all current installations.

  ## Usage

  ### Basic Search

  1. Add the Google Search node to your workflow
  2. Configure your credentials (Search Engine ID and API Key)
  3. Enter your search query
  4. Set whether to return all results or limit the number
  5. Execute the workflow

  ### Advanced Search Options

  Use the "Additional Fields" section to:

  - Restrict results to a specific time period (past 24 hours, week, month, etc.)
  - Sort results by date or relevance
  - Filter results by file type, language, or site
  - Search for exact phrases or exclude specific terms
  - Filter images by size, color, or type

  ### Pagination

  The node supports automatic pagination when "Return All" is enabled, allowing you to retrieve large result sets efficiently.

  ### Example Use Cases

  - **Content Research**: Search for articles, papers, or resources on specific topics
  - **Competitor Analysis**: Monitor mentions of your brand or competitors
  - **Lead Generation**: Find contact information or company details
  - **SEO Analysis**: Research keywords and analyze search results
  - **Data Collection**: Gather information from web sources programmatically

  ## Using as an AI Agent Tool

  This node can be used as a tool in n8n's AI Agent workflows, allowing AI assistants to automatically search the web when needed.

  ### Prerequisites

  - n8n version 1.40 or higher (with AI Agent support)
  - Environment variable: `N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true`

  ### Setting the Environment Variable

  **For Docker:**

  ```bash
  docker run -e N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true n8nio/n8n
  ```

  Or in your `docker-compose.yml`:

  ```yaml
  environment:
    - N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true
  ```

  **For npm installation:**

  ```bash
  export N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE=true
  npx n8n start
  ```

  **For Windows (PowerShell):**

  ```powershell
  $env:N8N_COMMUNITY_PACKAGES_ALLOW_TOOL_USAGE="true"
  npx n8n start
  ```

  ### Setup Steps

  1. Set the environment variable as shown above
  2. Install this community node through n8n's Community Nodes settings
  3. Restart n8n if it was already running
  4. In your workflow, add an **AI Agent** node
  5. Click **Add Tool** in the AI Agent configuration
  6. Select **Google Search** from the available tools

  ### How It Works

  - The AI agent will automatically call the Google Search tool when it determines a web search is needed
  - The tool returns search results including titles, links, and snippets
  - Results are limited to 50 by default (configurable with the "Limit" parameter)
  - All "Additional Fields" are available for advanced filtering

  ### Tips for AI Tool Usage

  - Use descriptive prompts that might require web searches (e.g., "What are the latest trends in...")
  - The AI will decide when to use the search tool based on the conversation context
  - You can combine this with other tools for comprehensive AI workflows
  - Monitor your Google API quota as the AI may make multiple search requests

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [Google Custom Search API documentation](https://developers.google.com/custom-search/v1/overview)
  - [Google Programmable Search Engine](https://programmablesearchengine.google.com)
  - [Google Cloud Console](https://console.cloud.google.com)

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"This n8n community node enables programmatic web searches using Google's Custom Search API, allowing workflows to retrieve information from the internet.","capabilities":["Execute custom search queries via Google Custom Search API","Filter results by date range (past 24h, week, month, year)","Search for exact phrases or exclude specific terms","Filter results by file type (PDF, DOC, etc.)","Filter images by size, color type, and dominant color","Restrict results to specific sites or link sites","Sort results by relevance or date","Enable safe search filtering","Support automatic pagination for large result sets","Integrate as a tool in AI Agent workflows"],"authentication":"API key required (Google Cloud API key and Custom Search Engine ID)","commonUseCases":["Content research and information gathering","Competitor analysis and brand monitoring","Lead generation and contact information retrieval","SEO keyword analysis","Automated web data collection"],"limitations":["Requires Google Cloud Platform account and Custom Search Engine setup","Requires n8n v0.198.0+ (v1.40+ for AI Agent tool usage)","Requires Node.js 18.10 or higher","Community node requires enabling community packages in n8n settings","AI Agent tool usage requires additional environment variable configuration"],"relatedNodes":["AI Agent node","HTTP Request node","Webhook node"]}


node_type: @bitovi/n8n-nodes-watsonx.watsonx
package_name: @bitovi/n8n-nodes-watsonx
display_name: watsonx
description: N8N node to connect to WatsonX
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-watsonx.git
npm_package_name: @bitovi/n8n-nodes-watsonx
npm_version: 0.2.5
community_fetched_at: 2026-05-02T08:43:03.239Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # @bitovi/n8n-nodes-watsonx

  This is an n8n community node that lets you use IBM watsonx.ai in your n8n workflows.

  IBM watsonx.ai is an enterprise-ready AI and data platform designed to multiply the impact of AI across your business. It provides access to foundation models for language, code, and multimodal tasks, with options for both IBM Cloud and on-premise Cloud Pak for Data deployments.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  Alternative installation method:
  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-watsonx`

  ## Operations

  This package provides three nodes for different AI operations:

  ### WatsonX LLM
  - **Chat completion**: Generate text responses using IBM watsonx foundation models
  - **Model selection**: Choose from available foundation models in your watsonx instance
  - **Parameter control**: Configure temperature, max tokens, top-p, and other model parameters
  - **Langfuse integration**: Built-in tracking and monitoring of LLM interactions

  ### WatsonX AI Agent
  - **AI Agent execution**: Create autonomous agents that can use tools and make decisions
  - **Tool integration**: Connect with n8n tools and external APIs
  - **Memory support**: Maintain conversation context across interactions
  - **Output parsing**: Structure agent responses with custom output formats
  - **Iteration control**: Set maximum iterations and return intermediate steps
  - **System message customization**: Define agent behavior and personality
  - **Batch Processing, returning Intermediate Steps and more!**

  ### Embeddings WatsonX
  - **Text embeddings**: Convert text into vector representations for semantic search
  - **Model selection**: Use watsonx embedding models for your specific use case
  - **Vector store integration**: Connect directly with n8n vector store nodes

  ## Credentials

  To use this node, you need to authenticate with IBM watsonx.ai. The package supports two authentication methods:

  ### Prerequisites
  - An IBM watsonx.ai account (either IBM Cloud or Cloud Pak for Data)
  - A watsonx project with appropriate permissions
  - API credentials for your chosen environment

  ### Authentication Methods

  #### IBM Cloud (IAM Authentication)
  For IBM Cloud-hosted watsonx.ai:
  1. **IBM Cloud API Key**: Your IBM Cloud IAM API Key
  2. **Project ID**: Your watsonx.ai project ID (found in the "Manage" tab of your project)
  3. **Region**: Select your IBM Cloud region (us-south, eu-gb, eu-de, or jp-tok)

  #### On-Premise (Cloud Pak for Data Authentication)
  For on-premise Cloud Pak for Data instances:
  1. **On-Premise URL**: The base URL of your CP4D instance (e.g., https://your-watsonx-host.com)
  2. **Username**: Your CP4D username
  3. **API Key**: Your username-associated API key from your CP4D profile
  4. **Project ID**: Your watsonx.ai project ID

  ### Setting up Credentials
  1. In n8n, go to **Settings** > **Credentials**
  2. Click **Add Credential** and search for "WatsonX API"
  3. Select your environment type (IBM Cloud or On-Premise)
  4. Fill in the required fields based on your chosen authentication method
  5. Test the connection to ensure it's working properly

  ## Compatibility

  - **Minimum n8n version**: 1.94.0
  - **Node.js**: 18.10 or higher
  - **Package manager**: pnpm 9.1 or higher
  - **Tested on n8n 1.104.1**

  This package is tested against 1.104.1 of n8n and is regularly updated to maintain compatibility.

  ## Usage

  ### Basic LLM Usage
  1. Add the **WatsonX LLM** node to your workflow
  2. Configure your watsonx credentials
  3. Select a foundation model from the dropdown
  4. Connect to other n8n nodes to process input and output

  ### Creating AI Agents
  1. Add the **AgentV2 Custom** node to your workflow
  2. Connect a **WatsonX LLM** node as the chat model
  3. Add any tools your agent should have access to
  4. Configure the system message to define agent behavior
  5. Optionally add memory and output parsers for more advanced functionality

  ### Working with Embeddings
  1. Add the **Embeddings WatsonX** node to your workflow
  2. Configure your watsonx credentials
  3. Select an embedding model
  4. Connect to vector store nodes for semantic search capabilities

  ## Resources

  * [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  * [IBM watsonx.ai documentation](https://www.ibm.com/docs/en/watsonx-as-a-service)
  * [Langchain IBM integration documentation](https://js.langchain.com/docs/integrations/llms/ibm)
  * [IBM Cloud API documentation](https://cloud.ibm.com/apidocs)

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Connects n8n workflows to IBM watsonx.ai to enable text generation, AI agent execution, and text embedding operations for enterprise AI tasks.","capabilities":["Chat completion using watsonx foundation models","Model selection for language, code, and multimodal tasks","Configuration of temperature, max tokens, and top-p parameters","Langfuse integration for tracking LLM interactions","Autonomous AI agent execution with tool use","Tool integration with n8n tools and external APIs","Conversation memory and context maintenance","Custom output parsing and formatting for agents","Batch processing with intermediate step returns","Text-to-vector embedding generation"],"authentication":"API key required (supports IBM Cloud IAM API Key or On-Premise CP4D Username/API Key)","commonUseCases":["Enterprise text generation and summarization","Building autonomous AI agents with tool access","Semantic search and vector database integration","Code generation and analysis","Multimodal data processing"],"limitations":["Requires n8n version 1.94.0 or higher","Requires Node.js 18.10 or higher","Requires pnpm 9.1 or higher for installation","Separate credential setup required for IBM Cloud vs On-Premise deployments"],"relatedNodes":["n8n vector store nodes","AgentV2 Custom node","Langfuse nodes"]}


node_type: n8n-nodes-zalo-tools.zalotools
package_name: n8n-nodes-zalo-tools
display_name: zalotools
description: Các node hỗ trợ Zalo cho n8n
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: dinhtrung1308
author_github_url: git+https://github.com/ChickenAI/zalo-node.git
npm_package_name: n8n-nodes-zalo-tools
npm_version: 0.6.1
community_fetched_at: 2026-05-02T08:43:03.243Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-zalo-tools
  Node dành riêng cho n8n này được thiết kế hoạt động hoàn toàn bên trong instance n8n của bạn. Không cần sử dụng API của bên thứ ba hay phụ thuộc ngoại vi nào — chỉ có sự tự động hóa quy trình thuần túy, đảm bảo dữ liệu của bạn luôn được giữ riêng tư và an toàn.

  Node này mô phỏng trình duyệt để tương tác trực tiếp với Zalo Web, cho phép tự động hóa liền mạch ngay trong n8n. Đây là dự án mã nguồn mở, mở rộng cơ hội cho cộng đồng cùng đóng góp ý kiến và phát triển thêm các tính năng mới, nhằm xây dựng hệ thống tự động hóa Zalo tiên tiến, hiệu quả và an toàn hơn.

  ## Buy me a coffee
  Nếu **node** này giúp bạn tiết kiệm thời gian hoặc giải quyết được vấn đề khó nhằn, hãy cân nhắc ủng hộ tôi một ☕ (Buy me a coffee) hoặc đơn giản là nhấn **★ Star** cho dự án.  
  Sự động viên nhỏ ấy sẽ tiếp thêm năng lượng để mình tiếp tục duy trì, cập nhật và phát triển thêm nhiều tính năng hữu ích hơn nữa.  
  Cám ơn bạn rất nhiều! 💛

  ![Alt text](qr.png)
  ## Tác giả
  - Dương Đình Trung - ChickenAI Team

  ## Hướng dẫn cài đặt node này:

  **Community Nodes (Khuyến nghị)**

  Đối với người dùng n8n v0.187+, bạn có thể cài đặt node này trực tiếp từ bảng Community Nodes trong trình soạn thảo n8n.

  1.  Mở trình soạn thảo n8n của bạn.
  2.  Vào Settings > Community Nodes.
  3.  Tìm kiếm "n8n-nodes-zalo-tools".
  4.  Nhấp vào Install.
  5.  Tải lại trình soạn thảo.

  **Cài đặt thủ công**

  Bạn cũng có thể cài đặt node này theo cách thủ công:

  ```
  cd YOUR_N8N_INSTALLATION_DIRECTORY
  npm install n8n-nodes-zalo-tools
  ```

  ## Available Nodes

  1. Zalo Login By QR
  Node cho phép đăng nhập vào Zalo thông qua mã QR.

  2. Zalo Group
  Node quản lý các hoạt động nhóm.
  Operations:
  createGroup: Tạo nhóm mới
  getGroupInfo: Lấy thông tin nhóm
  addGroupDeputy: Thêm phó nhóm
  addUserToGroup: Thêm thành viên
  changeGroupAvatar: Đổi avatar nhóm
  changeGroupName: Đổi tên nhóm
  getGroupMembers: Lấy danh sách thành viên
  getAllGroups: Lấy tất cả nhóm
  removeUserFromGroup: Xóa thành viên

  3. Zalo User
  Node quản lý người dùng và bạn bè.
  Operations:
  acceptFriendRequest: Chấp nhận lời mời kết bạn
  sendFriendRequest: Gửi lời mời kết bạn
  blockUser: Chặn người dùng
  unblockUser: Bỏ chặn người dùng
  changeAccountAvatar: Đổi ảnh đại diện
  changeAccountSetting: Thay đổi cài đặt tài khoản
  getUserInfo: Lấy thông tin người dùng
  getAllFriends: Lấy danh sách bạn bè
  findUser: Tìm kiếm người dùng qua số điện thoại

  4. Zalo Send Message
  Node gửi tin nhắn tới người dùng hoặc nhóm.
  Features:
  Gửi tin nhắn văn bản


  5. Zalo Message Trigger
  Node lắng nghe và xử lý các sự kiện tin nhắn.
  Events:
  Tin nhắn mới
  Tin nhắn nhóm
  Thay đổi trạng thái tin nhắn

  ## Warning and Thanks

  **Please read this carefully before using the Zalo nodes:**

  Lưu ý: việc sử dụng thư viện này đồng nghĩa với việc bạn đang làm trái với chính sách của Zalo và nó có thể khiến cho tài khoản của bạn bị vô hiệu hóa. Chúng tôi sẽ không chịu trách nhiệm nếu điều đó xảy ra, vậy nên hãy cân nhắc trước khi sử dụng.

  We would like to thank ZCA-JS for their work on this library.


  ## License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

ai_documentation_summary:
  {"purpose":"Provides n8n workflow automation capabilities for Zalo by simulating a browser to interact directly with Zalo Web, allowing users to manage groups, users, and send messages without external APIs.","capabilities":["Login via QR code","Create new groups","Retrieve group information and members","Add or remove group members and deputies","Change group name and avatar","List all groups","Manage friend requests (send and accept)","Block or unblock users","Change account avatar and settings","Retrieve user information and friend lists"],"authentication":"QR code login","commonUseCases":["Automated customer support responses via Zalo","Automated group management and announcements","Automated friend request handling","Scheduled messaging campaigns to contacts or groups"],"limitations":["Violates Zalo's terms of service and may lead to account suspension","Requires manual QR code login setup","No official API support; relies on browser simulation which may be fragile with Zalo updates"],"relatedNodes":[]}


node_type: @bitovi/n8n-nodes-langfuse.langfuse
package_name: @bitovi/n8n-nodes-langfuse
display_name: langfuse
description: n8n node to process Langfuse configuration files
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-langfuse.git
npm_package_name: @bitovi/n8n-nodes-langfuse
npm_version: 0.1.0
community_fetched_at: 2026-05-02T08:43:03.244Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # @bitovi/n8n-nodes-langfuse

  This repo contains [N8N](https://n8n.io/) node to work with Langfuse.

  ## Installation

  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-langfuse`

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Processes Langfuse configuration files to enable integration with the Langfuse observability platform within n8n workflows.","capabilities":["Load Langfuse configuration files","Initialize Langfuse connections","Support community node installation via n8n web UI"],"authentication":"None (configuration-based)","commonUseCases":["AI model observability setup","LLM prompt tracking configuration","Agent workflow monitoring initialization"],"limitations":["Requires manual configuration file setup","Limited to configuration processing (no direct API operations mentioned)"],"relatedNodes":["langfuse","community-nodes","ai-agents-workshop"]}


node_type: @bitovi/n8n-nodes-utils.utils
package_name: @bitovi/n8n-nodes-utils
display_name: utils
description: N8N util nodes from Bitovi
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-utils.git
npm_package_name: @bitovi/n8n-nodes-utils
npm_version: 0.3.1
community_fetched_at: 2026-05-02T08:43:03.244Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # @bitovi/n8n-nodes-utils

  This is an n8n community node package that provides utility nodes for enhancing your n8n workflows. It includes nodes for JSON schema validation, regex operations, data manipulation, and Wikipedia integration.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ### Quick Installation

  1. Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  2. Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-utils`
  3. Click install and restart your n8n instance

  ## Operations

  This package includes the following utility nodes:

  ### JSONSchema Validation
  Validates JSON data against a provided JSON schema using the AJV library.

  ### Regex
  Perform regular expression operations on text data.
  - **Get Matches**: Extract all matches from text using a regex pattern
  - **Replace**: Replace text using regex patterns with support for capture groups

  ### Skip
  Skip a specified number of items from the input data stream.
  - **Data filtering**: Remove the first N items from your data flow
  - **Pagination support**: Useful for implementing pagination or data chunking

  ### Wikipedia
  Integrate with Wikipedia to fetch content and metadata.
  - **Get Content**: Retrieve the full content of a Wikipedia page
  - **Get Links**: Extract all links from a Wikipedia page
  - These automatically suggest the closest matching page name and follow redirects to the correct page

  ## Compatibility

  - **Minimum n8n version**: Compatible with n8n API version 1
  - **Node.js version**: Requires Node.js >= 18.10
  - **Package manager**: Uses pnpm >= 9.1

  This package has been tested with recent versions of n8n and follows the community node standards.

  ## Usage

  ### JSONSchema Validation Example
  Use this node to validate API responses or user input data:
  ```json
  {
    "type": "object",
    "properties": {
      "name": { "type": "string" },
      "age": { "type": "number", "minimum": 0 },
      "email": { "type": "string", "format": "email" }
    },
    "required": ["name", "email"]
  }
  ```

  ### Regex Example
  Extract email addresses from text:
  - **Pattern**: `[\w\.-]+@[\w\.-]+\.\w+`
  - **Flags**: `g` (global to find all matches)

  ### Wikipedia Integration
  Fetch content about a topic for AI processing or content generation:
  - Set **Page Name** to your topic of interest
  - Enable **Auto Suggest** for fuzzy matching
  - Use **Get Content** for full article text or **Get Links** for related topics

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## Resources

  - [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  - [AJV JSON Schema Validator](https://ajv.js.org/)
  - [Wikipedia API](https://github.com/dopecodez/Wikipedia)
  - [Bitovi GitHub Repository](https://github.com/bitovi/n8n-nodes-utils)

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"Provides utility nodes for n8n workflows including JSON schema validation, regex operations, data filtering, and Wikipedia integration.","capabilities":["JSON schema validation using AJV library","Regular expression matching and extraction","Text replacement with regex capture groups","Skipping N items from data stream","Wikipedia content fetching","Wikipedia link extraction","Auto-suggest for Wikipedia page matching"],"authentication":"None","commonUseCases":["Validating API responses against JSON schemas","Extracting data patterns from text","Implementing pagination in data flows","Fetching Wikipedia content for AI processing"],"limitations":["Requires Node.js >= 18.10","Requires pnpm >= 9.1","Compatible with n8n API version 1"],"relatedNodes":["n8n core nodes","JSON Schema validator","Regex node","Wikipedia node"]}


node_type: @bitovi/n8n-nodes-semantic-text-splitter.semantictextsplitter
package_name: @bitovi/n8n-nodes-semantic-text-splitter
display_name: semantictextsplitter
description: N8N node for semantic text splitting
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: bitovi-os
author_github_url: git+https://github.com/bitovi/n8n-nodes-semantic-text-splitter.git
npm_package_name: @bitovi/n8n-nodes-semantic-text-splitter
npm_version: 0.1.3
community_fetched_at: 2026-05-02T08:43:03.246Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # @bitovi/n8n-nodes-semantic-text-splitter

  This is an n8n community node. It lets you use semantic text splitting in your n8n workflows.

  Semantic text splitting is an advanced text processing technique that splits text based on semantic similarity rather than simple character or token counts. This node implements the methodology described in [5 Levels Of Text Splitting](https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb), which uses embedding models to identify natural breakpoints in text where meaning shifts significantly.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Compatibility](#compatibility)  
  [Usage](#usage)  
  [Resources](#resources)  
  [Version history](#version-history)

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  **Quick Installation:**
  - Make sure to allow community nodes with `N8N_COMMUNITY_PACKAGES_ENABLED=true`
  - Once logged in to your N8N web UI, go to `/settings/community-nodes` and type `@bitovi/n8n-nodes-semantic-text-splitter`

  ## Operations

  The Semantic Text Splitter node provides intelligent text splitting capabilities:

  - **Semantic Text Splitting**: Splits text into semantically coherent chunks using embedding-based similarity analysis
  - **Configurable Parameters**: Control splitting behavior with customizable thresholds and window sizes
  - **Integration with Embedding Models**: Works with any n8n-compatible embedding model for similarity calculations

  ## Compatibility

  - **Minimum n8n version**: Compatible with n8n v1.0+
  - **Node.js version**: Requires Node.js 18.10 or higher
  - **Dependencies**: Requires @langchain/core and @langchain/textsplitters

  This node is tested with the latest stable version of n8n and should work with most n8n installations that support community nodes.

  ## Usage

  ### Node Configuration

  The Semantic Text Splitter node requires an embedding model connection and supports the following parameters:

  - **Percentile Threshold for Breakpoints** (default: 0.95): Controls how selective the algorithm is when identifying breakpoints. Higher values result in fewer, larger chunks.
  - **Number of Sentences to Consider in Sliding Window** (default: 3): The size of the sliding window used for embedding comparison.
  - **Minimum Chunk Size** (default: 100): Minimum character length for generated chunks.
  - **Sentence Delimiters** (default: ".!?"): Characters used to identify sentence boundaries.

  ### How It Works

  1. **Sentence Splitting**: Text is first split into sentences using the configured delimiters
  2. **Sliding Windows**: Creates overlapping windows of sentences based on the window size
  3. **Embedding Generation**: Each window is converted to embeddings using the connected embedding model
  4. **Distance Calculation**: Calculates cosine distances between sequential window embeddings
  5. **Breakpoint Detection**: Identifies breakpoints where semantic distance exceeds the threshold
  6. **Chunk Creation**: Creates final text chunks based on identified breakpoints

  ### Example Workflow

  1. Connect a text input (e.g., from a document loader)
  2. Connect an embedding model (e.g., OpenAI Embeddings)
  3. Configure the splitting parameters based on your needs
  4. Connect the output to downstream processing nodes (e.g., vector store, document processing)

  This approach creates more coherent chunks compared to simple character or token-based splitting, making it ideal for RAG (Retrieval Augmented Generation) applications and document processing workflows.

  ## Resources

  * [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  * [5 Levels Of Text Splitting Tutorial](https://github.com/FullStackRetrieval-com/RetrievalTutorials/blob/main/tutorials/LevelsOfTextSplitting/5_Levels_Of_Text_Splitting.ipynb)
  * [LangChain Text Splitters Documentation](https://js.langchain.com/docs/modules/data_connection/document_transformers/)

  ## Version history

  - **v0.1.2** (Current): Latest stable release with full semantic splitting functionality
  - **v0.1.x**: Initial releases with core semantic text splitting features

  ## Need help or have questions?

  Need guidance on leveraging AI agents or N8N for your business? Our [AI Agents workshop](https://hubs.ly/Q02X-9Qq0) will equip you with the knowledge and tools necessary to implement successful and valuable agentic workflows.

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"This n8n community node performs semantic text splitting by using embedding models to identify natural breakpoints in text where meaning shifts, creating coherent chunks based on semantic similarity rather than fixed character counts.","capabilities":["Splits text into semantically coherent chunks using embedding-based similarity analysis","Configurable percentile threshold for identifying breakpoints","Adjustable sliding window size for sentence comparison","Configurable minimum chunk size","Customizable sentence delimiter characters","Integration with any n8n-compatible embedding model"],"authentication":"None","commonUseCases":["RAG (Retrieval Augmented Generation) applications","Document processing workflows requiring semantic coherence","Creating chunks for vector stores with improved retrieval accuracy"],"limitations":["Requires an external embedding model connection to function","Requires Node.js 18.10 or higher","Dependent on community node installation and n8n v1.0+"],"relatedNodes":["OpenAI Embeddings","Document Loader","Vector Store"]}


node_type: @jonmash/n8n-nodes-altium365.altium365
package_name: @jonmash/n8n-nodes-altium365
display_name: altium365
description: n8n community node for Altium 365 via Nexar API
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-02 08:43:03
author_name: GitHub Actions
author_github_url: git+https://github.com/jonmash/n8n-nodes-altium365.git
npm_package_name: @jonmash/n8n-nodes-altium365
npm_version: 0.12.0
community_fetched_at: 2026-05-02T08:43:03.247Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # @jonmash/n8n-nodes-altium365

  This is an n8n community node that integrates n8n with Altium 365 via the Nexar GraphQL API.

  [n8n](https://n8n.io/) is a workflow automation platform with a visual editor.

  [Altium 365](https://www.altium.com/altium-365) is a cloud platform for electronics design collaboration.

  [Nexar API](https://nexar.com/api) is the GraphQL API for programmatic access to Altium 365 data.

  ## Features

  ### Action Node (Altium 365)

  **Projects**
  - Get project by ID
  - Get many projects (with pagination)
  - Get latest commit for a project
  - Get commit history for a project
  - Update project parameters

  **Workspaces**
  - Get all workspaces

  ### Trigger Node (Altium 365 Trigger)

  **Events**
  - **Project Committed** - Triggers when a project is committed (Git push detected)
    - Monitor specific project or all projects in workspace
    - Includes file change details
    - Returns commit message, author, timestamp
  - **New Project** - Triggers when a new project is created in the workspace

  ## Installation

  ### In n8n (recommended)

  1. Go to **Settings** > **Community Nodes**
  2. Select **Install**
  3. Enter `@jonmash/n8n-nodes-altium365` in **Enter npm package name**
  4. Agree to the risks of using community nodes
  5. Select **Install**

  After installing the node, you can use it in your workflows.

  ### Manual Installation

  To install manually, navigate to your n8n installation directory and run:

  ```bash
  npm install @jonmash/n8n-nodes-altium365
  ```

  For Docker-based deployments, add this to your `package.json` or Dockerfile.

  ## Credentials

  This node requires Altium 365 Nexar API credentials.

  ### Setting up Nexar API Access

  1. **Sign up at Nexar Portal**
     - Go to [portal.nexar.com](https://portal.nexar.com/)
     - Sign in with your Altium Live credentials (they link automatically)

  2. **Create an Application**
     - Click **Create Application**
     - Give it a name (e.g., "n8n Integration")
     - Enable the **Design** scope
     - Save the application

  3. **Get Credentials**
     - Go to the **Authorization** tab
     - Copy the **Client ID**
     - Copy the **Client Secret** (guard this carefully!)

  4. **Find Your Workspace URL**
     - Your workspace URL follows the format: `https://YOURWORKSPACE.365.altium.com/`
     - You can find this in your Altium 365 web interface URL

  ### Configuring in n8n

  1. In n8n, create a new credential of type **Altium 365 Nexar API**
  2. Enter your **Client ID**
  3. Enter your **Client Secret**
  4. Enter your **Workspace URL** (e.g., `https://mycompany.365.altium.com/`)
  5. Test the credential to verify it works

  ## Usage

  ### Example: Monitor Project Commits

  Set up a workflow that triggers whenever a project is committed:

  1. Add **Altium 365 Trigger** node
  2. Select event: **Project Committed**
  3. (Optional) Enter a specific **Project ID** to monitor one project, or leave blank to monitor all projects
  4. Connect to any action (Slack notification, email, webhook, etc.)

  The trigger outputs:
  ```json
  {
    "projectId": "abc123",
    "projectName": "PowerSupply_v2",
    "revisionId": "e4f8a9b2c1d3",
    "message": "Fixed power rail routing on layer 3",
    "author": "John Smith",
    "committedAt": "2025-03-14T10:23:00Z",
    "filesChanged": [
      {
        "kind": "MODIFIED",
        "path": "PowerBoard.PcbDoc"
      },
      {
        "kind": "MODIFIED",
        "path": "PowerSchematic.SchDoc"
      }
    ]
  }
  ```

  ### Example: Get Project Details

  1. Add **Altium 365** action node
  2. Select resource: **Project**
  3. Select operation: **Get**
  4. Enter the **Project ID**

  Returns complete project information including metadata, parameters, and variant count.

  ### Example: List All Projects

  1. Add **Altium 365** action node
  2. Select resource: **Project**
  3. Select operation: **Get Many**
  4. Choose **Return All** or set a **Limit**

  Returns paginated list of all projects in your workspace.

  ## API Rate Limits

  - Design queries are **free and unlimited** with an active Altium 365 subscription
  - OAuth tokens are valid for 24 hours and automatically refreshed
  - The node caches tokens to minimize authentication requests

  ## Development

  ### Prerequisites

  - Node.js >= 18.17.0
  - npm >= 10.x
  - Active Altium 365 subscription
  - Nexar API credentials with Design scope

  ### Setup

  ```bash
  # Clone the repository
  git clone https://github.com/jonmash/n8n-nodes-altium365.git
  cd n8n-nodes-altium365  # Note: package is published as @jonmash/n8n-nodes-altium365

  # Install dependencies
  npm install

  # Generate GraphQL types from Nexar schema
  npm run codegen

  # Build the node
  npm run build

  # Run linter
  npm run lint

  # Format code
  npm run format
  ```

  ### Project Structure

  ```
  @jonmash/n8n-nodes-altium365/
  ├── credentials/
  │   └── Altium365NexarApi.credentials.ts  # OAuth2 credentials
  ├── nodes/
  │   ├── Altium365/
  │   │   ├── Altium365.node.ts             # Main action node
  │   │   └── altium365.svg                 # Node icon
  │   └── Altium365Trigger/
  │       ├── Altium365Trigger.node.ts      # Polling trigger node
  │       └── altium365trigger.svg          # Trigger icon
  ├── shared/
  │   ├── NexarClient.ts                    # GraphQL client with token caching
  │   ├── queries/                          # GraphQL query definitions
  │   │   ├── workspace.graphql
  │   │   └── projects.graphql
  │   └── generated/
  │       └── graphql.ts                    # Auto-generated types from schema
  └── package.json
  ```

  ### GraphQL Code Generation

  This package uses GraphQL Code Generator to create fully typed SDK from the Nexar schema:

  ```bash
  # Regenerate types after modifying .graphql files
  npm run codegen
  ```

  The codegen:
  1. Introspects the Nexar GraphQL schema
  2. Validates your queries against the schema
  3. Generates TypeScript types and SDK functions
  4. Provides full autocomplete and type safety

  ## Compatibility

  - Tested with n8n version: 1.x
  - Node.js: >= 18.17.0
  - Altium 365: Current version (2025)

  ## Resources

  - [n8n Documentation](https://docs.n8n.io/)
  - [Nexar API Documentation](https://nexar.com/api)
  - [Nexar Portal](https://portal.nexar.com/)
  - [Altium 365](https://www.altium.com/altium-365)

  ## License

  [MIT](LICENSE.md)

  ## Contributing

  Contributions are welcome! Please feel free to submit a Pull Request.

  ## Support

  For issues and questions:
  - [GitHub Issues](https://github.com/jonmash/n8n-nodes-altium365/issues)
  - [Nexar Community](https://community.nexar.com/)

  ## Changelog

  See [CHANGELOG.md](CHANGELOG.md)

ai_documentation_summary:
  {"purpose":"Integrates n8n with Altium 365 via the Nexar GraphQL API to manage projects, workspaces, and monitor design collaboration events.","capabilities":["Get project details by ID","List multiple projects with pagination","Retrieve latest commit for a project","Get full commit history for a project","Update project parameters","List all workspaces","Trigger on project commits (Git push detection)","Trigger on new project creation","Receive detailed file change information in commit events"],"authentication":"OAuth2 (Client ID and Client Secret via Nexar API)","commonUseCases":["Automated notifications when PCB designs are committed","Tracking project metadata and variant counts","Monitoring workspace activity across multiple projects","Integrating Altium 365 data into external dashboards or databases"],"limitations":["Requires active Altium 365 subscription for API access","OAuth tokens are valid for 24 hours and require automatic refresh","Limited to Design scope permissions in Nexar API configuration"],"relatedNodes":[]}


node_type: @periodix/n8n-nodes-actions.linkedInSearch
package_name: @periodix/n8n-nodes-actions
display_name: Periodix LinkedIn Search
description: Search LinkedIn People, Companies, Posts, and Jobs (Classic or Sales Navigator) by URL
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
outputs:
  [
  "main"
  ]

updated_at: 2026-05-22 09:37:12
author_name: vadym.gidulian
author_github_url: https://github.com/Periodix-Inc/n8n-nodes-actions.git
npm_package_name: @periodix/n8n-nodes-actions
npm_version: 1.0.0
community_fetched_at: 2026-05-22T09:37:12.246Z
ai_summary_generated_at: 2026-05-22 10:26:01
npm_readme:
  # @periodix/n8n-nodes-actions

  This is the **Periodix Actions** community node package for n8n. It lets you pull LinkedIn data — search results, full profiles, company profiles, posts, post comments and reactions, and connections — straight from your workflows, using safe, rate-limited calls through a connected LinkedIn account.

  [Periodix Actions](https://actions.periodix.net/?utm_source=github&utm_medium=readme&utm_content=intro) is a multi-tenant API for sales-automation primitives. It handles LinkedIn account connection, rate limiting, and pacing on your behalf, so your workflows don't have to.

  [Installation](#installation)
  [Features](#features)
  [Credentials](#credentials)
  [Nodes](#nodes)
  [Usage](#usage)
  [Example Workflow](#example-workflow)
  [Resources](#resources)
  [Version history](#version-history)

  ## Installation

  ### Community Nodes (recommended)

  1. In n8n, go to **Settings → Community Nodes**.
  2. Click **Install**.
  3. Enter `@periodix/n8n-nodes-actions` and click **Download**.
  4. The **Periodix LinkedIn** node will appear in your node palette.

  ### Self-hosted / manual

  Run `npm install @periodix/n8n-nodes-actions` inside your n8n installation, then restart n8n.

  See the official [community nodes installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) for full details.

  ## Features

  - **Search by URL** — paste any LinkedIn Classic or Sales Navigator search URL and get back matching People, Companies, Posts, or Jobs.
  - **Profile & company enrichment** — fetch a full person profile (experience, education, skills, summary) or a company profile (industry, size, locations) by identifier.
  - **Engagement & content** — list a person's or company's recent posts, and the comments and reactions on any post, to find and qualify warm leads.
  - **Network** — list the 1st-degree connections of a connected account.
  - **Managed profile connection** — connect LinkedIn accounts in the Periodix Actions dashboard with a hosted auth flow; no cookies or credentials in n8n.
  - **Built-in rate limiting** — Periodix paces calls per profile so you stay within LinkedIn's limits.

  ## Credentials

  Steps to obtain the **API key** needed for authentication:

  1. Go to [actions.periodix.net](https://actions.periodix.net?utm_source=github&utm_medium=readme&utm_content=signin) and sign in (or create an account).
  2. Open the **Profiles** page and connect at least one LinkedIn account using the hosted auth flow.
  3. Open the **API keys** page and click **New API key**.
  4. **Copy** the generated key.
  5. In n8n, create a new **Periodix Actions API** credential.
  6. **Paste** the API key into the **API Key** field and save.

  API keys can be revoked from the dashboard at any time.

  Every operation requires this credential and a connected LinkedIn **Profile**, chosen from a dropdown that loads the profiles on your account. The dropdown shows each profile's connection status; if the chosen profile is not connected at execution time, the call fails — reconnect it from the dashboard.

  ## Node

  A single **Periodix LinkedIn** node exposes every capability. Pick a **Resource**, then an **Operation**.

  ### Profile → Get

  Fetch a full LinkedIn profile (experience, education, skills, summary).

  - **Person** — the public identifier (the part after `/in/` in the profile URL, e.g. `john-doe`) or the internal ID (e.g. `ACoAA…`) of the person.
  - **Options → Notify Person** — whether to let the person see that you viewed their profile (default off).

  ### Company → Get

  Fetch a LinkedIn company profile (industry, size, description, locations).

  - **Company** — the public identifier (the part after `/company/`), numeric company ID, or URN.

  ### Post → Get Many

  List the recent posts published by a person or company. Emits one item per post.

  - **Author ID** — the author's internal ID. For a person it starts with `ACo`/`ADo`; for a company use the numeric company ID and enable **Is Company**.
  - **Is Company** — whether the author is a company rather than a person.
  - **Return All** / **Limit** — return everything, or cap the number of posts.

  ### Post → Get Comments

  List the comments on a post, with author details. Emits one item per comment.

  - **Post Social ID** — the post's `social_id` (returned by **Post → Get Many**), not the numeric ID in the post URL.
  - **Return All** / **Limit**.

  ### Post → Get Reactions

  List the people who reacted to a post (or to a specific comment). Emits one item per reaction.

  - **Post Social ID** — the post's `social_id` (returned by **Post → Get Many**).
  - **Options → Comment ID** — fetch reactions on a specific comment instead of the post.
  - **Return All** / **Limit**.

  ### Connection → Get Many

  List the 1st-degree connections of the connected account. Emits one item per connection.

  - **Return All** / **Limit**.

  ### Search → Search

  Run a LinkedIn search by URL and return the matched items. *Asynchronous* — see [Usage](#usage).

  - **Search URL** — a fully-qualified LinkedIn search URL. Supported:
    - LinkedIn Classic: [People](https://www.linkedin.com/search/results/people/), [Companies](https://www.linkedin.com/search/results/companies/), [Posts](https://www.linkedin.com/search/results/content/), [Jobs](https://www.linkedin.com/search/results/jobs/).
    - LinkedIn Sales Navigator: [People](https://www.linkedin.com/sales/search/people), [Companies](https://www.linkedin.com/sales/search/company).
  - **Limit** — maximum number of results to return.
  - **Options → Timeout (Minutes)** *(advanced)* — how long to wait for the search to finish before giving up.

  ## Usage

  **Search is asynchronous.** The **Search → Search** operation processes a single input item and waits (via webhook) for the search to complete — searches typically take minutes depending on result size and LinkedIn pacing.

  **The other operations are synchronous.** They return immediately, process every input item, and emit one output item per result. The list operations (Post → Get Many, Get Comments, Get Reactions, and Connection → Get Many) paginate automatically: turn on **Return All** to fetch everything, or leave it off and set a **Limit**.

  **Post IDs.** Comments and reactions are keyed by a post's `social_id`, which you get from **Post → Get Many** — the numeric ID in a post's URL will not work.

  New to n8n? See the [Try it out](https://docs.n8n.io/try-it-out/) guide.

  ## Example Workflow

  ### Find and enrich engaged leads from a post

  1. Add a **Manual Trigger** (or any trigger).
  2. Add **Periodix LinkedIn** (Resource **Post**, Operation **Get Many**), pick a connected **Profile**, and enter the author's **Author ID** to find a relevant post; note its `social_id`.
  3. Add another **Periodix LinkedIn** (Resource **Post**, Operation **Get Comments** or **Get Reactions**) and pass that `social_id` as the **Post Social ID** to list everyone who engaged.
  4. Add another **Periodix LinkedIn** (Resource **Profile**, Operation **Get**) to enrich each commenter/reactor into a full profile.
  5. Connect a **Google Sheets → Append Row** node downstream, mapping the fields you need.

  ## Version history

  See [CHANGELOG.md](CHANGELOG.md) for the full release history.

  ## Resources

  - [Periodix Actions](https://actions.periodix.net/?utm_source=github&utm_medium=readme&utm_content=links)
  - [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)

ai_documentation_summary:
  {"purpose":"A community n8n node that executes LinkedIn Classic and Sales Navigator searches by pasting a search URL, returning matching people, companies, posts, or jobs asynchronously.","capabilities":["Search LinkedIn People","Search LinkedIn Companies","Search LinkedIn Posts","Search LinkedIn Jobs","Support for LinkedIn Classic","Support for LinkedIn Sales Navigator","Async execution with webhook completion","Built-in rate limiting and pacing","Managed profile connection via hosted auth"],"authentication":"API key required (Access Token)","commonUseCases":["Scraping LinkedIn search results into spreadsheets","Automating lead discovery from search URLs","Monitoring job postings or company changes","Extracting profile data for sales automation"],"limitations":["Searches run asynchronously and may take minutes to complete","Results are limited by LinkedIn's pacing and rate limits","Profile connection status must be verified before execution","Only supports People and Companies for Sales Navigator (no Posts or Jobs)"],"relatedNodes":["Manual Trigger","Google Sheets → Append Row","Webhook Response"]}


node_type: n8n-nodes-fluentc.fluentCTranslate
package_name: n8n-nodes-fluentc
display_name: FluentC Translate
description: Translate text or HTML using FluentC AI
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
outputs:
  [
  "main"
  ]

updated_at: 2026-05-22 09:37:13
author_name: fluentc
author_github_url: https://github.com/FluentC/
npm_package_name: n8n-nodes-fluentc
npm_version: 1.2.7
community_fetched_at: 2026-05-22T09:37:13.402Z
ai_summary_generated_at: 2026-03-25 22:51:43
npm_readme:
  # FluentC N8N Plugin

  This N8N community plugin provides integration with the FluentC AI Translation API, enabling you to translate text and HTML content and detect languages within your N8N workflows.

  ## Features

  - **Translation**: Support for both real-time and batch translation modes
  - **Language Detection**: Detect the language of input content
  - **Language Retrieval**: Fetch lists of supported and source languages
  - **Dynamic Language Selection**: Dropdown menus populated with your API key's enabled languages
  - **Format Support**: Handle text, HTML, and JSON content
  - **Automatic Polling**: Batch jobs are automatically polled until completion
  - **Comprehensive Output**: Returns all metadata including token counts, detected languages, and model information
  - **Error Handling**: Graceful error handling with continue-on-fail support
  - **Language Management**: Direct link to manage enabled languages on your account

  ## Installation

  The installation method depends on your n8n setup. Choose the appropriate method below:

  ### Method 1: n8n GUI Installation (Recommended for self-hosted n8n)

  This is the easiest method for self-hosted n8n instances:

  1. **Open n8n Settings**: In your n8n instance, go to **Settings** > **Community Nodes**
  2. **Install Node**: Click **Install**
  3. **Enter Package Name**: Enter `n8n-nodes-fluentc` in the "Enter npm package name" field
  4. **Accept Risk**: Check "I understand the risks of installing unverified code from a public source"
  5. **Install**: Click **Install**
  6. **Restart**: The nodes will be available immediately after installation

  ### Method 2: Verified Community Nodes (for n8n Cloud and recent versions)

  If this package gets verified by n8n (future goal):

  1. **Open Nodes Panel**: Go to the Canvas and open the nodes panel (click '+' or press Tab)
  2. **Search**: Search for "FluentC"
  3. **Install from Community**: Look for the "More from the community" section
  4. **Install**: Click on the FluentC node and select **Install**

  ### Method 3: Manual Installation (for Docker/advanced setups)

  For Docker containers, queue mode, or when GUI installation isn't available:

  #### For Docker Containers:

  1. **Access Docker Shell**:
     ```bash
     docker exec -it [your-n8n-container-name] sh
     ```

  2. **Create nodes directory** (if it doesn't exist):
     ```bash
     mkdir -p ~/.n8n/nodes
     cd ~/.n8n/nodes
     ```

  3. **Install the package**:
     ```bash
     npm install n8n-nodes-fluentc
     ```

  4. **Restart n8n container**

  #### For npm-based installations:

  1. **Navigate to n8n nodes directory**:
     ```bash
     cd ~/.n8n/nodes
     ```
     (Create the directory if it doesn't exist: `mkdir -p ~/.n8n/nodes`)

  2. **Install the package**:
     ```bash
     npm install n8n-nodes-fluentc
     ```

  3. **Restart n8n**

  ### Method 4: Custom Docker Build

  For permanent installation in a custom Docker image:

  ```dockerfile
  FROM n8nio/n8n:latest
  RUN cd ~/.n8n/ && mkdir -p nodes && cd nodes && npm install n8n-nodes-fluentc
  ```

  ## Verification

  After installation, verify the node is available:

  1. Create a new workflow
  2. Click the '+' button to add a node
  3. Search for "FluentC" in the node search
  4. You should see the **FluentC** node (with package icon)

  ## Setup

  ### 1. Create FluentC API Credentials

  1. In N8N, go to **Credentials** > **New**
  2. Search for "FluentC API" and select it
  3. Enter your FluentC API key (obtained from the FluentC sales website)
  4. Test and save the credential

  ### 2. Using the Node

  The FluentC node uses a **Resource** and **Operation** pattern. Select the resource for the task you want to perform, then choose the operation.

  #### Translation > Translate

  Translate text, HTML, or JSON content with support for both real-time and batch modes.

  **Parameters:**
  - **Mode**: Choose between "Real-Time" (synchronous) or "Batch" (asynchronous)
  - **Input**: Text, HTML, or JSON content to translate (max 100,000 bytes)
  - **Input Format**: Select "Text", "HTML", or "JSON"
  - **Target Language**: Dropdown populated with your enabled target languages
  - **Source Language**: Dropdown with your enabled source languages (optional, includes "Auto-Detect")
  - **Max Polling Attempts**: (Batch mode only) Maximum polling attempts for batch jobs (default: 60)

  **Language Management:**
  The language dropdowns are dynamically populated based on your API key's enabled languages. If you need additional languages, you'll see a link to visit www.fluentc.io to manage your language access.

  **Output:**
  The node returns all available data including:
  - `translation`: The translated content
  - `token_count`: Number of tokens used
  - `source_language_detected`: Detected source language
  - `model_used`: AI model used for translation
  - `metadata`: Additional metadata
  - `mode`: Translation mode used
  - `input_format`: Input format processed
  - `target_language`: Target language

  #### Language Detection > Detect

  Detect the language of input content.

  **Parameters:**
  - **Input**: Text or HTML content to analyze
  - **Input Format**: Select "Text" or "HTML"

  **Output:**
  - `detected_language`: Two-letter language code of detected language
  - `confidence`: Confidence score (0-1) for the detection
  - `input_format`: Input format processed
  - `input_length`: Length of analyzed content

  #### Language > Get Many

  Fetch the lists of supported and source languages from your FluentC account.

  **Parameters:**
  This operation has no additional parameters. It only requires a configured FluentC API credential.

  **Output:**
  - `supported_languages`: An array of objects, each with `code` and `name` of a language available for translation as a target.
  - `source_languages`: An array of objects, each with `code` and `name` of a language available as a source for translation.

  ## Usage Examples

  ### Basic Translation Workflow

  1. Add a **FluentC** node to your workflow
  2. Select Resource: **Translation**, Operation: **Translate**
  3. Configure it with:
     - Mode: "Real-Time"
     - Input: "Hello, how are you today?"
     - Input Format: "Text"
     - Target Language: Select "Spanish (es)" from dropdown
  4. The output will include the Spanish translation and metadata

  ### Batch Translation for Large Content

  1. Use the **FluentC** node with Resource: **Translation**, Operation: **Translate**
  2. Configure with:
     - Mode: "Batch"
     - Input: Your large HTML or text content
     - Target Language: Your desired language code
  3. The node will automatically poll until the translation is complete

  ### Language Detection Before Translation

  1. Add a **FluentC** node with Resource: **Language Detection**, Operation: **Detect**
  2. Connect it to another **FluentC** node with Resource: **Translation**, Operation: **Translate**
  3. Use the detected language as the source language parameter

  ### Retrieving Language Lists

  1. Add a **FluentC** node with Resource: **Language**, Operation: **Get Many**
  2. Execute the node
  3. The output will contain two arrays: `supported_languages` and `source_languages`, which you can use in other parts of your workflow

  ## Migration from v1.x

  Version 2.0 consolidates the three separate nodes from v1.x into a single **FluentC** node:

  | v1.x Node | v2.0 Resource | v2.0 Operation |
  |---|---|---|
  | FluentC Translate | Translation | Translate |
  | FluentC Check Language | Language Detection | Detect |
  | FluentC Languages | Language | Get Many |

  Existing workflows using the old nodes must be updated manually. Parameter names within each operation remain the same, so expressions referencing fields like `input`, `targetLanguage`, or `mode` should continue to work after migration.

  ## Troubleshooting

  ### Node Not Appearing

  If the node doesn't appear after installation:

  1. **Check Installation Method**: Ensure you used the correct method for your setup
  2. **Restart n8n**: Always restart n8n after manual installation
  3. **Check Directory**: For manual installs, verify the package is in `~/.n8n/nodes/`
  4. **Check Permissions**: Ensure n8n has read permissions for the nodes directory
  5. **Check Logs**: Look at n8n logs for any error messages during startup

  ### Permission Issues

  For Docker installations, you might need to ensure proper permissions:

  ```bash
  # Inside the container
  chown -R node:node ~/.n8n/nodes
  ```

  ### Queue Mode

  If you're running n8n in queue mode, you **must** use manual installation (Method 3).

  ## Error Handling

  The plugin includes comprehensive error handling:

  - **Content Size Validation**: Prevents requests exceeding 100,000 bytes
  - **Batch Timeout Protection**: Limits polling attempts to prevent infinite loops
  - **API Error Handling**: Gracefully handles API errors and rate limits
  - **Continue on Fail**: Option to continue workflow execution even if translation fails

  ## API Rate Limits

  The plugin respects FluentC API rate limits and uses the recommended polling intervals returned by the batch API to avoid overwhelming the service.

  ## Development & Publishing

  This package follows n8n community node standards:

  - ✅ Package name starts with `n8n-nodes-`
  - ✅ Includes `n8n-community-node-package` keyword
  - ✅ No runtime dependencies (only devDependencies)
  - ✅ Proper n8n configuration in package.json
  - ✅ Built TypeScript with proper exports
  - ✅ Single action node with Resource/Operation pattern

  ## Support

  For issues related to this N8N plugin, please check:

  1. **FluentC API Documentation**: https://fluentc.ai/docs
  2. **N8N Community**: https://community.n8n.io
  3. **Plugin Repository**: https://github.com/FluentC/n8n-nodes-fluentc
  4. **n8n Community Nodes Documentation**: https://docs.n8n.io/integrations/community-nodes/

  ## License

  MIT License - see LICENSE file for details.

  ---

  **Note**: You need a valid FluentC API key to use this plugin. API keys are obtained through the FluentC sales website.

ai_documentation_summary:
  {"purpose":"The FluentC Translate node integrates with the FluentC AI Translation API to translate text and HTML content, detect languages, and manage language lists within n8n workflows.","capabilities":["Real-time (synchronous) translation","Batch translation with automatic polling","Text and HTML content translation","Language detection for input content","Supported and source language list retrieval","Dynamic language selection based on API credentials","Comprehensive metadata output including token counts and model information"],"authentication":"API key required (FluentC API key)","commonUseCases":["Multi-language content translation for websites or documents","Real-time chat translation","Batch processing of large content volumes","Language detection for incoming user input","Workflow automation for internationalization tasks"],"limitations":["Input content is limited to a maximum of 100,000 bytes","Batch mode requires manual configuration of max polling attempts","Language selection is restricted to languages enabled in the user's FluentC account"],"relatedNodes":["FluentC Check Language","FluentC Languages","n8n-nodes-fluentc.fluentCTranslate"]}


node_type: n8n-nodes-palatine-speech.palatinespeech
package_name: n8n-nodes-palatine-speech
display_name: palatinespeech
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: palatine_zealot
author_github_url: git+https://github.com/PalatineVision/n8n-nodes-palatine-speech.git
npm_package_name: n8n-nodes-palatine-speech
npm_version: 1.0.1
community_fetched_at: 2026-05-22T09:37:14.370Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  Official n8n node for Palatine Speech API: transcription, diarization, sentiment analysis, summarization and more

npm_readme:
  ![README banner](https://github.com/palatine-vision/n8n-nodes-palatine-speech/blob/main/docs/assets/Header.png)

  # n8n-nodes-palatine-speech

  > Designed for seamless integration of **Palatine Speech API** into n8n workflows.

  This is an n8n community node that integrates [Palatine Speech](https://speech.palatine.ru/) into your workflows and enables audio processing capabilities such as transcription, diarization, sentiment analysis, and summarization.

  ## Navigation

  [Supported Operations](#supported-operations)\
  [Installation](#installation)\
  [Credentials](#credentials)\
  [Workflow Example](#workflow-example)\
  [Use Cases](#use-cases)\
  [Compatibility](#compatibility)\
  [Useful Resources](#useful-resources)\
  [Keywords](#keywords)\
  [License](#license)\
  [Support](#support)

  > Looking for a Russian version? [Here](https://gist.github.com/Valeronich/b5d116fd4ca251ff672eda7d2a530a61)

  ## Supported Operations

  For details on each operation, see the Palatine Speech [documentation](https://docs.speech.palatine.ru/documentation/quick_start/transcription).

  - [Full list of supported file types](https://docs.speech.palatine.ru/documentation/technical_information/supported_files)
  - [Full list of supported languages](https://docs.speech.palatine.ru/documentation/technical_information/supported_languages)

  ### [Transcribe - speech transcription](https://docs.speech.palatine.ru/api-reference/transcribe-polling-api/transcribe)

  Speech-to-Text (STT) converts audio/video into a written transcript.  
  It supports multiple languages and can automatically detect the language spoken in the recording.  
  It is well-suited for calls, interviews, lectures, and any other recordings where an accurate transcript is required.

  ### [Diarize - speaker diarization](https://docs.speech.palatine.ru/api-reference/diarization-polling-api/diarize)

  Speaker diarization segments audio by speaker and labels speaker turns.  
  This is useful for meetings and interviews, where maintaining conversation structure matters.

  ### [Sentiment Analysis - sentiment analysis](https://docs.speech.palatine.ru/api-reference/sentiment-analysis-polling-api/sentiment-analysis)

  Determines the emotional tone of speech in audio/video (and can also analyze text).  
  The result is a ranked list of sentiment classes with probabilities, where the first item is the most likely:  
  `Very Negative`, `Negative`, `Neutral`, `Positive`, `Very Positive`.

  ### [Summarize - audio summarization](https://docs.speech.palatine.ru/api-reference/ai-service/summarize-file)

  Generates a structured summary from audio/video or pre-existing text.  
  In addition to built-in scenarios such as `meeting_summary`, it supports `user_prompt`, allowing you to define custom output structures (bullet points, decisions, action items, risks, Q&A, etc.).

  ### [Message to model - OpenAI-compatible chat](https://docs.speech.palatine.ru/api-reference/chat-completions/chat-completions)

  Generate a response from the Palatine Speech LLM using a list of messages (`system`, `user`, `assistant`).  
  You can select the model, tune generation parameters (`temperature`, `max_tokens`), and optionally enable `thinking` for deeper reasoning.

  Supported response formats:
  - `Text`
  - `JSON Object`
  - `JSON Schema`

  ## Installation

  1. In your n8n instance, go to **Settings > Community Nodes -> Install**
  2. Enter: `n8n-nodes-palatine-speech`
  3. Click **Install**

  > Make sure the environment variable `N8N_COMMUNITY_PACKAGES_ENABLED=true` is set.

  ## Credentials

  1. Go to **Credentials -> + Create**
  2. Find **Palatine Speech API**
  3. Fill in the fields:
     - **API Key** - available in your Palatine Speech dashboard
     - **Base URL** - default is `https://api.palatine.ru`

  ## Workflow Example

  1. `Webhook` -> Receive an audio file
  2. `Config` -> Configure parameters
  3. `Palatine Speech` -> Transcribe the file
  4. `Create record` -> Create a table record
  5. `Telegram` -> Send the result to a chat

  ![workflow example](https://github.com/palatine-vision/n8n-nodes-palatine-speech/blob/main/docs/assets/WorkflowExample.png)

  ## Use Cases

  - **Meeting summaries**  
  Use `Summarize` (`meeting_summary`) to generate summaries, decisions, and action items grouped by owner and due date.  
  Custom prompts can be used for additional structure.

  - **Lecture/webinar notes**  
  Recording -> `Transcribe` -> full transcript saved alongside materials.

  - **Automatic subtitles for video**  
  Extract audio -> `Transcribe` + `Diarize` -> convert to SRT/VTT.

  - **Customer support assistant**  
  Use `Sentiment Analysis` to determine tone and assign ticket priority.

  - **Action items extraction**  
  Use **Message to model** with **JSON Schema** to extract structured tasks (title, owner, due date, priority) and associated risks.  
  Results can be sent to Jira / Notion / Asana or team chat.

  ## Compatibility

  Tested with n8n v1.39.1 and later.

  ## Useful Resources

  - [Palatine Speech documentation](https://docs.speech.palatine.ru/documentation/quick_start/transcription)
  - [n8n Community Nodes guide](https://docs.n8n.io/integrations/community-nodes/)
  - [Official n8n GitHub](https://github.com/n8n-io/n8n)

  ## Keywords

  `n8n-community-node-package`, `n8n`, `palatine`, `speech-to-text`, `transcribe`, `transcription`, `stt`, `audio`, `ai`, `automation`, `voice-to-text`, `speech-recognition`, `audio-transcription`, `audio2text`, `audio-processing`, `diarization`, `speaker-diarization`, `speaker-segmentation`, `summarization`, `audio-summarization`, `sentiment-analysis`, `emotion-detection`, `tone-analysis`, `llm`, `chat-completions`, `openai-compatible`, `structured-output`, `json-schema`

  ## License
  MIT

  ## Support
  Need help? Contact our Telegram support bot: [@Speech_Palatine_Support_Bot](https://t.me/Speech_Palatine_Support_Bot)

ai_documentation_summary:
  {"purpose":"An official n8n community node that integrates the Palatine Speech API to perform audio processing tasks including transcription, diarization, sentiment analysis, and summarization.","capabilities":["Speech-to-text transcription with automatic language detection","Speaker diarization to separate and identify speakers in recordings","Sentiment analysis with ranked emotional tone classification","Audio/video summarization with customizable prompts","Support for multiple file types and languages","Custom prompt engineering for LLM-based summarization"],"authentication":"API Key required (configured via Credentials node)","commonUseCases":["Meeting summaries and action item extraction","Lecture and webinar note generation","Automatic subtitle creation for videos","Customer support ticket prioritization via sentiment analysis"],"limitations":["Requires n8n v1.39.1 or later","Requires enabling community packages in n8n environment (N8N_COMMUNITY_PACKAGES_ENABLED=true)","Base URL must be manually configured (default provided)"],"relatedNodes":["Webhook","Config","Create record","Telegram"]}


node_type: n8n-nodes-evolution.evolution
package_name: n8n-nodes-evolution
display_name: evolution
description: n8n Community Node for Evolution API V2 - WhatsApp Integration Hub (130+ operations)
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: flaviokosta79
author_github_url: git+https://github.com/flaviokosta79/NewEvolutionAPI.git
npm_package_name: n8n-nodes-evolution
npm_version: 1.9.52
community_fetched_at: 2026-05-22T09:37:14.389Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  ﻿# n8n-nodes-evolution

  ![Evolution API](https://github.com/user-attachments/assets/813b7b34-377c-42e8-9f1a-12e27e682c7f)

  <p align="center">
  Community Node para integração completa da <b>Evolution API v2.2+</b> com o <b>n8n</b>.<br>
  Permite automação de WhatsApp com suporte a mensagens, grupos, canais, integrações e muito mais.
  </p>

  <div align="center">
    <img src="https://img.shields.io/badge/version-1.9.29-blue?style=for-the-badge" alt="Version">
    <img src="https://img.shields.io/badge/operations-130+-green?style=for-the-badge" alt="Operations">
    <img src="https://img.shields.io/badge/resources-14-orange?style=for-the-badge" alt="Resources">
  </div>

  ---

  ##  Requisitos

  - **n8n** versão **1.54.4** ou superior
  - **Evolution API** versão **2.2.0** ou superior
  - **Node.js** >= 18.10
  - **pnpm** >= 9.1.4 (para desenvolvimento)

  ---

  ##  Instalação

  ### Via npm (Recomendado)
  ```bash
  npm install n8n-nodes-evolution
  ```

  ### Manual
  1. Clone o repositório
  2. Execute `pnpm install`
  3. Execute `pnpm build`
  4. Copie para a pasta de nodes customizados do n8n

  ---

  ##  Recursos Disponíveis (14)

  ###  Instância
  Gerenciamento completo de instâncias da Evolution API.

  | Operação | Descrição |
  |----------|-----------|
  | Criar Instância | Cria nova instância WhatsApp |
  | Gerar QR-Code | Obtém QR code para conexão |
  | Buscar Instância | Lista instâncias disponíveis |
  | Estado da Conexão | Verifica estado atual |
  | Definir Comportamento | Configura comportamento |
  | Definir Presença | Define status de presença |
  | Definir Proxy | Configura proxy |
  | Buscar Proxy | Obtém configuração de proxy |
  | Desconectar | Desconecta do WhatsApp |
  | Deletar | Remove instância |

  ###  Mensagem
  Envio de diversos tipos de mensagens.

  | Operação | Descrição |
  |----------|-----------|
  | Enviar Texto | Mensagem de texto simples |
  | Enviar Imagem | Envio de imagens |
  | Enviar Vídeo | Envio de vídeos |
  | Enviar Áudio | Envio de áudios |
  | Enviar Documento | Envio de documentos |
  | Enviar Enquete | Criação de enquetes |
  | Enviar Contato | Compartilhamento de contatos |
  | Enviar Lista | Mensagem com lista de opções |
  | Enviar Botão | Mensagem com botões |
  | Enviar Pix | Mensagem de pagamento PIX |
  | Enviar Status | Publicar no status |
  | Reagir | Adicionar reação a mensagem |

  ###  Grupo
  Gerenciamento completo de grupos.

  | Operação | Descrição |
  |----------|-----------|
  | Criar Grupo | Cria novo grupo |
  | Atualizar Imagem | Altera foto do grupo |
  | Atualizar Nome | Altera nome do grupo |
  | Atualizar Descrição | Altera descrição |
  | Atualizar Configurações | Altera configurações |
  | Atualizar Membros | Adiciona/remove membros |
  | Buscar Link de Convite | Obtém link de convite |
  | Revogar Link | Revoga link atual |
  | Enviar Link de Convite | Envia convite |
  | Encontrar Participantes | Lista participantes |
  | Mensagens Temporárias | Configura mensagens temporárias |
  | Sair do Grupo | Remove instância do grupo |
  | Entrar no Grupo | Entra via link de convite |

  ###  Canais (Newsletter)
  Gerenciamento de canais/newsletters do WhatsApp.

  | Operação | Descrição |
  |----------|-----------|
  | Criar Canal | Cria novo canal |
  | Buscar Canais | Lista canais disponíveis |
  | Buscar Mensagens | Lista mensagens do canal |
  | Enviar Texto | Envia texto para canal próprio |
  | Enviar Mídia | Envia imagem/vídeo/áudio/documento |
  | Enviar Enquete | Cria enquete no canal |
  | Enviar Pergunta Q&A | Cria pergunta interativa (⚠️ respostas não disponíveis) |
  | Repostar Mensagem | Reposta de um canal para outro |
  | Info do Convite | Obtém info do código de convite |
  | Seguir | Segue um canal |
  | Deixar de Seguir | Para de seguir |
  | Silenciar | Silencia notificações |
  | Reativar | Reativa notificações |

  > ⚠️ **Limitação do WhatsApp**: Respostas a perguntas Q&A são processadas apenas server-side pelo WhatsApp. Não é possível capturar as respostas dos inscritos via API.

  ###  Comunidade
  Gerenciamento de comunidades WhatsApp.

  | Operação | Descrição |
  |----------|-----------|
  | Criar Comunidade | Cria nova comunidade |
  | Buscar Comunidades | Lista comunidades |
  | Buscar Participantes | Lista membros |
  | Atualizar Participantes | Gerencia membros |
  | Sair da Comunidade | Remove da comunidade |

  ###  Chat
  Operações de chat e mensagens.

  | Operação | Descrição |
  |----------|-----------|
  | Verificar Número | Valida número WhatsApp |
  | Ler Mensagem | Marca como lida |
  | Gerenciar Arquivo | Arquiva/desarquiva |
  | Marcar como Não Lido | Marca conversa |
  | Deletar Mensagem | Remove mensagem |
  | Buscar Foto de Perfil | Obtém foto |
  | Obter Mídia em Base64 | Converte mídia |
  | Editar Mensagem | Edita mensagem enviada |
  | Enviar Presença | Envia status de digitando |
  | Bloquear Contato | Bloqueia/desbloqueia |
  | Buscar Contatos | Lista contatos |
  | Procurar Mensagens | Busca mensagens |
  | Procurar Status | Busca status |
  | Procurar Chats | Lista conversas |
  | Buscar Chat por JID | Busca chat específico |

  ###  Etiquetas
  Gerenciamento de etiquetas (labels).

  | Operação | Descrição |
  |----------|-----------|
  | Criar Etiqueta | Cria nova label |
  | Buscar Etiquetas | Lista labels |
  | Adicionar a Chat | Adiciona label ao chat |
  | Remover de Chat | Remove label do chat |

  ###  Chamadas
  Controle de chamadas de voz.

  | Operação | Descrição |
  |----------|-----------|
  | Simular Chamada | Inicia chamada fake |
  | Buscar Chamadas | Lista chamadas |

  ###  Negócios
  Recursos do WhatsApp Business.

  | Operação | Descrição |
  |----------|-----------|
  | Buscar Catálogo | Lista produtos |
  | Buscar Coleções | Lista coleções |

  ###  Perfil
  Gerenciamento de perfil.

  | Operação | Descrição |
  |----------|-----------|
  | Buscar Perfil | Obtém informações |
  | Atualizar Nome | Altera nome |
  | Atualizar Status | Altera status |
  | Atualizar Foto | Altera foto |
  | Remover Foto | Remove foto |
  | Configurações de Privacidade | Gerencia privacidade |

  ###  Templates (Meta Business)
  Gerenciamento de templates do Meta Business.

  | Operação | Descrição |
  |----------|-----------|
  | Criar Template | Cria novo template |
  | Buscar Templates | Lista templates |

  ###  Armazenamento S3
  Integração com armazenamento S3.

  | Operação | Descrição |
  |----------|-----------|
  | Buscar Mídia | Obtém mídia do S3 |
  | Buscar URL da Mídia | Obtém URL assinada |

  ###  Evento
  Configuração de eventos e integrações.

  | Operação | Descrição |
  |----------|-----------|
  | Webhook | Configura webhook |
  | RabbitMQ | Configura RabbitMQ |
  | WebSocket | Configura WebSocket |
  | SQS | Configura Amazon SQS |
  | NATS | Configura NATS |
  | Pusher | Configura Pusher |
  | Kafka | Configura Apache Kafka |

  ###  Integração
  Integrações com plataformas externas.

  | Operação | Descrição |
  |----------|-----------|
  | Chatwoot | Integração Chatwoot |
  | Evolution Bot | Bot nativo |
  | Typebot | Integração Typebot |
  | Dify | Integração Dify AI |
  | Flowise | Integração Flowise |
  | OpenAI | Integração OpenAI |
  | N8N Bot | Bot do n8n |
  | EvoAI | Integração EvoAI |

  ---

  ##  Cenários de Uso

  ### Workflow Reativo (Webhook)
  Processa mensagens recebidas:
  ```
  Webhook n8n  Processa dados  Evolution API Node  Responde
  ```

  ### Workflow Proativo (Consultas)
  Inicia ações programadas:
  ```
  Schedule/Trigger  Evolution API Node  Busca/Envia dados
  ```

  ---

  ##  Desenvolvimento

  ```bash
  # Instalar dependências
  pnpm install

  # Build de produção
  pnpm build

  # Modo de desenvolvimento (watch)
  pnpm dev

  # Lint
  pnpm lint

  # Lint com correção automática
  pnpm lintfix
  ```

  ---

  ##  Changelog

  ### v1.9.29 (2025-12-06)
  - ❌ **Removido**: Evento `NEWSLETTER_QUESTION_REPLY` (limitação do WhatsApp - respostas Q&A não são enviadas para terceiros)
  - 🧹 Limpeza de código de debug

  ### v1.9.27 (2025-12-02)
  - ✨ **Newsletter Send Question**: Enviar perguntas Q&A para canais próprios
  - ✨ **Newsletter Send Poll**: Enquetes em canais

  ### v1.9.19 (2025-12-01)
  - ✨ **S3 Media URL**: Suporte a `mediaS3Url` no trigger e repost
  - 🔧 Fix: `ignoreOwnNewsletters` default true (evita loop de duplicação)

  ### v1.9.0 (2025-11-30)
  - ✨ **Seleção Dinâmica**: Canais, grupos e instâncias com dropdown
  - ✨ **LoadOptions**: Busca dinâmica via API
  - ✨ **Repost Newsletter**: Reposta mensagens entre canais

  ### v1.8.0 (2025-11-30)
  - ✨ **Repost Newsletter Message**: Reposta de canais seguidos para canais próprios
  - ✨ **Modificar Legenda/Mídia**: Edita conteúdo ao repostar
  - 🔧 Otimização de payload (~40-50% menor)

  ### v1.7.0 (2025-11-27)
  - ✨ **Trigger Node**: Recebe webhooks com endpoint editável
  - ✨ **Auto-extração**: 30+ campos extraídos automaticamente
  - ✨ **Newsletter Media Base64**: Mídia completa no webhook

  ### v1.6.0 (2025-11-28)
  - ✨ **Newsletter Send**: Enviar texto e mídia para canais próprios
  - ✨ **Newsletter Invite Info**: Obter informações de código de convite
  - ✨ **Newsletter Fetch Messages**: Buscar mensagens do canal
  - 🔧 Correções de tipos TypeScript para Newsletter API
  - 📊 **127+ operações** cobrindo toda API

  ### v1.5.0 (2025-11-27)
  - ✨ **Community**: 10 operações adicionais (convites, solicitações, configurações)
  - 🔧 Melhorias no Trigger Node para webhooks

  ### v1.2.0 (2025-11-25)
  -  **14 Recursos** completos
  -  **~114 Operações** cobrindo toda API
  -  Novos: Templates API, S3 API
  -  Novos eventos: WebSocket, SQS, NATS, Pusher, Kafka
  -  Novas integrações: OpenAI, N8N Bot, EvoAI
  -  Newsletter renomeado para "Canais" (localização PT-BR)
  -  Correções de bugs e melhorias de UI

  ### v1.1.0
  - Adicionado suporte a Newsletter/Canais
  - Melhorias no gerenciamento de grupos
  - Novos campos para mensagens

  ### v1.0.0
  - Release inicial
  - Suporte básico a instâncias e mensagens

  ---

  ##  Contribuição

  Contribuições são bem-vindas! Por favor:
  - Abra **Issues** para reportar bugs
  - Envie **Pull Requests** com melhorias
  - Sugira novas funcionalidades

  ---

  ##  Licença

  MIT License - Veja [LICENSE.md](LICENSE.md) para detalhes.

  ---

  <p align="center">
  Desenvolvido com  para a comunidade Evolution API
  </p>

ai_documentation_summary:
  {"purpose":"Provides comprehensive WhatsApp automation capabilities via Evolution API v2.2+, supporting 130+ operations for messaging, groups, channels, and business features.","capabilities":["Send text, image, video, audio, document, contact, list, button, and Pix messages","Create and manage WhatsApp groups (add/remove members, set photos, invite links)","Manage WhatsApp channels and newsletters (post content, polls, Q&A)","Handle WhatsApp communities and participant management","Search and filter messages, chats, and contacts","Edit, delete, or mark messages as read/unread","Manage WhatsApp Business catalogs and collections","Update profile information (name, status, photo, privacy settings)","Simulate voice calls and manage call history","Create and manage message labels/tags"],"authentication":"API key required (Evolution API token)","commonUseCases":["Automated customer support responses via WhatsApp","Broadcast marketing campaigns to groups and channels","Automated lead qualification with interactive buttons and lists","Business catalog management and product updates","Automated status updates and presence simulation"],"limitations":["Q&A channel responses are processed server-side only; individual subscriber responses cannot be captured via API","Requires Evolution API v2.2.0 or higher","Requires n8n version 1.54.4 or higher"],"relatedNodes":["n8n-nodes-whatsapp","n8n-nodes-telegram","n8n-nodes-slack","n8n-nodes-discord"]}


node_type: n8n-nodes-minio.minio
package_name: n8n-nodes-minio
display_name: minio
description: n8n custom nodes for Minio
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: cedricziel
author_github_url: git+https://github.com/cedricziel/n8n-nodes-minio.git
npm_package_name: n8n-nodes-minio
npm_version: 0.1.4
community_fetched_at: 2026-05-22T09:37:14.394Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-minio

  This is an n8n community node. It lets you use the minio client library in your n8n workflows.

  The primary motivation was to create an easy way to create pre-signed URLs easily.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  <!-- delete if no auth needed -->  
  [Compatibility](#compatibility)  
  [Usage](#usage)  <!-- delete if not using this section -->  
  [Resources](#resources)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Operations

  ### Objects

  * `presignedGetObject` - create a presigned URL for an object
  * `presignedPutObject` - create a presigned upload URL for an object
  * `removeObject` - remove an object

  ## Credentials

  To use the minio credentials, you'll need to provide the following:

  * Access Key
  * Secret Key
  * Endpoint

  ## License

  [MIT](./LICENSE.md)

ai_documentation_summary:
  {"purpose":"This n8n community node enables interaction with Minio object storage, primarily for generating pre-signed URLs and managing objects.","capabilities":["Create presigned GET URLs for object download","Create presigned PUT URLs for object upload","Remove objects from storage"],"authentication":"API key required (Access Key and Secret Key)","commonUseCases":["Secure object download via time-limited URLs","Secure object upload via time-limited URLs","Object cleanup and deletion workflows"],"limitations":["Limited to basic object operations (no list, head, or copy operations mentioned)","Community node (may require manual installation)"],"relatedNodes":["n8n-nodes-webhook","n8n-nodes-http-request","n8n-nodes-s3"]}


node_type: n8n-nodes-avisaapi.avisaapi
package_name: n8n-nodes-avisaapi
display_name: avisaapi
description: Integração com o Avisa API para envio de mensagens via WhatsApp
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: avisaapp
author_github_url: git+https://github.com/jonesheckler/n8n-nodes-avisaapi.git
npm_package_name: n8n-nodes-avisaapi
npm_version: 0.2.18
community_fetched_at: 2026-05-22T09:37:14.395Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-avisaapi

  Este é um nó personalizado para n8n que permite integração com o [Avisa API](https://www.avisaapi.com.br), uma plataforma de comunicação via WhatsApp para envio de mensagens, documentos e mídia.

  ## Funcionalidades

  - Envio de mensagens de texto
  - Envio de documentos em base64
  - Envio de imagens em base64
  - Envio de mídia (imagem/vídeo/áudio) via URL
  - Verificação de status da instância
  - Obtenção de QR Code para conexão

  ## Sobre o Avisa API

  O Avisa API é uma plataforma que permite o envio de notificações agendadas e simples via WhatsApp. Para mais informações e para obter sua chave de API, visite [https://www.avisaapi.com.br](https://www.avisaapi.com.br).

  ## Instalação

  Para usar este nó, você precisará:

  1. Ter uma conta no [Avisa API](https://www.avisaapi.com.br)
  2. Obter sua chave de API no painel do Avisa API
  3. Instalar este pacote no seu n8n

  ## Prerequisites

  You need the following installed on your development machine:

  * [git](https://git-scm.com/downloads)
  * Node.js and pnpm. Minimum version Node 18. You can find instructions on how to install both using nvm (Node Version Manager) for Linux, Mac, and WSL [here](https://github.com/nvm-sh/nvm). For Windows users, refer to Microsoft's guide to [Install NodeJS on Windows](https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows).
  * Install n8n with:
    ```
    pnpm install n8n -g
    ```
  * Recommended: follow n8n's guide to [set up your development environment](https://docs.n8n.io/integrations/creating-nodes/build/node-development-environment/).

  ## Using this starter

  These are the basic steps for working with the starter. For detailed guidance on creating and publishing nodes, refer to the [documentation](https://docs.n8n.io/integrations/creating-nodes/).

  1. [Generate a new repository](https://github.com/n8n-io/n8n-nodes-starter/generate) from this template repository.
  2. Clone your new repo:
     ```
     git clone https://github.com/<your organization>/<your-repo-name>.git
     ```
  3. Run `pnpm i` to install dependencies.
  4. Open the project in your editor.
  5. Browse the examples in `/nodes` and `/credentials`. Modify the examples, or replace them with your own nodes.
  6. Update the `package.json` to match your details.
  7. Run `pnpm lint` to check for errors or `pnpm lintfix` to automatically fix errors when possible.
  8. Test your node locally. Refer to [Run your node locally](https://docs.n8n.io/integrations/creating-nodes/test/run-node-locally/) for guidance.
  9. Replace this README with documentation for your node. Use the [README_TEMPLATE](README_TEMPLATE.md) to get started.
  10. Update the LICENSE file to use your details.
  11. [Publish](https://docs.npmjs.com/packages-and-modules/contributing-packages-to-the-registry) your package to npm.

  ## More information

  Refer to our [documentation on creating nodes](https://docs.n8n.io/integrations/creating-nodes/) for detailed information on building your own nodes.

  ## License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

ai_documentation_summary:
  {"purpose":"Integrates with the Avisa API to enable sending text messages, documents, images, and media files via WhatsApp through n8n workflows.","capabilities":["Send text messages","Send documents in base64 format","Send images in base64 format","Send media (image/video/audio) via URL","Check instance status","Retrieve QR code for connection"],"authentication":"API key required","commonUseCases":["Automated WhatsApp notifications","Sending documents and media to clients","Scheduled WhatsApp messages"],"limitations":[],"relatedNodes":[]}


node_type: n8n-nodes-google-gemini-embeddings-extended.googlegeminiembeddingsextended
package_name: n8n-nodes-google-gemini-embeddings-extended
display_name: googlegeminiembeddingsextended
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: resettech
author_github_url: git+https://github.com/ResetNetwork/n8n-nodes.git
npm_package_name: n8n-nodes-google-gemini-embeddings-extended
npm_version: 0.2.3
community_fetched_at: 2026-05-22T09:37:14.399Z
ai_summary_generated_at: 2026-05-02 08:57:17
description:
  n8n community sub-node for Google Gemini Embeddings with extended features like output dimensions support

npm_readme:
  # n8n-nodes-google-gemini-embeddings-extended

  This is an n8n community sub-node that provides Google Gemini Embeddings with extended features, including support for task types, titles, and optimized handling for different Google embedding models.

  ## Features

  - Support for any Google Gemini embedding model (dynamically loaded from Google's API)
  - **Task type specification** for optimized embeddings (RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, etc.)
  - **Title support** for retrieval documents (improves embedding quality)
  - **Optimized API handling** using official @google/genai library
  - Uses standard Google API credentials (same as other Google AI nodes)
  - Works as a sub-node with vector stores and other AI nodes
  - Clean, production-ready implementation

  ## Installation

  ### Community Node (Recommended)

  1. In n8n, go to **Settings** > **Community Nodes**
  2. Search for `n8n-nodes-google-gemini-embeddings-extended`
  3. Click **Install**

  ### Manual Installation

  ```bash
  npm install n8n-nodes-google-gemini-embeddings-extended
  ```

  ## Setup

  ### Prerequisites

  1. A Google AI Studio account
  2. A Gemini API key

  ### Authentication

  This node uses the standard Google PaLM/Gemini API credentials:

  1. Get your API key from [Google AI Studio](https://aistudio.google.com/app/apikey)
  2. In n8n, create **Google PaLM API** credentials
  3. Enter your API key

  ## Usage

  This is a **sub-node** that provides embeddings functionality to other n8n AI nodes.

  ### Using with Vector Stores

  1. Add a vector store node to your workflow (e.g., Pinecone, Qdrant, Supabase Vector Store)
  2. Connect the **Embeddings Google Gemini Extended** node to the embeddings input of the vector store
  3. Configure your Google PaLM API credentials
  4. Enter your model name (e.g., `text-embedding-004`, `gemini-embedding-001`)
  5. Configure additional options as needed
  6. The vector store will use these embeddings to process your documents

  ### Example Workflow

  ```
  [Document Loader] → [Vector Store] ← [Embeddings Google Gemini Extended]
                            ↓
                      [AI Agent/Chain]
  ```

  ### Configuration Options

  #### Model Name

  Select any valid Google Gemini embedding model from the dropdown (dynamically loaded from Google's API). Examples:
  - `text-embedding-004` (Latest model, 768 default dimensions)
  - `gemini-embedding-001` (Advanced model, 3072 default dimensions)
  - `embedding-001` (Legacy model, 768 default dimensions)

  #### Task Types

  Optimize your embeddings by specifying the task type:

  - **Retrieval Document**: For document storage in retrieval systems
  - **Retrieval Query**: For search queries
  - **Semantic Similarity**: For comparing text similarity
  - **Classification**: For text classification tasks
  - **Clustering**: For grouping similar texts
  - **Question Answering**: For Q&A systems
  - **Fact Verification**: For fact-checking applications
  - **Code Retrieval Query**: For code search

  #### Additional Options

  - **Title**: Add a title to documents (only for RETRIEVAL_DOCUMENT task type)
  - **Strip New Lines**: Remove line breaks from input text (enabled by default)

  ## Use Cases

  - **Semantic Search**: Generate embeddings for documents and queries in vector stores
  - **RAG Applications**: Build retrieval-augmented generation systems
  - **Document Similarity**: Find similar documents in your vector database
  - **Multi-language Support**: Use models that support multiple languages
  - **Code Search**: Use CODE_RETRIEVAL_QUERY for searching code repositories

  ## Model-Specific Notes

  ### gemini-embedding-001

  - Advanced model with 3072 default dimensions
  - High-quality embeddings for complex use cases
  - Optimized for semantic similarity and retrieval tasks

  ### text-embedding-004

  - Supports batch processing
  - Default dimensions: 768
  - Good balance of performance and quality

  ## Differences from Official n8n Node

  This community node extends the official Google Gemini Embeddings node with:

  1. **Extended Task Types**: More task type options for embedding optimization
  2. **Title Support**: Add titles to documents for better retrieval quality
  3. **Official Library**: Uses @google/genai library for better compatibility
  4. **Model Flexibility**: Dynamic model loading from Google's available models
  5. **Production Ready**: Clean implementation with optional debug logging

  ## Compatible Nodes

  This embeddings node can be used with:

  - Simple Vector Store
  - Pinecone Vector Store
  - Qdrant Vector Store
  - Supabase Vector Store
  - PGVector Vector Store
  - Milvus Vector Store
  - MongoDB Atlas Vector Store
  - Zep Vector Store
  - Question and Answer Chain
  - AI Agent nodes

  ## Troubleshooting

  ### Common Issues

  1. **Authentication Errors**
     - Ensure your Google PaLM API key is valid
     - Check that the API is enabled in your Google Cloud project
     - Verify you have sufficient quota

  2. **Model Errors**
     - Verify the model name is spelled correctly
     - Check [Google's documentation](https://ai.google.dev/gemini-api/docs/models/gemini#text-embedding) for valid model names

  3. **Rate Limit Errors**
     - Add delays between requests if processing large datasets
     - Check your Google API quota and rate limits

  4. **Bad Request Errors**
     - Ensure text inputs are within token limits
     - Verify model names are valid and available

  ## Contributing

  Contributions are welcome! Please feel free to submit a Pull Request.

  ## License

  MIT

  ## Support

  For issues and feature requests, please use the [GitHub issue tracker](https://github.com/danblah/n8n-nodes-google-gemini-embeddings-extended/issues).

  ## Changelog

  ### 0.1.2
  - Version bump for republishing to ensure package visibility

  ### 0.1.1
  - Updated all dependencies to latest versions
  - Fixed TypeScript compatibility issues
  - Updated ESLint configuration for ESLint 9.x
  - Updated `@langchain/google-genai` from 0.0.23 to 0.2.10
  - Updated `n8n-workflow` peer dependency to match current version (1.82.0)
  - Improved build stability and security

  ### 0.1.0
  - Initial release
  - Support for Google Gemini embeddings via API
  - Output dimensions configuration
  - Task type selection with extended options
  - Title support for documents
  - Batch size control
  - Special handling for gemini-embedding-001 

ai_documentation_summary:
  {"purpose":"Provides Google Gemini Embeddings with extended features like task type specification, title support, and optimized handling for various embedding models.","capabilities":["Support for any Google Gemini embedding model dynamically loaded from API","Task type specification (RETRIEVAL_DOCUMENT, RETRIEVAL_QUERY, etc.)","Title support for retrieval documents to improve embedding quality","Optimized API handling using official @google/genai library","Batch processing support","Multi-language support","Code retrieval query capability"],"authentication":"API key required (Google PaLM API credentials)","commonUseCases":["Semantic search in vector stores","Retrieval-augmented generation (RAG) applications","Document similarity analysis","Code search and retrieval","Multi-language text embedding"],"limitations":["Requires Google AI Studio account and API key","Subject to Google API quota and rate limits","Input text must be within token limits of the selected model","Title support only available for RETRIEVAL_DOCUMENT task type"],"relatedNodes":["Simple Vector Store","Pinecone Vector Store","Qdrant Vector Store","Supabase Vector Store","PGVector Vector Store"]}


node_type: n8n-nodes-datadog.datadog
package_name: n8n-nodes-datadog
display_name: datadog
description: n8n node for datadog logging
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: mdasberg
author_github_url: git+https://github.com/team-carepay/n8n-nodes-datadog.git
npm_package_name: n8n-nodes-datadog
npm_version: 1.4.0
community_fetched_at: 2026-05-22T09:37:14.402Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-datadog

  <img src="https://n8n.io/images/nodes/n8n.svg" width="100" height="100"/>
  <img src="https://raw.githubusercontent.com/team-carepay/n8n-nodes-datadog/main/nodes/LogToDatadog/dd_logo_v_rgb.svg" width="100" height="100"/>

  A community node for integrating Datadog with n8n, the workflow automation tool. This node allows you to interact with Datadog's API to log messages from your n8n workflows.

  ## Features

  - **Logs**: Send logs to Datadog.

  ## Installation

  To install the node, follow these steps:

  1. Navigate to your n8n installation directory.
  2. Install the node package:

     ```bash
     npm install n8n-nodes-datadog
     ```
  3. Start or restart your n8n instance.   

  ## Configuration
  Before using the Datadog node, you need to configure the Datadog API credentials in n8n.

  1. Go to the n8n Credentials section.
  2. Add new credentials and select "Datadog API".
  3. Enter your Datadog API key.
  4. Save the credentials.

  ## Usage
  Once the credentials are set up, you can use the `Log messages to Datadog` node in your workflows.

  1. **Add the `Log messages to Datadog` node**: Drag and drop the `Log messages to Datadog` node into your workflow.
  2. **Select credentials to connect with** : Choose the credentials you configured in the previous step.
  3. **Configure Parameters**: Condition, success and failure messages, tags and service name.
  4. Execute Workflow: Run your workflow to interact with Datadog.

  ## License
  This project is licensed under the MIT License. See the [LICENSE](https://github.com/team-carepay/n8n-nodes-datadog/blob/main/LICENSE.md) file for details.

ai_documentation_summary:
  {"purpose":"Enables n8n workflows to send log messages to Datadog for monitoring and observability.","capabilities":["Send logs to Datadog","Configure success and failure messages","Add custom tags to logs","Specify service name for logs"],"authentication":"API key required","commonUseCases":["Track workflow execution status","Monitor custom business logic events","Debug workflow issues via Datadog dashboards"],"limitations":[],"relatedNodes":[]}


node_type: n8n-nodes-difyai.difyai
package_name: n8n-nodes-difyai
display_name: difyai
description: Community node for Dify API
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: axyonsoftwares
author_github_url: git+https://github.com/gabrielbuarque/n8n-nodes-difyai.git
npm_package_name: n8n-nodes-difyai
npm_version: 0.1.31
community_fetched_at: 2026-05-22T09:37:14.404Z
ai_summary_generated_at: 2026-03-25 22:47:20
npm_readme:
  # n8n-nodes-difyai

  [![npm version](https://img.shields.io/npm/v/n8n-nodes-difyai.svg)](https://www.npmjs.com/package/n8n-nodes-difyai)
  [![License: MIT](https://img.shields.io/npm/l/n8n-nodes-difyai.svg)](LICENSE)

  Este pacote é um nó da comunidade para o [n8n](https://n8n.io) que integra a **Dify API**.  
  Ele permite enviar mensagens de chat, converter áudio em texto e fazer upload de arquivos diretamente pela API do Dify.

  ## Funcionalidades

  - **Enviar Mensagem de Chat:**  
    Envie mensagens de chat para a API do Dify com suporte aos modos de resposta *streaming* ou *blocking*.  
    Suporta o envio de arquivos via configuração dinâmica (com opções para URLs remotas ou uploads locais).

  - **Áudio para Texto:**  
    Converta arquivos de áudio em texto enviando dados binários.

  - **Upload de Arquivo:**  
    Faça upload de arquivos utilizando `multipart/form-data`.

  ## Instalação no n8n

  Para instalar este nó da comunidade no n8n:

  1. **Acesse as Configurações do n8n:**
     - No editor do n8n, vá para `Settings` > `Community Nodes`.

  2. **Instale o Nó da Comunidade:**
     - Clique em `Install`.
     - No campo `Enter npm package name`, insira `n8n-nodes-difyai`.
     - Marque a opção `I understand the risks of installing unverified code from a public source`.
     - Clique em `Install` para concluir a instalação.

  Para mais detalhes sobre a instalação de nós da comunidade, consulte a [documentação oficial do n8n](https://docs.n8n.io/integrations/community-nodes/installation/).

  ## Configuração de Credenciais

  Antes de usar o nó, configure as credenciais do **DifyApi** no n8n:

  - **Base URL:**  
    Informe a URL base da API do Dify, por exemplo:  
    `https://dify.com/v1`  
    (O nó força HTTPS e garante que a URL termine com `/v1`)

  - **API Key:**  
    Sua chave de API fornecida pelo Dify.

  ## Operações do Nó

  ### 1. Enviar Mensagem de Chat

  Envie uma requisição de mensagem de chat para a API do Dify.

  **Parâmetros:**

  - **User ID:** Identificador único do usuário.
  - **Query:** Conteúdo da mensagem de chat.
  - **Conversation ID:** (Opcional) ID da conversa para continuidade.
  - **Response Mode:** Selecione entre *Streaming* e *Blocking*.
  - **Files:** (Opcional) Adicione um ou mais arquivos.  
    Para cada arquivo, configure:
    - **Type:** Tipo do arquivo (Áudio, Personalizado, Documento, Imagem, Vídeo).
    - **Transfer Method:** Selecione entre *Remote URL* e *Local File*.
    - **URL:** (Exibido quando *Remote URL* é selecionado) Forneça a URL do arquivo.
    - **Upload File ID:** (Exibido quando *Local File* é selecionado) Forneça o ID do arquivo enviado via API de Upload de Arquivo.

  ### 2. Áudio para Texto

  Converta um arquivo de áudio em texto.

  - Utilize o campo **Binary Property** para informar o nome da propriedade binária que contém o arquivo de áudio.
  - O nó envia o arquivo para a API e retorna o texto convertido.

  ### 3. Upload de Arquivo

  Faça upload de um arquivo para a API do Dify.

  - Utilize o campo **Binary Property** para informar o nome da propriedade binária que contém o arquivo.
  - O nó realiza o upload e retorna os detalhes do arquivo (ID, nome, tamanho, etc.).

  ## Uso no n8n

  1. **Adicione o nó DifyAI** ao seu workflow no editor do n8n.
  2. **Selecione a operação desejada** (Enviar Mensagem de Chat, Áudio para Texto ou Upload de Arquivo).
  3. **Configure os parâmetros do nó** e atribua as credenciais **DifyApi**.
  4. **Conecte o nó** ao seu fluxo de trabalho e execute-o para interagir com a API do Dify.

  ## Licença

  Este pacote é licenciado sob a [Licença MIT](LICENSE).

  ---

  Para mais informações sobre a instalação e uso de nós da comunidade no n8n, consulte a [documentação oficial](https://docs.n8n.io/integrations/community-nodes/installation/).

ai_documentation_summary:
  {"purpose":"A community n8n node that integrates with the Dify API to enable chat messaging, audio-to-text conversion, and file uploads.","capabilities":["Send chat messages with streaming or blocking response modes","Upload files via multipart/form-data (remote URLs or local files)","Convert audio files to text using binary data","Support multiple file types (audio, custom, document, image, video)","Maintain conversation context via conversation IDs"],"authentication":"API Key required (Base URL and API Key configuration)","commonUseCases":["Chatbot integration with Dify","Audio transcription workflows","Document processing and file management"],"limitations":["Community node (unverified code from public source)","Requires manual installation via npm package manager","File uploads require specific binary property configuration"],"relatedNodes":["n8n-nodes-http.request","n8n-nodes-binaryData","n8n-nodes-ai"]}


node_type: n8n-nodes-soaprequest.soaprequest
package_name: n8n-nodes-soaprequest
display_name: soaprequest
description: n8n node for soap requests
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: mdasberg
author_github_url: git+https://github.com/team-carepay/n8n-nodes-soaprequest.git
npm_package_name: n8n-nodes-soaprequest
npm_version: 1.1.0
community_fetched_at: 2026-05-22T09:37:14.405Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-soaprequest

  <img src="https://n8n.io/images/nodes/n8n.svg" width="100" height="100"/>

  A community node for making soap requests with n8n, the workflow automation tool. This node allows
  you to not worry about the soap boilerplate in your n8n workflows.

  ## Features

  - **request**: Send a soap request.
  - **interpolate**: In order to not hardcode credentials in either the **soap:Body** or **soap:Header**, you
    can use the `interpolate` function. This allows you to use **_{{ $credentials.username }}_** and **_{{
    $credentials.password }}_** in your template and it will be interpolated with the selected SOAP API
    credentials.

  ## Installation

  To install the node, follow these steps:

  1. Navigate to your n8n installation directory.
  2. Install the node package:

  ```bash
  npm install n8n-nodes-soaprequest
  ```
  3. Start or restart your n8n instance.

  ## Configuration

  Before using the SOAP Request node, you need to configure the Soap API credentials in n8n.

  1. Go to the n8n Credentials section.
  2. Add new credentials and select "Soap API".
  3. Enter your credentials.
  4. Save the credentials.

  ## Usage

  Once the credentials are set up, you can use the `SOAP Request` node in your workflows.

  1. **Add the `SOAP Request` node**: Drag and drop the `SOAP Request` node into your workflow.
  2. **Select credentials to connect with** : Choose the credentials you configured in the previous
     step.
  3. **Configure Parameters**: set the right parameters for your soap request.
  4. Execute Workflow: Run your workflow to make a soap request.

  ## License

  This project is licensed under the MIT License. See
  the [LICENSE](https://github.com/team-carepay/n8n-nodes-soaprequest/blob/main/LICENSE.md) file for details.

ai_documentation_summary:
  {"purpose":"This community node simplifies making SOAP requests within n8n workflows by handling the necessary SOAP boilerplate code.","capabilities":["Send SOAP requests","Interpolate credentials in SOAP body and header using {{ $credentials.username }} and {{ $credentials.password }}"],"authentication":"Soap API credentials required","commonUseCases":["Integrating with legacy enterprise systems that use SOAP","Automating data exchange between services via SOAP protocols"],"limitations":[],"relatedNodes":[]}


node_type: n8n-nodes-twenty.twenty
package_name: n8n-nodes-twenty
display_name: twenty
description: n8n node to call Twenty CRM's API
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: hodgolabs
author_github_url: git+https://github.com/shodgson/n8n-nodes-twenty.git
npm_package_name: n8n-nodes-twenty
npm_version: 0.0.5
community_fetched_at: 2026-05-22T09:37:14.408Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-twenty

  This is an n8n community node. It lets you use **Twenty CRM** in your n8n workflows.

  [Twenty CRM](https://twenty.com/) is an open-source CRM (customer relationship management) tool that is under rapid development. Please consider this as a **Beta** release that is likely to break with future changes in the Twenty API.

  [n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.

  [Installation](#installation)  
  [Operations](#operations)  
  [Credentials](#credentials)  
  [Compatibility](#compatibility)  
  [Resources](#resources)  
  [Credit](#credit)  
  [Version history](#version-history)  

  ## Installation

  Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.

  ## Operations
  	- General
  	- Api Keys
  	- Attachments
  	- Blocklists
  	- Calendar Channel Event Associations
  	- Calendar Channels
  	- Calendar Event Participants
  	- Calendar Events
  	- Companies
  	- Connected Accounts
  	- Favorite Folders
  	- Favorites
  	- Message Channel Message Associations
  	- Message Channels
  	- Message Folders
  	- Message Participants
  	- Messages
  	- Message Threads
  	- Notes
  	- Note Targets
  	- Opportunities
  	- People
  	- Tasks
  	- Task Targets
  	- Timeline Activities
  	- View Fields
  	- View Filter Groups
  	- View Filters
  	- View Groups
  	- Views
  	- View Sorts
  	- Webhooks
  	- Workflow Automated Triggers
  	- Workflow Runs
  	- Workflows
  	- Workflow Versions
  	- Workspace Members

  ## Credentials

  Generate an API key in Twenty by following the [Twenty docs](https://twenty.com/user-guide/section/functions/api-webhooks). In summary, create an API key in the Settings -> Developers section.

  Copy the API key. Click 'Add Credential' in n8n and search for 'Twenty API'. Provide the API key and your Twenty domain (e.g. http://localhost:5020, https://n8n.example.org). Do _not_ use the 'API Base URL', e.g. https://n8n.example.org/rest/.

  ## Compatibility

  Compatible and tested with Twenty v1.0.3 and n8n v1.91.3.

  ## Resources

  * [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
  * [Twenty developer documentation](https://twenty.com/developers/)

  ## Version history

  #### v0.0.5
  Simplified to build on n8n-openapi-node

  #### v0.0.4
  Compatible with Twenty's updated API in v0.40.7

  #### v0.0.3
  Compatible with Twenty's updated API in v0.33.4

  #### v0.0.1
  Initial release

  ## Credit

  Almost all credit goes to [devlikeapro](https://github.com/devlikeapro/n8n-openapi-node) for the work on generic n8n nodebuilders for OpenAPI specs. Previous versions relied on similar tools from [ivov](https://github.com/ivov) and [feelgood-interface](https://github.com/feelgood-interface).

ai_documentation_summary:
  {"purpose":"This n8n community node enables integration with Twenty CRM, an open-source customer relationship management tool, allowing users to manage CRM data within n8n workflows.","capabilities":["Manage API keys","Handle attachments","Manage blocklists","Associate calendar channel events","Manage calendar channels","Manage calendar event participants","Manage calendar events","Manage companies","Manage connected accounts","Manage favorite folders"],"authentication":"API key required","commonUseCases":["Automate CRM data entry and retrieval","Sync contacts and companies with other systems","Automate task creation based on workflow triggers","Manage calendar events and participants","Handle message and note management"],"limitations":["Beta release likely to break with future changes in the Twenty API","Compatible only with Twenty v1.0.3 and n8n v1.91.3","Requires manual API key generation in Twenty settings"],"relatedNodes":[]}


node_type: n8n-nodes-quepasa.quepasa
package_name: n8n-nodes-quepasa
display_name: quepasa
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: hugodeco
author_github_url: git+https://github.com/sufficit/n8n-nodes-quepasa.git
npm_package_name: n8n-nodes-quepasa
npm_version: 0.1.85
community_fetched_at: 2026-05-22T09:37:14.413Z
ai_summary_generated_at: 2026-03-25 22:47:20
description:
  This is an n8n community node. It lets you use Quepasa in your n8n workflows. (use with Quepasa >= v4)

npm_readme:
  ![Banner image](https://user-images.githubusercontent.com/10284570/173569848-c624317f-42b1-45a6-ab09-f0ea3c247648.png)

  # n8n-nodes-starter

  This repo contains example nodes to help you get started building your own custom integrations for [n8n](n8n.io). It includes the node linter and other dependencies.

  To make your custom node available to the community, you must create it as an npm package, and [submit it to the npm registry](https://docs.npmjs.com/packages-and-modules/contributing-packages-to-the-registry).

  ## Version Changes (0.1.65)

  * in reply to send text messages (missing)

  ## Version Changes (0.1.64)

  * in reply to send messages with attachments

  ## Version Changes (0.1.62)

  * revoke message

  ## Version Changes (0.1.60)

  * message id on sent

  ## Version Changes (0.1.58)

  * error status message

  ## Version Changes (0.1.57)

  * download endpoint to v4 with messageid paramater

  ## Prerequisites

  You need the following installed on your development machine:

  * [git](https://git-scm.com/downloads)
  * Node.js and npm. Minimum version Node 16. You can find instructions on how to install both using nvm (Node Version Manager) for Linux, Mac, and WSL [here](https://github.com/nvm-sh/nvm). For Windows users, refer to Microsoft's guide to [Install NodeJS on Windows](https://docs.microsoft.com/en-us/windows/dev-environment/javascript/nodejs-on-windows).
  * Install n8n with:
  	```
  	npm install n8n -g
  	```
  * Recommended: follow n8n's guide to [set up your development environment](https://docs.n8n.io/integrations/creating-nodes/build/node-development-environment/).

  ## License

  [MIT](https://github.com/n8n-io/n8n-nodes-starter/blob/master/LICENSE.md)

ai_documentation_summary:
  {"purpose":"This n8n community node enables users to integrate Quepasa (version 4+) into their n8n workflows for messaging and communication tasks.","capabilities":["Send text messages","Send messages with attachments","Revoke messages","Retrieve message IDs on sent","Download messages via v4 endpoint"],"authentication":"API key required (implied by Quepasa integration pattern, not explicitly detailed in README)","commonUseCases":["Automated customer support messaging","Internal team communication automation","Message archiving and retrieval","Attachment-based notifications"],"limitations":["Requires Quepasa client version >= v4","Community node (may lack official support)","Requires manual npm package submission for community availability"],"relatedNodes":["n8n-nodes-webhook","n8n-nodes-http-request","n8n-nodes-ai"]}


node_type: n8n-nodes-whatghl.whatghl
package_name: n8n-nodes-whatghl
display_name: whatghl
description: Community nodes for WhatGHL integration in n8n.
category: Community
development_style: declarative
version: 1
properties_schema: []
operations: []
credentials_required: []
updated_at: 2026-05-22 09:37:14
author_name: gusgeneriss
author_github_url: git+https://github.com/whatghl/n8n-nodes-whatghl.git
npm_package_name: n8n-nodes-whatghl
npm_version: 0.1.107
community_fetched_at: 2026-05-22T09:37:14.414Z
ai_summary_generated_at: 2026-05-02 08:57:17
npm_readme:
  # n8n-nodes-whatghl

  Community nodes for integrating n8n with WhatGHL.

  ## Included nodes

  - `WhatGHL Trigger`: receives webhook events forwarded by WhatGHL (`n8n_webhook_url` in subaccount config).
  - `WhatGHL`: sends actions to `POST /actions` using subaccount API key.

  ## Installation in n8n

  1. Open **Settings -> Community Nodes** in your n8n instance.
  2. Click **Install**.
  3. Use package name: `n8n-nodes-whatghl`.
  4. Restart n8n if prompted.

  ## Credentials

  Create `WhatGHL API` credentials in n8n:

  - `Base URL`: your WhatGHL API base URL (example `https://api.yourdomain.com`)
  - `API Key`: `n8n_api_key` generated for the target subaccount

  ## Actions supported

  - Send Text / Image / Video
  - Send Voice / File
  - Send Reaction
  - Send Seen
  - Start Typing / Stop Typing
  - Get All Labels
  - Create Label / Update Label / Delete Label
  - Get Labels For Chat / Save Labels For Chat
  - Get Chats By Label
  - Custom Action (raw payload to `/actions`)

  ### Session selection (multi-session subaccounts)

  - `Session Mode = Auto` (default fallback): backend selects a session automatically.
  - `Session Mode = By Session Name`: the node sends `sessionName` to `/actions`.
  - `Session Mode = Select Session (Recommended)`: pick a session from available sessions for the API key; node sends `sessionId`.
  - `Session Name` supports n8n expressions, for example `{{$json.sessionName}}`.

  Example payload sent by the node (when session is selected):

  ```json
  {
    "action": "send_message",
    "sessionName": "Session1-0da2bdfd",
    "chatId": "<provided-by-workflow>",
    "content": "Hello from selected session",
    "type": "text"
  }
  ```

  ## Trigger payload

  Expected body from WhatGHL relay:

  ```json
  {
    "subaccountId": "sub_123",
    "sessionName": "AI_US",
    "event": "message.received",
    "sourceEvent": "message",
    "relayReason": "canonical_inbound",
    "type": "message.received",
    "timestamp": 1700000000000,
    "payload": {}
  }
  ```

  ### Recommended trigger branches

  - Business automation: use `message.received` as the single inbound source.
  - Delivery/read tracking: use `message.ack`.
  - Technical diagnostics only: use `engine.event`.
  - In canonical backend policy, duplicated inbound `engine.event -> events.Message` is filtered.

  ## License

  MIT

ai_documentation_summary:
  {"purpose":"Provides n8n integration for WhatGHL, enabling two-way communication between n8n workflows and WhatGHL subaccounts via webhooks and API actions.","capabilities":["Receive webhook events from WhatGHL","Send text, image, and video messages","Send voice messages and files","Send reactions and seen status","Manage typing indicators (start/stop)","Create, update, and delete labels","Retrieve labels for specific chats","Get chats filtered by label","Execute custom raw API actions"],"authentication":"API key required","commonUseCases":["Automated customer support responses","Broadcasting messages to specific user sessions","Chat categorization and labeling workflows","Message status tracking (read receipts)"],"limitations":["Requires a WhatGHL subaccount with API access","Multi-session subaccounts require manual or expression-based session selection"],"relatedNodes":[]}


