# nodes

node_type: n8n-nodes-base.TimescaleDb
name: TimescaleDb
display_name: TimescaleDB
description: Add and update data in TimescaleDB
category: input
icon: file:timescale.svg
code_hash: 713e4569856e0462795d8d821badaf29b960c59683cb71520ce0d1e709b5c921
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.timescaledb
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:33
updated_at: 2025-06-08 09:18:33
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.TimescaleDb = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const genericFunctions_1 = require("../Postgres/v1/genericFunctions");
  const pg_promise_1 = __importDefault(require("pg-promise"));
  class TimescaleDb {
      constructor() {
          this.description = {
              displayName: 'TimescaleDB',
              name: 'timescaleDb',
              icon: 'file:timescale.svg',
              group: ['input'],
              version: 1,
              description: 'Add and update data in TimescaleDB',
              defaults: {
                  name: 'TimescaleDB',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'timescaleDb',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      options: [
                          {
                              name: 'Execute Query',
                              value: 'executeQuery',
                              description: 'Execute an SQL query',
                              action: 'Execute a SQL query',
                          },
                          {
                              name: 'Insert',
                              value: 'insert',
                              description: 'Insert rows in database',
                              action: 'Insert rows in database',
                          },
                          {
                              name: 'Update',
                              value: 'update',
                              description: 'Update rows in database',
                              action: 'Update rows in database',
                          },
                      ],
                      default: 'insert',
                  },
                  {
                      displayName: 'Query',
                      name: 'query',
                      type: 'string',
                      noDataExpression: true,
                      typeOptions: {
                          editor: 'sqlEditor',
                          rows: 5,
                          sqlDialect: 'PostgreSQL',
                      },
                      displayOptions: {
                          show: {
                              operation: ['executeQuery'],
                          },
                      },
                      default: '',
                      placeholder: 'SELECT id, name FROM product WHERE quantity > $1 AND price <= $2',
                      required: true,
                      description: 'The SQL query to execute. You can use n8n expressions or $1 and $2 in conjunction with query parameters.',
                  },
                  {
                      displayName: 'Schema',
                      name: 'schema',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                      default: 'public',
                      required: true,
                      description: 'Name of the schema the table belongs to',
                  },
                  {
                      displayName: 'Table',
                      name: 'table',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the table in which to insert data to',
                  },
                  {
                      displayName: 'Columns',
                      name: 'columns',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                      default: '',
                      placeholder: 'id,name,description',
                      description: 'Comma-separated list of the properties which should used as columns for the new rows',
                  },
                  {
                      displayName: 'Schema',
                      name: 'schema',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['update'],
                          },
                      },
                      default: 'public',
                      required: true,
                      description: 'Name of the schema the table belongs to',
                  },
                  {
                      displayName: 'Table',
                      name: 'table',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['update'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the table in which to update data in',
                  },
                  {
                      displayName: 'Update Key',
                      name: 'updateKey',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['update'],
                          },
                      },
                      default: 'id',
                      required: true,
                      description: 'Name of the property which decides which rows in the database should be updated. Normally that would be "id".',
                  },
                  {
                      displayName: 'Columns',
                      name: 'columns',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['update'],
                          },
                      },
                      default: '',
                      placeholder: 'name,description',
                      description: 'Comma-separated list of the properties which should used as columns for rows to update',
                  },
                  {
                      displayName: 'Return Fields',
                      name: 'returnFields',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['insert', 'update'],
                          },
                      },
                      default: '*',
                      description: 'Comma-separated list of the fields that the operation will return',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      default: {},
                      options: [
                          {
                              displayName: 'Mode',
                              name: 'mode',
                              type: 'options',
                              options: [
                                  {
                                      name: 'Independently',
                                      value: 'independently',
                                      description: 'Execute each query independently',
                                  },
                                  {
                                      name: 'Multiple Queries',
                                      value: 'multiple',
                                      description: '<b>Default</b>. Sends multiple queries at once to database.',
                                  },
                                  {
                                      name: 'Transaction',
                                      value: 'transaction',
                                      description: 'Executes all queries in a single transaction',
                                  },
                              ],
                              default: 'multiple',
                              description: 'The way queries should be sent to database. Can be used in conjunction with <b>Continue on Fail</b>. See <a href="https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.timescaledb/">the docs</a> for more examples',
                          },
                          {
                              displayName: 'Query Parameters',
                              name: 'queryParams',
                              type: 'string',
                              displayOptions: {
                                  show: {
                                      '/operation': ['executeQuery'],
                                  },
                              },
                              default: '',
                              placeholder: 'quantity,price',
                              description: 'Comma-separated list of properties which should be used as query parameters',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const credentials = await this.getCredentials('timescaleDb');
          const pgp = (0, pg_promise_1.default)();
          const config = {
              host: credentials.host,
              port: credentials.port,
              database: credentials.database,
              user: credentials.user,
              password: credentials.password,
              ssl: !['disable', undefined].includes(credentials.ssl),
              sslmode: credentials.ssl || 'disable',
          };
          const db = pgp(config);
          let returnItems = [];
          const items = this.getInputData();
          const operation = this.getNodeParameter('operation', 0);
          if (operation === 'executeQuery') {
              const queryResult = await genericFunctions_1.pgQueryV2.call(this, pgp, db, items, this.continueOnFail(), {
                  resolveExpression: true,
              });
              returnItems = this.helpers.returnJsonArray(queryResult);
          }
          else if (operation === 'insert') {
              const insertData = await (0, genericFunctions_1.pgInsert)(this.getNodeParameter, pgp, db, items, this.continueOnFail());
              for (let i = 0; i < insertData.length; i++) {
                  returnItems.push({
                      json: insertData[i],
                  });
              }
          }
          else if (operation === 'update') {
              const updateItems = await (0, genericFunctions_1.pgUpdate)(this.getNodeParameter, pgp, db, items, this.continueOnFail());
              returnItems = this.helpers.returnJsonArray(updateItems);
          }
          else {
              await db.$pool.end();
              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not supported!`);
          }
          await db.$pool.end();
          return [returnItems];
      }
  }
  exports.TimescaleDb = TimescaleDb;
  //# sourceMappingURL=TimescaleDb.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: TimescaleDB node documentation
  description: Learn how to use the TimescaleDB node in n8n. Follow technical documentation to integrate TimescaleDB node into your workflows.
  contentType: [integration, reference]
  ---

  # TimescaleDB node

  Use the TimescaleDB node to automate work in TimescaleDB, and integrate TimescaleDB with other applications. n8n has built-in support for a wide range of TimescaleDB features, including executing an SQL query, as well as inserting and updating rows in a database. 

  On this page, you'll find a list of operations the TimescaleDB node supports and links to more resources.

  /// note | Credentials
  Refer to [TimescaleDB credentials](/integrations/builtin/credentials/timescaledb.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Execute an SQL query
  * Insert rows in database
  * Update rows in database

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'timescaledb') ]]

  ## Specify a column's data type

  To specify a column's data type, append the column name with `:type`, where `type` is the data type you want for the column. For example, if you want to specify the type `int` for the column **id** and type `text` for the column **name**, you can use the following snippet in the **Columns** field: `id:int,name:text`.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"fbcf6deb-349e-4d51-8434-70ba6b31429d","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"e92776bb9f02513bc57626936bcaefc9790e54f11f6dab2c52eac236449fb0d3"}}


node_type: n8n-nodes-base.Todoist
name: Todoist
display_name: Todoist
description: Consume Todoist API
category: output
icon: file:todoist.svg
code_hash: 5834162f968265342f1a072c65b59b08ebab47f0384790d999054541ff446777
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.todoist
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
extracted_at: 2025-06-08 09:18:33
updated_at: 2025-06-08 09:18:33
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Todoist = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const TodoistV1_node_1 = require("./v1/TodoistV1.node");
  const TodoistV2_node_1 = require("./v2/TodoistV2.node");
  class Todoist extends n8n_workflow_1.VersionedNodeType {
      constructor() {
          const baseDescription = {
              displayName: 'Todoist',
              name: 'todoist',
              icon: 'file:todoist.svg',
              group: ['output'],
              defaultVersion: 2,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Todoist API',
          };
          const nodeVersions = {
              1: new TodoistV1_node_1.TodoistV1(baseDescription),
              2: new TodoistV2_node_1.TodoistV2(baseDescription),
          };
          super(nodeVersions, baseDescription);
      }
  }
  exports.Todoist = Todoist;
  //# sourceMappingURL=Todoist.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Todoist node documentation
  description: Learn how to use the Todoist node in n8n. Follow technical documentation to integrate Todoist node into your workflows.
  contentType: [integration, reference]
  priority: medium
  ---

  # Todoist node

  Use the Todoist node to automate work in Todoist, and integrate Todoist with other applications. n8n has built-in support for a wide range of Todoist features, including creating, updating, deleting, and getting tasks. 

  On this page, you'll find a list of operations the Todoist node supports and links to more resources.

  /// note | Credentials
  Refer to [Todoist credentials](/integrations/builtin/credentials/todoist.md) for guidance on setting up authentication. 
  ///

  --8<-- "_snippets/integrations/builtin/app-nodes/ai-tools.md"

  ## Operations

  * Task
      * Create a new task
      * Close a task
      * Delete a task
      * Get a task
      * Get all tasks
      * Reopen a task
      * Update a task

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'todoist') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"684ce8bb-ebcd-44b2-9101-2196f64871f8","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"37a1f711203b98e99f22300d5ba575324f107acd5c4b899dc6165a0d2b7ea6dd"}}


node_type: n8n-nodes-base.Tapfiliate
name: Tapfiliate
display_name: Tapfiliate
description: Consume Tapfiliate API
category: transform
icon: file:tapfiliate.svg
code_hash: 322284a7aa45ad766d6bfbf77223992d532b8fa418f9f4a1c231747871981d2e
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.tapfiliate
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:33
updated_at: 2025-06-08 09:18:33
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Tapfiliate = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const AffiliateDescription_1 = require("./AffiliateDescription");
  const AffiliateMetadataDescription_1 = require("./AffiliateMetadataDescription");
  const ProgramAffiliateDescription_1 = require("./ProgramAffiliateDescription");
  const GenericFunctions_1 = require("./GenericFunctions");
  class Tapfiliate {
      constructor() {
          this.description = {
              displayName: 'Tapfiliate',
              name: 'tapfiliate',
              icon: 'file:tapfiliate.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ":" + $parameter["resource"]}}',
              description: 'Consume Tapfiliate API',
              defaults: {
                  name: 'Tapfiliate',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'tapfiliateApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Affiliate',
                              value: 'affiliate',
                          },
                          {
                              name: 'Affiliate Metadata',
                              value: 'affiliateMetadata',
                          },
                          {
                              name: 'Program Affiliate',
                              value: 'programAffiliate',
                          },
                      ],
                      default: 'affiliate',
                      required: true,
                  },
                  ...AffiliateDescription_1.affiliateOperations,
                  ...AffiliateDescription_1.affiliateFields,
                  ...AffiliateMetadataDescription_1.affiliateMetadataOperations,
                  ...AffiliateMetadataDescription_1.affiliateMetadataFields,
                  ...ProgramAffiliateDescription_1.programAffiliateOperations,
                  ...ProgramAffiliateDescription_1.programAffiliateFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getPrograms() {
                      const returnData = [];
                      const programs = await GenericFunctions_1.tapfiliateApiRequestAllItems.call(this, 'GET', '/programs/');
                      for (const program of programs) {
                          returnData.push({
                              name: program.title,
                              value: program.id,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          var _a;
          const items = this.getInputData();
          const length = items.length;
          const qs = {};
          let responseData;
          const returnData = [];
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'affiliate') {
                      if (operation === 'create') {
                          const firstname = this.getNodeParameter('firstname', i);
                          const lastname = this.getNodeParameter('lastname', i);
                          const email = this.getNodeParameter('email', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              firstname,
                              lastname,
                              email,
                          };
                          Object.assign(body, additionalFields);
                          if (body.addressUi) {
                              body.address = body.addressUi.addressValues;
                              delete body.addressUi;
                              if (body.address.country) {
                                  body.address.country = {
                                      code: body.address.country,
                                  };
                              }
                          }
                          if (body.companyName) {
                              body.company = {
                                  name: body.companyName,
                              };
                              delete body.companyName;
                          }
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'POST', '/affiliates/', body);
                          returnData.push(responseData);
                      }
                      if (operation === 'delete') {
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'DELETE', `/affiliates/${affiliateId}/`);
                          responseData = { success: true };
                      }
                      if (operation === 'get') {
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'GET', `/affiliates/${affiliateId}/`);
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          Object.assign(qs, filters);
                          if (returnAll) {
                              responseData = await GenericFunctions_1.tapfiliateApiRequestAllItems.call(this, 'GET', '/affiliates/', {}, qs);
                          }
                          else {
                              const limit = this.getNodeParameter('limit', i);
                              responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'GET', '/affiliates/', {}, qs);
                              responseData = responseData.splice(0, limit);
                          }
                      }
                  }
                  if (resource === 'affiliateMetadata') {
                      if (operation === 'add') {
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          const metadata = ((_a = this.getNodeParameter('metadataUi', i)) === null || _a === void 0 ? void 0 : _a.metadataValues) || [];
                          if (metadata.length === 0) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Metadata cannot be empty.', {
                                  itemIndex: i,
                              });
                          }
                          for (const { key, value } of metadata) {
                              await GenericFunctions_1.tapfiliateApiRequest.call(this, 'PUT', `/affiliates/${affiliateId}/meta-data/${key}/`, { value });
                          }
                          responseData = { success: true };
                      }
                      if (operation === 'remove') {
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          const key = this.getNodeParameter('key', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'DELETE', `/affiliates/${affiliateId}/meta-data/${key}/`);
                          responseData = { success: true };
                      }
                      if (operation === 'update') {
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          const key = this.getNodeParameter('key', i);
                          const value = this.getNodeParameter('value', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'PUT', `/affiliates/${affiliateId}/meta-data/`, { [key]: value });
                      }
                  }
                  if (resource === 'programAffiliate') {
                      if (operation === 'add') {
                          const programId = this.getNodeParameter('programId', i);
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              affiliate: {
                                  id: affiliateId,
                              },
                          };
                          Object.assign(body, additionalFields);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'POST', `/programs/${programId}/affiliates/`, body);
                      }
                      if (operation === 'approve') {
                          const programId = this.getNodeParameter('programId', i);
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'PUT', `/programs/${programId}/affiliates/${affiliateId}/approved/`);
                      }
                      if (operation === 'disapprove') {
                          const programId = this.getNodeParameter('programId', i);
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'DELETE', `/programs/${programId}/affiliates/${affiliateId}/approved/`);
                      }
                      if (operation === 'get') {
                          const programId = this.getNodeParameter('programId', i);
                          const affiliateId = this.getNodeParameter('affiliateId', i);
                          responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'GET', `/programs/${programId}/affiliates/${affiliateId}/`);
                      }
                      if (operation === 'getAll') {
                          const programId = this.getNodeParameter('programId', i);
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          Object.assign(qs, filters);
                          if (returnAll) {
                              responseData = await GenericFunctions_1.tapfiliateApiRequestAllItems.call(this, 'GET', `/programs/${programId}/affiliates/`, {}, qs);
                          }
                          else {
                              const limit = this.getNodeParameter('limit', i);
                              responseData = await GenericFunctions_1.tapfiliateApiRequest.call(this, 'GET', `/programs/${programId}/affiliates/`, {}, qs);
                              responseData = responseData.splice(0, limit);
                          }
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      const executionErrorData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
                      returnData.push(...executionErrorData);
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.Tapfiliate = Tapfiliate;
  //# sourceMappingURL=Tapfiliate.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Tapfiliate node documentation
  description: Learn how to use the Tapfiliate node in n8n. Follow technical documentation to integrate Tapfiliate node into your workflows.
  contentType: [integration, reference]
  ---

  # Tapfiliate node

  Use the Tapfiliate node to automate work in Tapfiliate, and integrate Tapfiliate with other applications. n8n has built-in support for a wide range of Tapfiliate features, including creating and deleting affiliates, and adding affiliate metadata. 

  On this page, you'll find a list of operations the Tapfiliate node supports and links to more resources.

  /// note | Credentials
  Refer to [Tapfiliate credentials](/integrations/builtin/credentials/tapfiliate.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Affiliate
      * Create an affiliate
      * Delete an affiliate
      * Get an affiliate by ID
      * Get all affiliates
  * Affiliate Metadata
      * Add metadata to affiliate
      * Remove metadata from affiliate
      * Update affiliate's metadata
  * Program Affiliate
      * Add affiliate to program
      * Approve an affiliate for a program
      * Disapprove an affiliate
      * Get an affiliate in a program
      * Get all affiliates in program

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'tapfiliate') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"d4dd1be5-f246-422c-a2ea-c9971067eda7","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"4178abae483392cce2ad2c864b580710bb780a7910d26f55be1b2b800379405e"}}


node_type: n8n-nodes-base.TravisCi
name: TravisCi
display_name: TravisCI
description: Consume TravisCI API
category: output
icon: file:travisci.png
code_hash: 3e073fa53575b8a98002bddbb6651c488e7ff09881d8d210b015393b839f0cba
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.travisci
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.TravisCi = void 0;
  const BuildDescription_1 = require("./BuildDescription");
  const GenericFunctions_1 = require("./GenericFunctions");
  class TravisCi {
      constructor() {
          this.description = {
              displayName: 'TravisCI',
              name: 'travisCi',
              icon: 'file:travisci.png',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume TravisCI API',
              defaults: {
                  name: 'TravisCI',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'travisCiApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Build',
                              value: 'build',
                          },
                      ],
                      default: 'build',
                  },
                  ...BuildDescription_1.buildOperations,
                  ...BuildDescription_1.buildFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          const qs = {};
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'build') {
                      if (operation === 'get') {
                          const buildId = this.getNodeParameter('buildId', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          if (additionalFields.include) {
                              qs.include = additionalFields.include;
                          }
                          responseData = await GenericFunctions_1.travisciApiRequest.call(this, 'GET', `/build/${buildId}`, {}, qs);
                      }
                      if (operation === 'getAll') {
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const returnAll = this.getNodeParameter('returnAll', i);
                          if (additionalFields.sortBy) {
                              qs.sort_by = additionalFields.sortBy;
                          }
                          if (additionalFields.sortBy && additionalFields.order) {
                              qs.sort_by = `${additionalFields.sortBy}:${additionalFields.order}`;
                          }
                          if (additionalFields.include) {
                              qs.include = additionalFields.include;
                          }
                          if (returnAll) {
                              responseData = await GenericFunctions_1.travisciApiRequestAllItems.call(this, 'builds', 'GET', '/builds', {}, qs);
                          }
                          else {
                              qs.limit = this.getNodeParameter('limit', i);
                              responseData = await GenericFunctions_1.travisciApiRequest.call(this, 'GET', '/builds', {}, qs);
                              responseData = responseData.builds;
                          }
                      }
                      if (operation === 'cancel') {
                          const buildId = this.getNodeParameter('buildId', i);
                          responseData = await GenericFunctions_1.travisciApiRequest.call(this, 'POST', `/build/${buildId}/cancel`, {}, qs);
                      }
                      if (operation === 'restart') {
                          const buildId = this.getNodeParameter('buildId', i);
                          responseData = await GenericFunctions_1.travisciApiRequest.call(this, 'POST', `/build/${buildId}/restart`, {}, qs);
                      }
                      if (operation === 'trigger') {
                          let slug = this.getNodeParameter('slug', i);
                          const branch = this.getNodeParameter('branch', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          slug = slug.replace(new RegExp(/\//g), '%2F');
                          const request = {
                              branch,
                          };
                          if (additionalFields.message) {
                              request.message = additionalFields.message;
                          }
                          if (additionalFields.mergeMode) {
                              request.merge_mode = additionalFields.mergeMode;
                          }
                          responseData = await GenericFunctions_1.travisciApiRequest.call(this, 'POST', `/repo/${slug}/requests`, JSON.stringify({ request }));
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      const executionErrorData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
                      returnData.push(...executionErrorData);
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.TravisCi = TravisCi;
  //# sourceMappingURL=TravisCi.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Travis CI node documentation
  description: Learn how to use the Travis CI node in n8n. Follow technical documentation to integrate Travis CI node into your workflows.
  contentType: [integration, reference]
  ---

  # Travis CI node

  Use the Travis CI node to automate work in Travis CI, and integrate Travis CI with other applications. n8n has built-in support for a wide range of Travis CI features, including cancelling and getting builds. 

  On this page, you'll find a list of operations the Travis CI node supports and links to more resources.

  /// note | Credentials
  Refer to [Travis CI credentials](/integrations/builtin/credentials/travisci.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Build
      * Cancel a build
      * Get a build
      * Get all builds
      * Restart a build
      * Trigger a build

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'travisci') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"d58585ed-7ef0-448c-bb77-85c5350cbd27","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"0b2108c487deadbe0de38d7f07c0fd3164334f4052c6182d1445cd21fdfe4505"}}


node_type: n8n-nodes-base.Trello
name: Trello
display_name: Trello
description: Create, change and delete boards and cards
category: transform
icon: file:trello.svg
code_hash: 3a5713584d89db802864ee8bb673e2c70882f0385ed0fbb2062f8101107f612b
documentation_url: https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.trellotrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Trello = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const AttachmentDescription_1 = require("./AttachmentDescription");
  const BoardDescription_1 = require("./BoardDescription");
  const BoardMemberDescription_1 = require("./BoardMemberDescription");
  const CardDescription_1 = require("./CardDescription");
  const CardCommentDescription_1 = require("./CardCommentDescription");
  const ChecklistDescription_1 = require("./ChecklistDescription");
  const LabelDescription_1 = require("./LabelDescription");
  const ListDescription_1 = require("./ListDescription");
  class Trello {
      constructor() {
          this.description = {
              displayName: 'Trello',
              name: 'trello',
              icon: 'file:trello.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Create, change and delete boards and cards',
              defaults: {
                  name: 'Trello',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'trelloApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Attachment',
                              value: 'attachment',
                          },
                          {
                              name: 'Board',
                              value: 'board',
                          },
                          {
                              name: 'Board Member',
                              value: 'boardMember',
                          },
                          {
                              name: 'Card',
                              value: 'card',
                          },
                          {
                              name: 'Card Comment',
                              value: 'cardComment',
                          },
                          {
                              name: 'Checklist',
                              value: 'checklist',
                          },
                          {
                              name: 'Label',
                              value: 'label',
                          },
                          {
                              name: 'List',
                              value: 'list',
                          },
                      ],
                      default: 'card',
                  },
                  ...AttachmentDescription_1.attachmentOperations,
                  ...BoardDescription_1.boardOperations,
                  ...BoardMemberDescription_1.boardMemberOperations,
                  ...CardDescription_1.cardOperations,
                  ...CardCommentDescription_1.cardCommentOperations,
                  ...ChecklistDescription_1.checklistOperations,
                  ...LabelDescription_1.labelOperations,
                  ...ListDescription_1.listOperations,
                  ...AttachmentDescription_1.attachmentFields,
                  ...BoardDescription_1.boardFields,
                  ...BoardMemberDescription_1.boardMemberFields,
                  ...CardDescription_1.cardFields,
                  ...CardCommentDescription_1.cardCommentFields,
                  ...ChecklistDescription_1.checklistFields,
                  ...LabelDescription_1.labelFields,
                  ...ListDescription_1.listFields,
              ],
          };
          this.methods = {
              listSearch: {
                  async searchBoards(query) {
                      if (!query) {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Query required for Trello search');
                      }
                      const searchResults = await GenericFunctions_1.apiRequest.call(this, 'GET', 'search', {}, {
                          query,
                          modelTypes: 'boards',
                          board_fields: 'name,url,desc',
                          partial: true,
                          boards_limit: 50,
                      });
                      return {
                          results: searchResults.boards.map((b) => ({
                              name: b.name,
                              value: b.id,
                              url: b.url,
                              description: b.desc,
                          })),
                      };
                  },
                  async searchCards(query) {
                      if (!query) {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Query required for Trello search');
                      }
                      const searchResults = await GenericFunctions_1.apiRequest.call(this, 'GET', 'search', {}, {
                          query,
                          modelTypes: 'cards',
                          board_fields: 'name,url,desc',
                          partial: true,
                          cards_limit: 50,
                      });
                      return {
                          results: searchResults.cards.map((b) => ({
                              name: b.name,
                              value: b.id,
                              url: b.url,
                              description: b.desc,
                          })),
                      };
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const operation = this.getNodeParameter('operation', 0);
          const resource = this.getNodeParameter('resource', 0);
          let body;
          let qs;
          let requestMethod;
          let endpoint;
          let returnAll = false;
          let responseData;
          for (let i = 0; i < items.length; i++) {
              try {
                  requestMethod = 'GET';
                  endpoint = '';
                  body = {};
                  qs = {};
                  if (resource === 'board') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          endpoint = 'boards';
                          qs.name = this.getNodeParameter('name', i);
                          qs.desc = this.getNodeParameter('description', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const id = this.getNodeParameter('id', i, undefined, {
                              extractValue: true,
                          });
                          endpoint = `boards/${id}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i, undefined, { extractValue: true });
                          endpoint = `boards/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i, undefined, { extractValue: true });
                          endpoint = `boards/${id}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(qs, updateFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'boardMember') {
                      if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i);
                          returnAll = this.getNodeParameter('returnAll', i);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          endpoint = `boards/${id}/members`;
                      }
                      else if (operation === 'add') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i);
                          const idMember = this.getNodeParameter('idMember', i);
                          endpoint = `boards/${id}/members/${idMember}`;
                          qs.type = this.getNodeParameter('type', i);
                          qs.allowBillableGuest = this.getNodeParameter('additionalFields.allowBillableGuest', i, false);
                      }
                      else if (operation === 'invite') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `boards/${id}/members`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          qs.email = this.getNodeParameter('email', i);
                          qs.type = additionalFields.type;
                          body.fullName = additionalFields.fullName;
                      }
                      else if (operation === 'remove') {
                          requestMethod = 'DELETE';
                          const id = this.getNodeParameter('id', i);
                          const idMember = this.getNodeParameter('idMember', i);
                          endpoint = `boards/${id}/members/${idMember}`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'card') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          endpoint = 'cards';
                          qs.idList = this.getNodeParameter('listId', i);
                          qs.name = this.getNodeParameter('name', i);
                          qs.desc = this.getNodeParameter('description', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const id = this.getNodeParameter('id', i, undefined, { extractValue: true });
                          endpoint = `cards/${id}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i, undefined, { extractValue: true });
                          endpoint = `cards/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i, undefined, { extractValue: true });
                          endpoint = `cards/${id}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(qs, updateFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'cardComment') {
                      if (operation === 'create') {
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          qs.text = this.getNodeParameter('text', i);
                          requestMethod = 'POST';
                          endpoint = `cards/${cardId}/actions/comments`;
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const commentId = this.getNodeParameter('commentId', i);
                          endpoint = `/cards/${cardId}/actions/${commentId}/comments`;
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const commentId = this.getNodeParameter('commentId', i);
                          qs.text = this.getNodeParameter('text', i);
                          endpoint = `cards/${cardId}/actions/${commentId}/comments`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'list') {
                      if (operation === 'archive') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i);
                          qs.value = this.getNodeParameter('archive', i);
                          endpoint = `lists/${id}/closed`;
                      }
                      else if (operation === 'create') {
                          requestMethod = 'POST';
                          endpoint = 'lists';
                          qs.idBoard = this.getNodeParameter('idBoard', i);
                          qs.name = this.getNodeParameter('name', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `lists/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          returnAll = this.getNodeParameter('returnAll', i);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          const id = this.getNodeParameter('id', i);
                          endpoint = `boards/${id}/lists`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getCards') {
                          requestMethod = 'GET';
                          returnAll = this.getNodeParameter('returnAll', i);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          const id = this.getNodeParameter('id', i);
                          endpoint = `lists/${id}/cards`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `lists/${id}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(qs, updateFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'attachment') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const url = this.getNodeParameter('url', i);
                          Object.assign(qs, {
                              url,
                          });
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                          endpoint = `cards/${cardId}/attachments`;
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const id = this.getNodeParameter('id', i);
                          endpoint = `cards/${cardId}/attachments/${id}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const id = this.getNodeParameter('id', i);
                          endpoint = `cards/${cardId}/attachments/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          endpoint = `cards/${cardId}/attachments`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'checklist') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const name = this.getNodeParameter('name', i);
                          Object.assign(qs, { name });
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                          endpoint = `cards/${cardId}/checklists`;
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const id = this.getNodeParameter('id', i);
                          endpoint = `cards/${cardId}/checklists/${id}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `checklists/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          endpoint = `cards/${cardId}/checklists`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getCheckItem') {
                          requestMethod = 'GET';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const checkItemId = this.getNodeParameter('checkItemId', i);
                          endpoint = `cards/${cardId}/checkItem/${checkItemId}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'createCheckItem') {
                          requestMethod = 'POST';
                          const checklistId = this.getNodeParameter('checklistId', i);
                          endpoint = `checklists/${checklistId}/checkItems`;
                          const name = this.getNodeParameter('name', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, { name, ...additionalFields });
                      }
                      else if (operation === 'deleteCheckItem') {
                          requestMethod = 'DELETE';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const checkItemId = this.getNodeParameter('checkItemId', i);
                          endpoint = `cards/${cardId}/checkItem/${checkItemId}`;
                      }
                      else if (operation === 'updateCheckItem') {
                          requestMethod = 'PUT';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const checkItemId = this.getNodeParameter('checkItemId', i);
                          endpoint = `cards/${cardId}/checkItem/${checkItemId}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'completedCheckItems') {
                          requestMethod = 'GET';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          endpoint = `cards/${cardId}/checkItemStates`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'label') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const idBoard = this.getNodeParameter('boardId', i, undefined, {
                              extractValue: true,
                          });
                          const name = this.getNodeParameter('name', i);
                          const color = this.getNodeParameter('color', i);
                          Object.assign(qs, {
                              idBoard,
                              name,
                              color,
                          });
                          endpoint = 'labels';
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `labels/${id}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `labels/${id}`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const idBoard = this.getNodeParameter('boardId', i, undefined, {
                              extractValue: true,
                          });
                          endpoint = `board/${idBoard}/labels`;
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(qs, additionalFields);
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const id = this.getNodeParameter('id', i);
                          endpoint = `labels/${id}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(qs, updateFields);
                      }
                      else if (operation === 'addLabel') {
                          requestMethod = 'POST';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const id = this.getNodeParameter('id', i);
                          qs.value = id;
                          endpoint = `/cards/${cardId}/idLabels`;
                      }
                      else if (operation === 'removeLabel') {
                          requestMethod = 'DELETE';
                          const cardId = this.getNodeParameter('cardId', i, undefined, {
                              extractValue: true,
                          });
                          const id = this.getNodeParameter('id', i);
                          endpoint = `/cards/${cardId}/idLabels/${id}`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource "${resource}" is not known!`, {
                          itemIndex: i,
                      });
                  }
                  const skipPagination = ['list:getAll'];
                  if (returnAll && !skipPagination.includes(`${resource}:${operation}`)) {
                      responseData = await GenericFunctions_1.apiRequestAllItems.call(this, requestMethod, endpoint, body, qs);
                  }
                  else {
                      responseData = await GenericFunctions_1.apiRequest.call(this, requestMethod, endpoint, body, qs);
                      if (!returnAll && qs.limit) {
                          responseData = responseData.splice(0, qs.limit);
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
                      returnData.push(...executionData);
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.Trello = Trello;
  //# sourceMappingURL=Trello.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Trello Trigger node documentation
  description: Learn how to use the Trello Trigger node in n8n. Follow technical documentation to integrate Trello Trigger node into your workflows.
  contentType: [integration, reference]
  priority: medium
  ---

  # Trello Trigger node

  [Trello](https://trello.com/){:target=_blank .external-link} is a web-based Kanban-style list-making application which is a subsidiary of Atlassian. Users can create their task boards with different columns and move the tasks between them.

  /// note | Credentials
  You can find authentication information for this node [here](/integrations/builtin/credentials/trello.md).
  ///

  ///  note  | Examples and templates
  For usage examples and templates to help you get started, refer to n8n's [Trello Trigger integrations](https://n8n.io/integrations/trello-trigger/){:target=_blank .external-link} page.
  ///

  ## Find the Model ID

  The model ID is the ID of any model in Trello. Depending on the use-case, it could be the User ID, List ID, and so on.

  For this specific example, the List ID would be the Model ID:

  1. Open the Trello board that contains the list.
  2. If the list doesn't have any cards, add a card to the list.
  3. Open the card, add `.json` at the end of the URL, and press enter.
  4. In the JSON file, you will see a field called `idList`.
  5. Copy `idList`and paste it in the **Model ID** field in n8n.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"47e33442-c882-4feb-8951-1f242e9e10a0","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"e4c24e9120531733cb0fdf7dce6e9592fe64b729f30616abd70f8ebe5be98b65"}}


node_type: n8n-nodes-base.Totp
name: Totp
display_name: TOTP
description: Generate a time-based one-time password
category: transform
icon: fa:fingerprint
code_hash: 7cdfce3ae2cf188a1b283409f9cc3859c6e6231987208b6599b91d397b862b07
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Totp = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const otpauth_1 = __importDefault(require("otpauth"));
  class Totp {
      constructor() {
          this.description = {
              displayName: 'TOTP',
              name: 'totp',
              icon: 'fa:fingerprint',
              group: ['transform'],
              version: 1,
              subtitle: '={{ $parameter["operation"] }}',
              description: 'Generate a time-based one-time password',
              defaults: {
                  name: 'TOTP',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'totpApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Generate Secret',
                              value: 'generateSecret',
                              action: 'Generate secret',
                          },
                      ],
                      default: 'generateSecret',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      displayOptions: {
                          show: {
                              operation: ['generateSecret'],
                          },
                      },
                      default: {},
                      placeholder: 'Add Option',
                      options: [
                          {
                              displayName: 'Algorithm',
                              name: 'algorithm',
                              type: 'options',
                              default: 'SHA1',
                              description: 'HMAC hashing algorithm. Defaults to SHA1.',
                              options: [
                                  {
                                      name: 'SHA1',
                                      value: 'SHA1',
                                  },
                                  {
                                      name: 'SHA224',
                                      value: 'SHA224',
                                  },
                                  {
                                      name: 'SHA256',
                                      value: 'SHA256',
                                  },
                                  {
                                      name: 'SHA3-224',
                                      value: 'SHA3-224',
                                  },
                                  {
                                      name: 'SHA3-256',
                                      value: 'SHA3-256',
                                  },
                                  {
                                      name: 'SHA3-384',
                                      value: 'SHA3-384',
                                  },
                                  {
                                      name: 'SHA3-512',
                                      value: 'SHA3-512',
                                  },
                                  {
                                      name: 'SHA384',
                                      value: 'SHA384',
                                  },
                                  {
                                      name: 'SHA512',
                                      value: 'SHA512',
                                  },
                              ],
                          },
                          {
                              displayName: 'Digits',
                              name: 'digits',
                              type: 'number',
                              default: 6,
                              description: 'Number of digits in the generated TOTP code. Defaults to 6 digits.',
                          },
                          {
                              displayName: 'Period',
                              name: 'period',
                              type: 'number',
                              default: 30,
                              description: 'How many seconds the generated TOTP code is valid for. Defaults to 30 seconds.',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const operation = this.getNodeParameter('operation', 0);
          const credentials = (await this.getCredentials('totpApi'));
          if (!credentials.label.includes(':')) {
              throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Malformed label - expected `issuer:username`');
          }
          const options = this.getNodeParameter('options', 0);
          if (!options.algorithm)
              options.algorithm = 'SHA1';
          if (!options.digits)
              options.digits = 6;
          if (!options.period)
              options.period = 30;
          const [issuer] = credentials.label.split(':');
          const totp = new otpauth_1.default.TOTP({
              issuer,
              label: credentials.label,
              secret: credentials.secret,
              algorithm: options.algorithm,
              digits: options.digits,
              period: options.period,
          });
          const token = totp.generate();
          const secondsRemaining = (options.period * (1 - ((Date.now() / 1000 / options.period) % 1))) | 0;
          if (operation === 'generateSecret') {
              for (let i = 0; i < items.length; i++) {
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ token, secondsRemaining }), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
          }
          return [returnData];
      }
  }
  exports.Totp = Totp;
  //# sourceMappingURL=Totp.node.js.map

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"4d91ee19-fd2f-4e06-818d-d89f0d5260ba","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"1d4b987c5c739c61cdf20fb5cd438f5ee618252bff2ec1f343949b7917b0cb4e"}}


node_type: n8n-nodes-base.Twilio
name: Twilio
display_name: Twilio
description: Send SMS and WhatsApp messages or make phone calls
category: transform
icon: file:twilio.svg
code_hash: 6a6d8e5660a38615ba7a11199540fed80d7d36fac57b6ba4728a36927c913bd4
documentation_url: https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.twiliotrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Twilio = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  class Twilio {
      constructor() {
          this.description = {
              displayName: 'Twilio',
              name: 'twilio',
              icon: 'file:twilio.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Send SMS and WhatsApp messages or make phone calls',
              defaults: {
                  name: 'Twilio',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'twilioApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Call',
                              value: 'call',
                          },
                          {
                              name: 'SMS',
                              value: 'sms',
                          },
                      ],
                      default: 'sms',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                          },
                      },
                      options: [
                          {
                              name: 'Send',
                              value: 'send',
                              description: 'Send SMS/MMS/WhatsApp message',
                              action: 'Send an SMS/MMS/WhatsApp message',
                          },
                      ],
                      default: 'send',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['call'],
                          },
                      },
                      options: [
                          {
                              name: 'Make',
                              value: 'make',
                              action: 'Make a call',
                          },
                      ],
                      default: 'make',
                  },
                  {
                      displayName: 'From',
                      name: 'from',
                      type: 'string',
                      default: '',
                      placeholder: '+14155238886',
                      required: true,
                      displayOptions: {
                          show: {
                              operation: ['send', 'make'],
                              resource: ['sms', 'call'],
                          },
                      },
                      description: 'The number from which to send the message',
                  },
                  {
                      displayName: 'To',
                      name: 'to',
                      type: 'string',
                      default: '',
                      placeholder: '+14155238886',
                      required: true,
                      displayOptions: {
                          show: {
                              operation: ['send', 'make'],
                              resource: ['sms', 'call'],
                          },
                      },
                      description: 'The number to which to send the message',
                  },
                  {
                      displayName: 'To Whatsapp',
                      name: 'toWhatsapp',
                      type: 'boolean',
                      default: false,
                      displayOptions: {
                          show: {
                              operation: ['send'],
                              resource: ['sms'],
                          },
                      },
                      description: 'Whether the message should be sent to WhatsApp',
                  },
                  {
                      displayName: 'Message',
                      name: 'message',
                      type: 'string',
                      default: '',
                      required: true,
                      displayOptions: {
                          show: {
                              operation: ['send'],
                              resource: ['sms'],
                          },
                      },
                      description: 'The message to send',
                  },
                  {
                      displayName: 'Use TwiML',
                      name: 'twiml',
                      type: 'boolean',
                      default: false,
                      displayOptions: {
                          show: {
                              operation: ['make'],
                              resource: ['call'],
                          },
                      },
                      description: 'Whether to use the <a href="https://www.twilio.com/docs/voice/twiml">Twilio Markup Language</a> in the message',
                  },
                  {
                      displayName: 'Message',
                      name: 'message',
                      type: 'string',
                      default: '',
                      required: true,
                      displayOptions: {
                          show: {
                              operation: ['make'],
                              resource: ['call'],
                          },
                      },
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      placeholder: 'Add Field',
                      default: {},
                      options: [
                          {
                              displayName: 'Status Callback',
                              name: 'statusCallback',
                              type: 'string',
                              default: '',
                              description: 'Status Callbacks allow you to receive events related to the REST resources managed by Twilio: Rooms, Recordings and Compositions',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          let operation;
          let resource;
          let body;
          let qs;
          let requestMethod;
          let endpoint;
          for (let i = 0; i < items.length; i++) {
              try {
                  requestMethod = 'GET';
                  endpoint = '';
                  body = {};
                  qs = {};
                  resource = this.getNodeParameter('resource', i);
                  operation = this.getNodeParameter('operation', i);
                  if (resource === 'sms') {
                      if (operation === 'send') {
                          requestMethod = 'POST';
                          endpoint = '/Messages.json';
                          body.From = this.getNodeParameter('from', i);
                          body.To = this.getNodeParameter('to', i);
                          body.Body = this.getNodeParameter('message', i);
                          body.StatusCallback = this.getNodeParameter('options.statusCallback', i, '');
                          const toWhatsapp = this.getNodeParameter('toWhatsapp', i);
                          if (toWhatsapp) {
                              body.From = `whatsapp:${body.From}`;
                              body.To = `whatsapp:${body.To}`;
                          }
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'call') {
                      if (operation === 'make') {
                          requestMethod = 'POST';
                          endpoint = '/Calls.json';
                          const message = this.getNodeParameter('message', i);
                          const useTwiml = this.getNodeParameter('twiml', i);
                          body.From = this.getNodeParameter('from', i);
                          body.To = this.getNodeParameter('to', i);
                          if (useTwiml) {
                              body.Twiml = message;
                          }
                          else {
                              body.Twiml = `<Response><Say>${(0, GenericFunctions_1.escapeXml)(message)}</Say></Response>`;
                          }
                          body.StatusCallback = this.getNodeParameter('options.statusCallback', i, '');
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The resource "${resource}" is not known!`, {
                          itemIndex: i,
                      });
                  }
                  const responseData = await GenericFunctions_1.twilioApiRequest.call(this, requestMethod, endpoint, body, qs);
                  returnData.push(responseData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Twilio = Twilio;
  //# sourceMappingURL=Twilio.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Twilio Trigger node documentation
  description: Learn how to use the Twilio Trigger node in n8n. Follow technical documentation to integrate Twilio Trigger node into your workflows.
  contentType: [integration, reference]
  ---

  # Twilio Trigger node

  Use the Twilio Trigger node to respond to events in [Twilio](https://www.twilio.com){:target=_blank .external-link} and integrate Twilio with other applications. n8n has built-in support for a wide range of Twilio events, including new SMS and calls.

  On this page, you'll find a list of events the Twilio Trigger node can respond to and links to more resources.

  ///  note  | Credentials
  You can find authentication information for this node [here](/integrations/builtin/credentials/twilio.md).
  ///

  ///  note  | Examples and templates
  For usage examples and templates to help you get started, refer to n8n's [Twilio integrations](https://n8n.io/integrations/twilio-trigger/){:target=_blank .external-link} page.
  ///

  ## Events

  * On New SMS
  * On New Call

  ///  note  | New Call Delay
  It can take Twilio up to thirty minutes to generate a summary for a completed call.
  ///

  ## Related resources

  n8n provides an app node for Twilio. You can find the node docs [here](/integrations/builtin/app-nodes/n8n-nodes-base.twilio.md).

  View [example workflows and related content](https://n8n.io/integrations/twilio/){:target=_blank .external-link} on n8n's website.

  Refer to [Twilio's documentation](https://www.twilio.com/docs){:target=_blank .external-link} for details about their API.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"ba0a0007-5739-4ccf-bca4-d474b631fe03","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"be7cc353b8ae2ce1c2d857fbd2b7f4fd07bbd95995bd08640b7ea8ed8662c377"}}


node_type: n8n-nodes-base.Twist
name: Twist
display_name: Twist
description: Consume Twist API
category: input
icon: file:twist.png
code_hash: e9b8d9315076ff304212703c7127f5754cf7480780be718af94afdd99f21a7b2
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.twist
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Twist = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const ChannelDescription_1 = require("./ChannelDescription");
  const MessageConversationDescription_1 = require("./MessageConversationDescription");
  const ThreadDescription_1 = require("./ThreadDescription");
  const CommentDescription_1 = require("./CommentDescription");
  const uuid_1 = require("uuid");
  const moment_1 = __importDefault(require("moment"));
  class Twist {
      constructor() {
          this.description = {
              displayName: 'Twist',
              name: 'twist',
              icon: 'file:twist.png',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Twist API',
              defaults: {
                  name: 'Twist',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'twistOAuth2Api',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Channel',
                              value: 'channel',
                          },
                          {
                              name: 'Comment',
                              value: 'comment',
                          },
                          {
                              name: 'Message Conversation',
                              value: 'messageConversation',
                          },
                          {
                              name: 'Thread',
                              value: 'thread',
                          },
                      ],
                      default: 'messageConversation',
                  },
                  ...ChannelDescription_1.channelOperations,
                  ...ChannelDescription_1.channelFields,
                  ...CommentDescription_1.commentOperations,
                  ...CommentDescription_1.commentFields,
                  ...MessageConversationDescription_1.messageConversationOperations,
                  ...MessageConversationDescription_1.messageConversationFields,
                  ...ThreadDescription_1.threadOperations,
                  ...ThreadDescription_1.threadFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getWorkspaces() {
                      const returnData = [];
                      const workspaces = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/workspaces/get');
                      for (const workspace of workspaces) {
                          returnData.push({
                              name: workspace.name,
                              value: workspace.id,
                          });
                      }
                      return returnData;
                  },
                  async getConversations() {
                      const returnData = [];
                      const qs = {
                          workspace_id: this.getCurrentNodeParameter('workspaceId'),
                      };
                      const conversations = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/conversations/get', {}, qs);
                      for (const conversation of conversations) {
                          returnData.push({
                              name: conversation.title || conversation.id,
                              value: conversation.id,
                          });
                      }
                      return returnData;
                  },
                  async getUsers() {
                      const returnData = [];
                      const qs = {
                          id: this.getCurrentNodeParameter('workspaceId'),
                      };
                      const users = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/workspaces/get_users', {}, qs);
                      for (const user of users) {
                          returnData.push({
                              name: user.name,
                              value: user.id,
                          });
                      }
                      return returnData;
                  },
                  async getGroups() {
                      const returnData = [];
                      const qs = {
                          workspace_id: this.getCurrentNodeParameter('workspaceId'),
                      };
                      const groups = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/groups/get', {}, qs);
                      for (const group of groups) {
                          returnData.push({
                              name: group.name,
                              value: group.id,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          const qs = {};
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'channel') {
                      if (operation === 'create') {
                          const workspaceId = this.getNodeParameter('workspaceId', i);
                          const name = this.getNodeParameter('name', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              workspace_id: workspaceId,
                              name,
                          };
                          Object.assign(body, additionalFields);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/channels/add', body);
                      }
                      if (operation === 'delete') {
                          qs.id = this.getNodeParameter('channelId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/channels/remove', {}, qs);
                      }
                      if (operation === 'get') {
                          qs.id = this.getNodeParameter('channelId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/channels/getone', {}, qs);
                      }
                      if (operation === 'getAll') {
                          const workspaceId = this.getNodeParameter('workspaceId', i);
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          qs.workspace_id = workspaceId;
                          Object.assign(qs, filters);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/channels/get', {}, qs);
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', i);
                              responseData = responseData.splice(0, limit);
                          }
                      }
                      if (operation === 'update') {
                          const channelId = this.getNodeParameter('channelId', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id: channelId,
                          };
                          Object.assign(body, updateFields);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/channels/update', body);
                      }
                      if (operation === 'archive') {
                          qs.id = this.getNodeParameter('channelId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/channels/archive', {}, qs);
                      }
                      if (operation === 'unarchive') {
                          qs.id = this.getNodeParameter('channelId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/channels/unarchive', {}, qs);
                      }
                  }
                  if (resource === 'comment') {
                      if (operation === 'create') {
                          const threadId = this.getNodeParameter('threadId', i);
                          const content = this.getNodeParameter('content', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              thread_id: threadId,
                              content,
                          };
                          Object.assign(body, additionalFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/comments/add', body);
                      }
                      if (operation === 'delete') {
                          qs.id = this.getNodeParameter('commentId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/comments/remove', {}, qs);
                      }
                      if (operation === 'get') {
                          qs.id = this.getNodeParameter('commentId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/comments/getone', {}, qs);
                          responseData = responseData === null || responseData === void 0 ? void 0 : responseData.comment;
                      }
                      if (operation === 'getAll') {
                          const threadId = this.getNodeParameter('threadId', i);
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          qs.thread_id = threadId;
                          Object.assign(qs, filters);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          if (qs.older_than_ts) {
                              qs.older_than_ts = (0, moment_1.default)(qs.older_than_ts).unix();
                          }
                          if (qs.newer_than_ts) {
                              qs.newer_than_ts = (0, moment_1.default)(qs.newer_than_ts).unix();
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/comments/get', {}, qs);
                          if (qs.as_ids) {
                              responseData = responseData.map((id) => ({ ID: id }));
                          }
                      }
                      if (operation === 'update') {
                          const commentId = this.getNodeParameter('commentId', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id: commentId,
                          };
                          Object.assign(body, updateFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/comments/update', body);
                      }
                  }
                  if (resource === 'messageConversation') {
                      if (operation === 'create') {
                          const workspaceId = this.getNodeParameter('workspaceId', i);
                          const conversationId = this.getNodeParameter('conversationId', i);
                          const content = this.getNodeParameter('content', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              conversation_id: conversationId,
                              workspace_id: workspaceId,
                              content,
                          };
                          Object.assign(body, additionalFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/conversation_messages/add', body);
                      }
                      if (operation === 'get') {
                          qs.id = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/conversation_messages/getone', {}, qs);
                      }
                      if (operation === 'getAll') {
                          const conversationId = this.getNodeParameter('conversationId', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          qs.conversation_id = conversationId;
                          Object.assign(qs, additionalFields);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/conversation_messages/get', {}, qs);
                      }
                      if (operation === 'delete') {
                          qs.id = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/conversation_messages/remove', {}, qs);
                      }
                      if (operation === 'update') {
                          const id = this.getNodeParameter('id', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id,
                          };
                          Object.assign(body, updateFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/conversation_messages/update', body);
                      }
                  }
                  if (resource === 'thread') {
                      if (operation === 'create') {
                          const channelId = this.getNodeParameter('channelId', i);
                          const title = this.getNodeParameter('title', i);
                          const content = this.getNodeParameter('content', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              channel_id: channelId,
                              content,
                              title,
                          };
                          Object.assign(body, additionalFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/threads/add', body);
                      }
                      if (operation === 'delete') {
                          qs.id = this.getNodeParameter('threadId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/threads/remove', {}, qs);
                      }
                      if (operation === 'get') {
                          qs.id = this.getNodeParameter('threadId', i);
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/threads/getone', {}, qs);
                      }
                      if (operation === 'getAll') {
                          const channelId = this.getNodeParameter('channelId', i);
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          qs.channel_id = channelId;
                          Object.assign(qs, filters);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          if (qs.older_than_ts) {
                              qs.older_than_ts = (0, moment_1.default)(qs.older_than_ts).unix();
                          }
                          if (qs.newer_than_ts) {
                              qs.newer_than_ts = (0, moment_1.default)(qs.newer_than_ts).unix();
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'GET', '/threads/get', {}, qs);
                          if (qs.as_ids) {
                              responseData = responseData.map((id) => ({ ID: id }));
                          }
                      }
                      if (operation === 'update') {
                          const threadId = this.getNodeParameter('threadId', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id: threadId,
                          };
                          Object.assign(body, updateFields);
                          if (body.actionsUi) {
                              const actions = body.actionsUi.actionValues;
                              if (actions) {
                                  body.actions = actions;
                                  delete body.actionsUi;
                              }
                          }
                          if (body.binaryProperties) {
                              const binaryProperties = body.binaryProperties.split(',');
                              const attachments = [];
                              for (const binaryProperty of binaryProperties) {
                                  const binaryData = this.helpers.assertBinaryData(i, binaryProperty);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
                                  attachments.push((await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/attachments/upload', {}, {}, {
                                      formData: {
                                          file_name: {
                                              value: dataBuffer,
                                              options: {
                                                  filename: binaryData.fileName,
                                              },
                                          },
                                          attachment_id: (0, uuid_1.v4)(),
                                      },
                                  })));
                              }
                              body.attachments = attachments;
                          }
                          if (body.direct_mentions) {
                              const directMentions = [];
                              for (const directMention of body.direct_mentions) {
                                  directMentions.push(`[name](twist-mention://${directMention})`);
                              }
                              body.content = `${directMentions.join(' ')} ${body.content}`;
                          }
                          responseData = await GenericFunctions_1.twistApiRequest.call(this, 'POST', '/threads/update', body);
                      }
                  }
                  if (Array.isArray(responseData)) {
                      returnData.push.apply(returnData, responseData);
                  }
                  else {
                      returnData.push(responseData);
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Twist = Twist;
  //# sourceMappingURL=Twist.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Twist node documentation
  description: Learn how to use the Twist node in n8n. Follow technical documentation to integrate Twist node into your workflows.
  contentType: [integration, reference]
  ---

  # Twist node

  Use the Twist node to automate work in Twist, and integrate Twist with other applications. n8n has built-in support for a wide range of Twist features, including creating conversations in a channel, as well as creating and deleting comments on a thread. 

  On this page, you'll find a list of operations the Twist node supports and links to more resources.

  /// note | Credentials
  Refer to [Twist credentials](/integrations/builtin/credentials/twist.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Channel
      * Archive a channel
      * Initiates a public or private channel-based conversation
      * Delete a channel
      * Get information about a channel
      * Get all channels
      * Unarchive a channel
      * Update a channel
  * Comment
      * Create a new comment to a thread
      * Delete a comment
      * Get information about a comment
      * Get all comments
      * Update a comment
  * Message Conversation
      * Create a message in a conversation
      * Delete a message in a conversation
      * Get a message in a conversation
      * Get all messages in a conversation
      * Update a message in a conversation
  * Thread
      * Create a new thread in a channel
      * Delete a thread
      * Get information about a thread
      * Get all threads
      * Update a thread

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'twist') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

  ## Get the User ID

  To get the User ID for a user:

  1. Open the **Team** tab.
  2. Select a user's avatar.
  3. Copy the string of characters located after `/u/` in your Twist URL. This string is the User ID. For example, if the URL is `https://twist.com/a/4qw45/people/u/475370` the User ID is `475370`.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"1c675b7b-1aeb-4f5e-af0e-5cfdb9928a25","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"79e53268675fc071245fdd021faa2588be9afdf59ba6892c2c573f9154b65430"}}


node_type: n8n-nodes-base.Twake
name: Twake
display_name: Twake
description: Consume Twake API
category: transform
icon: file:twake.png
code_hash: f118ef0fa20da4dc9fcaccdc87561206ca8708f58badba3b415d090b004c82bd
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.twake
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:35
updated_at: 2025-06-08 09:18:35
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Twake = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  class Twake {
      constructor() {
          this.description = {
              displayName: 'Twake',
              name: 'twake',
              group: ['transform'],
              version: 1,
              icon: 'file:twake.png',
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Twake API',
              defaults: {
                  name: 'Twake',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'twakeCloudApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Message',
                              value: 'message',
                              description: 'Send data to the message app',
                          },
                      ],
                      default: 'message',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                          },
                      },
                      options: [
                          {
                              name: 'Send',
                              value: 'send',
                              description: 'Send a message',
                              action: 'Send a message',
                          },
                      ],
                      default: 'send',
                  },
                  {
                      displayName: 'Channel Name or ID',
                      name: 'channelId',
                      type: 'options',
                      typeOptions: {
                          loadOptionsMethod: 'getChannels',
                      },
                      displayOptions: {
                          show: {
                              operation: ['send'],
                          },
                      },
                      default: '',
                      description: 'Channel\'s ID. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
                  },
                  {
                      displayName: 'Content',
                      name: 'content',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              operation: ['send'],
                          },
                      },
                      default: '',
                      description: 'Message content',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      displayOptions: {
                          show: {
                              operation: ['send'],
                          },
                      },
                      default: {},
                      options: [
                          {
                              displayName: 'Sender Icon',
                              name: 'senderIcon',
                              type: 'string',
                              default: '',
                              description: 'URL of the image/icon',
                          },
                          {
                              displayName: 'Sender Name',
                              name: 'senderName',
                              type: 'string',
                              default: '',
                          },
                      ],
                  },
              ],
          };
          this.methods = {
              loadOptions: {
                  async getChannels() {
                      const responseData = await GenericFunctions_1.twakeApiRequest.call(this, 'POST', '/channel', {});
                      if (responseData === undefined) {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No data got returned');
                      }
                      const returnData = [];
                      for (const channel of responseData) {
                          returnData.push({
                              name: channel.name,
                              value: channel.id,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              if (resource === 'message') {
                  if (operation === 'send') {
                      const additionalFields = this.getNodeParameter('additionalFields', i);
                      const message = {
                          channel_id: this.getNodeParameter('channelId', i),
                          content: {
                              formatted: this.getNodeParameter('content', i),
                          },
                          hidden_data: {
                              allow_delete: 'everyone',
                          },
                      };
                      if (additionalFields.senderName) {
                          message.hidden_data.custom_title = additionalFields.senderName;
                      }
                      if (additionalFields.senderIcon) {
                          message.hidden_data.custom_icon = additionalFields.senderIcon;
                      }
                      const body = {
                          object: message,
                      };
                      const endpoint = '/actions/message/save';
                      responseData = await GenericFunctions_1.twakeApiRequest.call(this, 'POST', endpoint, body);
                      responseData = responseData.object;
                  }
              }
          }
          if (Array.isArray(responseData)) {
              returnData.push.apply(returnData, responseData);
          }
          else if (responseData !== undefined) {
              returnData.push(responseData);
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Twake = Twake;
  //# sourceMappingURL=Twake.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Twake node documentation
  description: Learn how to use the Twake node in n8n. Follow technical documentation to integrate Twake node into your workflows.
  contentType: [integration, reference]
  ---

  # Twake node

  Use the Twake node to automate work in Twake, and integrate Twake with other applications. n8n supports sending messages with Twake.

  On this page, you'll find a list of operations the Twake node supports and links to more resources.

  /// note | Credentials
  Refer to [Twake credentials](/integrations/builtin/credentials/twake.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Message
      * Send a message

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'twake') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"fa475b26-be3e-4c2d-954c-105576eacbaa","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"574149d1678dbdb2a3046ed342c3aa754c10b2b822158beee08379e5bc3676be"}}


node_type: n8n-nodes-base.Twitter
name: Twitter
display_name: X (Formerly Twitter)
description: Consume the X API
category: output
icon: file:x.svg
code_hash: 5e1aad84374009c13bc16df5fbf185f045b053d91f9481ea49ec3337e43cd209
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.twitter
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Twitter = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const TwitterV1_node_1 = require("./V1/TwitterV1.node");
  const TwitterV2_node_1 = require("./V2/TwitterV2.node");
  class Twitter extends n8n_workflow_1.VersionedNodeType {
      constructor() {
          const baseDescription = {
              displayName: 'X (Formerly Twitter)',
              name: 'twitter',
              icon: 'file:x.svg',
              group: ['output'],
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the X API',
              defaultVersion: 2,
          };
          const nodeVersions = {
              1: new TwitterV1_node_1.TwitterV1(baseDescription),
              2: new TwitterV2_node_1.TwitterV2(baseDescription),
          };
          super(nodeVersions, baseDescription);
      }
  }
  exports.Twitter = Twitter;
  //# sourceMappingURL=Twitter.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: X (Formerly Twitter) node documentation
  description: Learn how to use the X (Formerly Twitter) node in n8n. Follow technical documentation to integrate X (Formerly Twitter) node into your workflows.
  contentType: [integration, reference]
  priority: medium
  ---

  # X (Formerly Twitter) node

  Use the X node to automate work in X and integrate X with other applications. n8n has built-in support for a wide range of X features, including creating direct messages and deleting, searching, liking, and retweeting a tweet. 

  On this page, you'll find a list of operations the X node supports and links to more resources.

  /// note | Credentials
  Refer to [X credentials](/integrations/builtin/credentials/twitter.md) for guidance on setting up authentication. 
  ///

  --8<-- "_snippets/integrations/builtin/app-nodes/ai-tools.md"

  ## Operations

  * Direct Message
      * Create a direct message
  * Tweet
      * Create or reply a tweet
      * Delete a tweet
      * Search tweets
      * Like a tweet
      * Retweet a tweet
  * User
    	* Get a user
  * List 
      * Add a member to a list

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'twitter') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"b2e43abd-50fe-4a86-b9bc-c451423ab62d","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"736574fa5dad8a67f81e74b7977a4747dfbc5f748e46328d930c09029d7e040f"}}


node_type: n8n-nodes-base.UProc
name: UProc
display_name: uProc
description: Consume uProc API
category: output
icon: file:uproc.png
code_hash: 24d13cc08ff97149e68e34a4a7b583ed84cc776550f9a6cd39738925e56418d9
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.uproc
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.UProc = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const GroupDescription_1 = require("./GroupDescription");
  const ToolDescription_1 = require("./ToolDescription");
  class UProc {
      constructor() {
          this.description = {
              displayName: 'uProc',
              name: 'uproc',
              icon: 'file:uproc.png',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["tool"]}}',
              description: 'Consume uProc API',
              defaults: {
                  name: 'uProc',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'uprocApi',
                      required: true,
                  },
              ],
              properties: [
                  ...GroupDescription_1.groupOptions,
                  ...ToolDescription_1.toolOperations,
                  ...ToolDescription_1.toolParameters,
                  {
                      displayName: 'Additional Options',
                      name: 'additionalOptions',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      displayOptions: {
                          show: {
                              group: [
                                  'audio',
                                  'communication',
                                  'company',
                                  'finance',
                                  'geographic',
                                  'image',
                                  'internet',
                                  'personal',
                                  'product',
                                  'security',
                                  'text',
                              ],
                          },
                      },
                      options: [
                          {
                              displayName: 'Data Webhook',
                              name: 'dataWebhook',
                              type: 'string',
                              description: 'URL to send tool response when tool has resolved your request',
                              default: '',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const group = this.getNodeParameter('group', 0);
          const tool = this.getNodeParameter('tool', 0);
          const additionalOptions = this.getNodeParameter('additionalOptions', 0);
          const dataWebhook = additionalOptions.dataWebhook;
          const fields = ToolDescription_1.toolParameters
              .filter((field) => {
              var _a, _b;
              return (((_b = (_a = field === null || field === void 0 ? void 0 : field.displayOptions) === null || _a === void 0 ? void 0 : _a.show) === null || _b === void 0 ? void 0 : _b.group) &&
                  field.displayOptions.show.tool &&
                  field.displayOptions.show.group.indexOf(group) !== -1 &&
                  field.displayOptions.show.tool.indexOf(tool) !== -1);
          })
              .map((field) => {
              return field.name;
          });
          for (let i = 0; i < length; i++) {
              try {
                  const toolKey = tool.replace(/([A-Z]+)/g, '-$1').toLowerCase();
                  const body = {
                      processor: toolKey,
                      params: {},
                  };
                  fields.forEach((field) => {
                      if (field === null || field === void 0 ? void 0 : field.length) {
                          const data = this.getNodeParameter(field, i);
                          body.params[field] = data + '';
                      }
                  });
                  if (dataWebhook === null || dataWebhook === void 0 ? void 0 : dataWebhook.length) {
                      body.callback = {};
                  }
                  if (dataWebhook === null || dataWebhook === void 0 ? void 0 : dataWebhook.length) {
                      body.callback.data = dataWebhook;
                  }
                  responseData = await GenericFunctions_1.uprocApiRequest.call(this, 'POST', body);
                  if (Array.isArray(responseData)) {
                      returnData.push.apply(returnData, responseData);
                  }
                  else {
                      returnData.push(responseData);
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.UProc = UProc;
  //# sourceMappingURL=UProc.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: uProc node documentation
  description: Learn how to use the uProc node in n8n. Follow technical documentation to integrate uProc node into your workflows.
  contentType: [integration, reference]
  ---

  # uProc node

  Use the uProc node to automate work in uProc, and integrate uProc with other applications. n8n has built-in support for a wide range of uProc features, including getting advanced human audio file, communication data, company, finance and product information. 

  On this page, you'll find a list of operations the uProc node supports and links to more resources.

  /// note | Credentials
  Refer to [uProc credentials](/integrations/builtin/credentials/uproc.md) for guidance on setting up authentication. 
  ///

  ## Operations

  ### Audio

  - Get advanced human audio file by provided text and language
  - Get an audio file by provided text and language

  ### Communication

  - Discover if a domain has a social network presence
  - Discover if an email is valid, hard bounce, soft bounce, spam-trap, free, temporary, and recipient exists
  - Discover if the email recipient exists, returning email status
  - Check if an email domain has an SMTP server to receive emails
  - Discover if the email has a social network presence
  - Check if an email has a valid format
  - Check if an email domain belongs to a disposable email service
  - Check if email belongs to free service provider like Gmail
  - Check if email is catchall
  - Discover if an email exists in the Robinson list (only Spain)
  - Check if email belongs to a system or role-based account
  - Check if an email is a spam trap
  - Discover if an IMEI number has a valid format
  - Check if a LinkedIn profile is a first-degree contact
  - Discover if mobile phone number exists in network operator, with worldwide coverage
  - Discover if a mobile phone number has a valid format with worldwide coverage
  - Discover if a mobile phone number has a valid format (only Spain)
  - Discover if a mobile phone number has a valid prefix, with worldwide coverage
  - Discover if a Spanish mobile phone number has a valid prefix
  - Discover if a mobile number is switched on to call it later, with worldwide coverage
  - Discover if a mobile number can receive SMS with worldwide coverage
  - Discover if a phone (landline or mobile) exists in a Robinson list (only Spain)
  - Discover if a landline or mobile number has a valid prefix
  - Discover if a landline phone number is valid, with Spain coverage
  - Allows discovering if landline number has a good international format, depending on the country
  - Discover if a landline phone number prefix exists, with worldwide coverage
  - Clean a phone removing non allowed characters
  - Allows getting country code of a mobile phone number with international format
  - Allows getting a domain from an email
  - Discover an email by company website or domain and prospect's first-name and last-name
  - Check if an email is personal or generic
  - Get emails list found on the internet by domain or URI
  - Get an emails list found on the internet by non-free email
  - Get emails list found inside the website by domain or URI
  - Get three first web references of an email published on the internet
  - Allows you to fix the email domain of those misspelled emails
  - Fix the international prefix of a phone based on the ISO code of a country
  - Get GDPR compliant emails list by domain for your Email Marketing campaigns in Europe
  - Discover if mobile exist using real-time HLR query
  - Get personal email by social network profile
  - Get portability data about a landline or mobile number, only for Spain
  - Extract results from a LinkedIn search (employees in a company)
  - Get members in a LinkedIn group
  - Get 'Search LinkedIn Contacts' URL
  - Extract the last 80 connections from your LinkedIn profile
  - Extract the last 80 invitations sent from your LinkedIn
  - Get users who comment on a post on LinkedIn
  - Get users who like a post on LinkedIn
  - Extract a LinkedIn profile
  - Extract results from a LinkedIn search (profiles)
  - Extract last profiles that have published content on LinkedIn by specific keywords
  - Discover if mobile exist using real-time HLR query, as well as portability and roaming data
  - Get existence, portability, and roaming of a mobile phone using MNP query
  - Discover if mobile or landline prefix exists in Spain
  - Allows normalizing email address, removing non allowed characters
  - Allows normalizing a mobile phone, removing non-allowed characters
  - Parse phone number in multiple fields and verify format and prefix validity
  - Allows getting country prefix number by country code
  - Discover an email by company website or domain and prospect's first-name and last-name
  - This tool parses a social URI address and extracts any available indicators
  - Search all social networks by domain, parses all found URLs, and returns social networks data
  - Discover if a domain or a website has social activity and returns all social network profiles found
  - Discover if an email has social activity, and get all social network profiles found
  - Discover if a mobile phone has social activity, and get all social network profiles found
  - Get web references for an email published on the internet
  - Send a custom message invitation to a non connected LinkedIn profile
  - Send a custom email to a recipient
  - Send a custom SMS to a recipient with worldwide coverage
  - Send a custom invitation message if a profile is connected or a custom message otherwise
  - Visits a profile to show interest and get profile views in return from contact, increasing your LinkedIn network
  - Send a custom private message to a connected LinkedIn profile
  - Get an email by contact's LinkedIn profile URI
  - Discover an email by company's name and prospect's full name
  - Discover an email by company's website or domain and prospect's full name
  - Get email by first name, last name, and company
  - Get parsed and validated phone

  ### Company

  - Discover if a CIF card number is valid
  - Check if a company is a debtor by TaxID
  - Check if the ISIN number is valid
  - Check if the SS number is valid, only for Spain
  - Identify and classify a prospecting role in detecting the right area and seniority to filter later
  - Get a company's contact, social, and technology data by domain
  - Get a company's contact, social, and technology data by email
  - Get a company's data by CIF
  - Get a company's data by DUNS
  - Get a company's data by domain
  - Get a company's data by email
  - Get a company's data by IP address
  - Get a company's data by name
  - Get a company's data by phone number
  - Get a company's data by social networks URI (LinkedIn, Twitter)
  - Get a company's name by company domain
  - Get professional data of a decision-maker by company name/domain and area
  - Discover more suitable decision-maker using search engines (Bing) by company name and area
  - Get professional emails of decision-makers by company domain and area
  - Discover up to ten decision-makers using search engines (Bing) by company name and area
  - Get a company's domain by company name
  - Get employees by company name or domain, area, seniority, and country
  - Get a company's Facebook profile by name without manually searching on Google or Facebook
  - Get geocoded company data by IP address
  - Get a company's LinkedIn profile by name without manually searching on Google or LinkedIn
  - Allows normalizing a CIF number, removing non-allowed characters
  - Get a company's phone by company domain
  - Get a company's sales data by a company's DUNS number
  - Get a company's sales data by a company's domain name
  - Get a company's sales data by a company's name
  - Get a company's sales data by a company's tax ID (CIF)
  - Get a company's Twitter profile by name without manually searching on Google or Twitter
  - Get decision maker by search engine
  - Get decision makers by search engine
  - Get Facebook URI by company's domain
  - Get GitHub URI by company's domain
  - Get Instagram URI by company's domain
  - Get LinkedIn URI by company's domain
  - Get Pinterest URI by company's domain
  - Get Twitter URI by company's domain
  - Get YouTube URI by company's domain

  ### Finance

  - Check if crypto wallet is valid
  - Discover if a BIC number has a valid format
  - Discover if an account number has a valid format
  - Check if credit card number checksum is valid
  - Discover if an IBAN account number has a valid format
  - Discover if an ISO currency code is valid
  - Check if a TIN exists in Europe
  - Convert amount between supported currencies and an exchange date
  - Get credit card type
  - Get multiple ISO currency codes by a country name
  - Get all ISO currency by an IP address
  - Get multiple ISO currency codes by a country ISO code
  - Get ISO currency code by IP address
  - Get ISO currency code by a currency ISO code
  - Get ISO currency code by an ISO country code
  - Get ISO currency code by a country name
  - Get related European TIN in Europe
  - Get IBAN by account number of the country
  - Get to search data bank information by IBAN account number
  - Get country VAT by address
  - Get country VAT by coordinates
  - Get Swift code lookup
  - Get VAT by IP address
  - Get VAT value by country ISO code
  - Get VAT by phone number, with worldwide coverage
  - Get VAT by zip code


  ### Geographical

  - Check if a country's ISO code exists
  - Discover if the distance between two coordinates is equal to another
  - Discover if the distance (kilometers) between two coordinates is greater than the given input
  - Discover if the distance (kilometers) between two coordinates is greater or equal to the given input
  - Discover if the distance(kilometers) between two coordinates is lower than the given input
  - Check if an address exists by a partial address search
  - Check if a house number exists by a partial address search
  - Check if coordinates have a valid format
  - Discover if a zip code number prefix exists (only for Spain)
  - Discover if a zip code number has a valid format (only for Spain)
  - Get cartesian coordinates(X, Y, Z/WGS84) by Latitude and Longitude
  - Get location by parameters
  - Get multiple cities by phone prefix (only for Spain)
  - Get multiple cities by partial initial text (only for Spain)
  - Get multiple cities by zip code prefix (only for Spain)
  - Get a city from IP
  - City search by partial name (only for Spain)
  - Discover the city name by a local phone number (only for Spain)
  - Discover the city name by the zip code (only for Spain)
  - Discover the community name from a zip code (only for Spain)
  - Discover latitude and longitude coordinates of an IP address
  - Discover latitude and longitude coordinates of a postal address
  - Get multiple country names by currency ISO code
  - Get multiple countries by ISO code
  - Get multiple country names by initial name
  - Get country name by currency ISO code
  - Get country name by IP address
  - Get country name by its ISO code
  - Get country by a prefix
  - Get country name by phone number, with worldwide coverage
  - Get Aplha2 code by a country prefix or a name
  - Get decimal coordinates (degrees, minutes, and seconds) by latitude and longitude
  - Returns straight-line distance (kilometers) between two addresses
  - Returns straight-line distance (kilometers) between two GPS coordinates (latitude and longitude)
  - Returns straight-line distance (kilometers) between two IP addresses
  - Returns straight-line distance (kilometers) between two landline phones, using city and province of every phone
  - Returns straight-line distance (kilometers) between two zip codes, using city and province of every zip code
  - Get an exact address by a partial address search
  - Discover geographical, company, timezone, and reputation data by IPv4 address
  - Discover the city name, zip code, province, country, latitude, and longitude from an IPv4 or IPv6 address and geocodes it
  - Parse postal address into separated fields, getting an improved resolution
  - Discover locale data (currency, language) by IPv4 or IPv6 address
  - Discover the city name, zip code, province, or country by latitude and longitude
  - Discover the city name, zip code, province, country, latitude, and longitude from an IPv4 or IPv6 address
  - Discover the city and the province from a landline phone number (only Spain)
  - Discover location data by name
  - Discover the city and the province from a zip code number (only Spain)
  - Get the most relevant locations by name
  - Get the most relevant locations by name, category, location, and radius
  - Get multiple personal names by a prefix
  - Discover network data by IPv4 or IPv6 address
  - Allow normalizing an address by removing non allowed characters
  - Allow normalizing a city by removing non allowed characters
  - Allow normalizing a country by removing non allowed characters
  - Allow normalizing a province by removing non allowed characters
  - Allow normalizing a zip code by removing non allowed characters
  - Get normalized country
  - Parse postal address into separated fields, getting a basic resolution
  - Discover the province name from an IP address
  - Get the first province by a name prefix (only for Spain)
  - Discover the province name from a landline phone number (only for Spain)
  - Discover the province name from a zip code number (only for Spain)
  - Get a province list by a name prefix (only for Spain)
  - Get a province list by a phone prefix (only for Spain)
  - Get a province list by a zip code prefix (only for Spain)
  - Discover reputation by IPv4 or IPv6 address
  - Returns driving routing time, distance, fuel consumption, and cost between two addresses
  - Returns driving routing time, distance, fuel consumption, and cost between two GPS coordinates
  - Returns driving routing time, distance, fuel consumption, and cost between two  IP addresses
  - Returns driving routing time, distance, fuel consumption, and cost between two landline phones, using city and province of every phone (only for Spain)
  - Returns driving routing time, distance, fuel consumption, and cost between two zip codes, using city and province of every zip code
  - Discover date-time data by IPv4 or IPv6 address
  - Get USNG coordinates by latitude and longitude
  - Get UTM coordinates by latitude and longitude
  - Discover the zip code if you have an IP address
  - Get the first zip code by prefix, only for Spain
  - Get multiple zip codes by prefix, with worldwide coverage
  - Get time data by coordinates
  - Get time data by postal address


  ### Image

  - Get QR code decoded content by an image URL
  - It allows discovering all geographical and technical EXIF metadata present in a photographic JPEG image
  - Get an encoded barcode by number and a required standard
  - Get QR code encoded by a text
  - Generate a new image by URL and text
  - Discover logo (favicon) used in a domain
  - Generate a screenshot by URL provided using Chrome browser
  - Get OCR text from image


  ### Internet

  - Check if a domain exists
  - Check if a domain has a DNS record
  - Check if a  domain has the given IP address assigned
  - Check if a domain has an MX record
  - Check if a domain has a valid SSL certificate
  - Check if a domain has a valid format
  - Check if a domain accepts all emails, existing or not
  - Check if a domain is a free service domain provider
  - Check if a domain is temporary or not
  - Discover if a computer is switched on
  - Discover if service in a port is available
  - Check if an URL contains a string or regular expression
  - Check if an URL exists
  - Check that an URL has a valid format
  - Get full SSL certificate data by a domain (or website) and monitor your certificate status
  - Get feed entries by domain
  - Get last feed entry by domain
  - Get text data from web, PDF or image allowing to filter some elements by regular expressions or field names
  - Decode URL to recover original
  - Get valid, existing, and default URL when accessing a domain using a web browser
  - Get long version of shortened URL
  - Discover device features by a user agent
  - Get the network name of and IP address
  - Get the domain record by its type
  - Encode URL to avoid problems
  - Copy file from one URL to another URL
  - Fix an IP address to the right format
  - Get the IPv4 address linked with a domain
  - Convert a number to an IP address
  - Get ISP known name of email domain name
  - Convert an IP address to numeric notation
  - Scan a host and returns the most commonly open ports
  - Obtains a list with multiple results from a website
  - Obtains the content of a website
  - Decode URL into multiple fields
  - Generate a PDF file by URL (provided using Chrome browser)
  - Get the root domain of any web address, removing non needed characters
  - Generates shareable URIs to use on social networks and email using a content URI and a text
  - Get data from the existing table in an HTML page or a PDF file
  - Discover client and server technologies used in a domain
  - Discover client and server technologies used in web pages
  - Analyze URL's health status about SSL, broken links, conflictive HTTP links with SSL, and more
  - Get website visits and rank of any domain
  - Get a domain's WHOIS data by fields
  - Get WHOIS data fields by IP address provided


  ### Personal

  - Check if age is between two numbers
  - Check if date returns an age between 20 and 29
  - Check if date returns an age between 40 and 49
  - Check if age is greater than another
  - Check if birth date returns an age greater than 64
  - Check if birth date belongs to an adult (18 years for Spain)
  - Check if age is lower than another
  - Check if age is lower or equal than another
  - Check if ages are equal
  - Discover if a date is between two dates
  - Discover if a date is greater
  - Discover if a date is greater or equal
  - Discover if a date belongs to a leap year
  - Discover if a date is lower
  - Discover if a date is lower or equal
  - Discover if a date has a valid format
  - Discover if a gender value is valid
  - Discover if an NIE card number is valid
  - Discover if a NIF card number is valid
  - Check if a personal name exists in the INE data source (only for Spain)
  - Check if a name contains accepted characters
  - Discover if a NIF exists in the Robinson list (only for Spain)
  - Check if surname contains accepted characters
  - Check if a personal surname appears in INE data source (only for Spain)
  - Discover if a DNI card number is valid
  - Discover the age of a birth date
  - Discover the age range of a person by birth date
  - Get the difference between two dates
  - Discover the gender of a person by the email
  - Discover the gender of a person or company by the name
  - Get LinkedIn employee profile URI by business email
  - Get LinkedIn employee profile URI by first name, last name, and company
  - Discover the letter of a DNI card number
  - Get first personal name matching by prefix and gender from INE data source (only for Spain)
  - Get LinkedIn URI by email
  - Get LinkedIn URI by phone
  - Allow normalizing a DNI number by removing non allowed characters
  - Allow normalizing an NIE number by removing non allowed characters
  - Normalize name by removing non allowed characters
  - Normalize surname
  - Get parsed date-time
  - Normalize full name, fixing abbreviations, sorting if necessary, and returning first name, last name, and gender
  - Get prospect's contact data and the company's location and social data by email
  - Get contact, location, and social data by email and company name and location
  - Get personal and social data by social profile
  - Get personal data by email
  - Get personal data by first name, last name, company, and location
  - Get personal data by mobile
  - Get personal data by social network profile
  - Generate random fake data
  - Get first personal surname matching by prefix from INE data source (only for Spain)
  - Get personal surname matching by prefix from INE data source (only for Spain)
  - Get Twitter profile by first name, last name, and company
  - Get XING profile by first name, last name, and company
  - Add a contact email to a person list

  ### Product

  - Check if an ASIN code exists on the Amazon Marketplace
  - Check if an ASIN code has a valid format
  - Check if an EAN code exists on Amazon Marketplace
  - Check if an EAN barcode has a valid format
  - Check if an EAN barcode of 13 digits has a valid format
  - Check if an EAN barcode of 14 digits has a valid format
  - Check if an EAN barcode of 18 digits has a valid format
  - Check if an EAN barcode of 8 digits has a valid format
  - Check if a GTIN barcode has a valid format
  - Check if a GTIN barcode of 13 digits has a valid format
  - Check if a GTIN barcode of 14 digits has a valid format
  - Check if a GTIN barcode of 8 digits has a valid format
  - Check if VIN Number is valid
  - Allows checking if an ISBN book exists
  - Allows checking if an ISBN10/13 code has a valid format
  - Allows checking if an ISBN10 code has a valid format
  - Allows checking if an ISBN13 code has a valid format
  - Check if a UPC exists
  - Check if a UPC has a valid format
  - Get ASIN by EAN
  - Get a book by author's surname
  - Get all publications by category
  - Get book data by an editor's name
  - Get book or publication data by 10 or 13 digits ISBN code
  - Get book data by title
  - Get books by author's surname
  - Get all books by category
  - Get all books by editor
  - Get all books by title
  - Get EAN code by ASIN code
  - Get product data on a UPC on Amazon Marketplace
  - Get ISBN10 code by ISBN13 code
  - Get ISBN13 code by ISBN10 code
  - Get data By VIN number

  ### Security

  - Check if a Luhn number is valid
  - Check if a password is strong
  - Check if a UUID number is valid
  - Get blacklists for a domain
  - Get blacklists for an IP address

  ### Text

  - Check if a string only contains alphabets
  - Check if a string is alphanumeric
  - Check if a string is boolean
  - Check if the largest item in a list matches the provided item
  - Check if IPv4 or IPv6 address has a valid format
  - Check if IPv4 address has a valid format
  - Check if IPv6 address has a valid format
  - Check if the length of a list is between two quantities
  - Checks if the length of a list equals a specified quantity
  - Checks if the length of a list is greater than or equal to a certain amount
  - Check if the length of a list is lower than a certain amount
  - Check if the list contains a specific item
  - Check if the list ends with a specific element
  - Check if a list is sorted in ascending order
  - Check if the list starts with a specific element
  - Checks if the smallest element in a list matches the provided element
  - Check if a string contains only numbers
  - Check if a string contains a character
  - Check if a string ends with a character
  - Check if a string has no content
  - Check if a string contains random characters
  - Check if a string contains a value that matches with a regular expression
  - Check if the length of a string is between two numbers
  - Check if the length of a string is equal to a number
  - Check if the length of a string is greater than a number
  - Check if the length of a string is greater or equal to a number
  - Check if the length of a string is lower than a number
  - Check if the length of a string is lower or equal to a number
  - Check if a string starts with a character
  - Check if a string contains only lowercase characters
  - Check if a string contains only uppercase characters
  - Check if a list consists of unique elements
  - Check if the supplied values form a valid list of elements
  - Check if the number of words in a sentence is between two determined quantities
  - Check if the number of words in a sentence equals a certain amount
  - Check if the number of words in a sentence is greater than a certain amount
  - Check if the number of words in a sentence is greater than
  - Check if the word count is lower
  - Check if the number of words present in a sentence is less than or equal to a quantity
  - Convert a string to Base64 encoded value
  - Discover banned English words in an email body or subject
  - Get field names by analyzing the field value provided
  - Get HTML code from Markdown
  - Get Markdown text from HTML
  - Get text without HTML
  - Get spin string
  - Format a string using a format pattern
  - Generate random string using a regular expression as a pattern
  - Return the largest item in a list
  - Return the smallest item in a list
  - Convert to lowercase
  - Convert a string to MD5 encoded value
  - Merge two strings
  - Normalize a string depending on the field name
  - Analyze string and return all emails, phones, zip codes, and links
  - Convert a string to an SHA encoded value
  - Analyze an English text with emojis and detect sentiment
  - Returns an ascending sorted list
  - Split a value into two parts and join them using a separator from the original string
  - Split a value into two parts using a separator from the original string
  - Get the length of a string
  - Lookup string between multiple values by fuzzy logic and regex patterns
  - Clean abuse words from a string
  - Replace the first value found in a string with another
  - Replace all values found in a string with another
  - Translate a text into any language
  - Return a single list with no repeating elements
  - Convert all letters to uppercase
  - Count total words in a text

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'uproc') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"2fc300be-6aa8-4498-b162-f339f02be15b","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"7ed11bc74e2fc13510935cb56936671e10eba3403c63264f6f66cbabe85c9a40"}}


node_type: n8n-nodes-base.UnleashedSoftware
name: UnleashedSoftware
display_name: Unleashed Software
description: Consume Unleashed Software API
category: transform
icon: file:unleashedSoftware.png
code_hash: 8773e68fb6b500f5f3588c5fd46d57e0a82cf6f5be5dc93c8d17f9c065a38708
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.unleashedsoftware
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.UnleashedSoftware = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const SalesOrderDescription_1 = require("./SalesOrderDescription");
  const StockOnHandDescription_1 = require("./StockOnHandDescription");
  const moment_1 = __importDefault(require("moment"));
  class UnleashedSoftware {
      constructor() {
          this.description = {
              displayName: 'Unleashed Software',
              name: 'unleashedSoftware',
              group: ['transform'],
              subtitle: '={{$parameter["operation"] + ":" + $parameter["resource"]}}',
              icon: 'file:unleashedSoftware.png',
              version: 1,
              description: 'Consume Unleashed Software API',
              defaults: {
                  name: 'Unleashed Software',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'unleashedSoftwareApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Sales Order',
                              value: 'salesOrder',
                          },
                          {
                              name: 'Stock On Hand',
                              value: 'stockOnHand',
                          },
                      ],
                      default: 'salesOrder',
                  },
                  ...SalesOrderDescription_1.salesOrderOperations,
                  ...SalesOrderDescription_1.salesOrderFields,
                  ...StockOnHandDescription_1.stockOnHandOperations,
                  ...StockOnHandDescription_1.stockOnHandFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          const qs = {};
          let responseData = [];
          for (let i = 0; i < length; i++) {
              const resource = this.getNodeParameter('resource', 0);
              const operation = this.getNodeParameter('operation', 0);
              if (resource === 'salesOrder') {
                  if (operation === 'getAll') {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const filters = this.getNodeParameter('filters', i);
                      if (filters.startDate) {
                          filters.startDate = (0, moment_1.default)(filters.startDate).format('YYYY-MM-DD');
                      }
                      if (filters.endDate) {
                          filters.endDate = (0, moment_1.default)(filters.endDate).format('YYYY-MM-DD');
                      }
                      if (filters.modifiedSince) {
                          filters.modifiedSince = (0, moment_1.default)(filters.modifiedSince).format('YYYY-MM-DD');
                      }
                      if (filters.orderStatus) {
                          filters.orderStatus = filters.orderStatus.join(',');
                      }
                      Object.assign(qs, filters);
                      if (returnAll) {
                          responseData = await GenericFunctions_1.unleashedApiRequestAllItems.call(this, 'Items', 'GET', '/SalesOrders', {}, qs);
                      }
                      else {
                          const limit = this.getNodeParameter('limit', i);
                          qs.pageSize = limit;
                          responseData = (await GenericFunctions_1.unleashedApiRequest.call(this, 'GET', '/SalesOrders', {}, qs, 1));
                          responseData = responseData.Items;
                      }
                      (0, GenericFunctions_1.convertNETDates)(responseData);
                      responseData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  }
              }
              if (resource === 'stockOnHand') {
                  if (operation === 'getAll') {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const filters = this.getNodeParameter('filters', i);
                      if (filters.asAtDate) {
                          filters.asAtDate = (0, moment_1.default)(filters.asAtDate).format('YYYY-MM-DD');
                      }
                      if (filters.modifiedSince) {
                          filters.modifiedSince = (0, moment_1.default)(filters.modifiedSince).format('YYYY-MM-DD');
                      }
                      if (filters.orderBy) {
                          filters.orderBy = filters.orderBy.trim();
                      }
                      Object.assign(qs, filters);
                      if (returnAll) {
                          responseData = await GenericFunctions_1.unleashedApiRequestAllItems.call(this, 'Items', 'GET', '/StockOnHand', {}, qs);
                      }
                      else {
                          const limit = this.getNodeParameter('limit', i);
                          qs.pageSize = limit;
                          responseData = (await GenericFunctions_1.unleashedApiRequest.call(this, 'GET', '/StockOnHand', {}, qs, 1));
                          responseData = responseData.Items;
                      }
                      (0, GenericFunctions_1.convertNETDates)(responseData);
                      responseData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  }
                  if (operation === 'get') {
                      const productId = this.getNodeParameter('productId', i);
                      responseData = await GenericFunctions_1.unleashedApiRequest.call(this, 'GET', `/StockOnHand/${productId}`);
                      (0, GenericFunctions_1.convertNETDates)(responseData);
                  }
              }
              const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
              returnData.push(...executionData);
          }
          return [returnData];
      }
  }
  exports.UnleashedSoftware = UnleashedSoftware;
  //# sourceMappingURL=UnleashedSoftware.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Unleashed Software node documentation
  description: Learn how to use the Unleashed Software node in n8n. Follow technical documentation to integrate Unleashed Software node into your workflows.
  contentType: [integration, reference]
  ---

  # Unleashed Software node

  Use the Unleashed Software node to automate work in Unleashed Software, and integrate Unleashed Software with other applications. n8n has built-in support for a wide range of Unleashed Software features, including getting sales orders and stock on hand. 

  On this page, you'll find a list of operations the Unleashed Software node supports and links to more resources.

  /// note | Credentials
  Refer to [Unleashed Software credentials](/integrations/builtin/credentials/unleashedsoftware.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Sales Order
      * Get all sales orders
  * Stock On Hand
      * Get a stock on hand
      * Get all stocks on hand

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'unleashed-software') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"2ac50c65-f019-4a04-bf66-85c2f0bdfbc0","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"3b938a3c04dd7a1a793dd2ac4f9635dbb7ac861f0c08c6a5e0b4602704144854"}}


node_type: n8n-nodes-base.Uplead
name: Uplead
display_name: Uplead
description: Consume Uplead API
category: output
icon: file:uplead.png
code_hash: 3ce27be43c0af9f6c0de56319d909fb40b551379d3fe62ccaa67dc9472090fa3
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.uplead
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Uplead = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const CompanyDesciption_1 = require("./CompanyDesciption");
  const PersonDescription_1 = require("./PersonDescription");
  class Uplead {
      constructor() {
          this.description = {
              displayName: 'Uplead',
              name: 'uplead',
              icon: 'file:uplead.png',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ":" + $parameter["resource"]}}',
              description: 'Consume Uplead API',
              defaults: {
                  name: 'Uplead',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'upleadApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Company',
                              value: 'company',
                              description: 'Company API lets you lookup company data via a domain name or company name',
                          },
                          {
                              name: 'Person',
                              value: 'person',
                              description: 'Person API lets you lookup a person based on an email address OR based on a domain name + first name + last name',
                          },
                      ],
                      default: 'company',
                  },
                  ...CompanyDesciption_1.companyOperations,
                  ...CompanyDesciption_1.companyFields,
                  ...PersonDescription_1.personOperations,
                  ...PersonDescription_1.personFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          const qs = {};
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'person') {
                      if (operation === 'enrich') {
                          const email = this.getNodeParameter('email', i);
                          const firstname = this.getNodeParameter('firstname', i);
                          const lastname = this.getNodeParameter('lastname', i);
                          const domain = this.getNodeParameter('domain', i);
                          if (email) {
                              qs.email = email;
                          }
                          if (firstname) {
                              qs.first_name = firstname;
                          }
                          if (lastname) {
                              qs.last_name = lastname;
                          }
                          if (domain) {
                              qs.domain = domain;
                          }
                          responseData = await GenericFunctions_1.upleadApiRequest.call(this, 'GET', '/person-search', {}, qs);
                      }
                  }
                  if (resource === 'company') {
                      if (operation === 'enrich') {
                          const domain = this.getNodeParameter('domain', i);
                          const company = this.getNodeParameter('company', i);
                          if (domain) {
                              qs.domain = domain;
                          }
                          if (company) {
                              qs.company = company;
                          }
                          responseData = await GenericFunctions_1.upleadApiRequest.call(this, 'GET', '/company-search', {}, qs);
                      }
                  }
                  if (Array.isArray(responseData.data)) {
                      returnData.push.apply(returnData, responseData.data);
                  }
                  else {
                      if (responseData.data !== null) {
                          returnData.push(responseData.data);
                      }
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Uplead = Uplead;
  //# sourceMappingURL=Uplead.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: UpLead node documentation
  description: Learn how to use the UpLead node in n8n. Follow technical documentation to integrate UpLead node into your workflows.
  contentType: [integration, reference]
  ---

  # UpLead node

  Use the UpLead node to automate work in UpLead, and integrate UpLead with other applications. n8n supports several UpLead operations, including getting company information. 

  On this page, you'll find a list of operations the UpLead node supports and links to more resources.

  /// note | Credentials
  Refer to [UpLead credentials](/integrations/builtin/credentials/uplead.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Company
      * Enrich
  * Person
      * Enrich

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'uplead') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"a213d952-5afd-4443-b5fa-f46dbd648175","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"a648f19caad564c8aef750bef57d4af73b281d3e1e8044beb3218a51fd8d6ba0"}}


node_type: n8n-nodes-base.UptimeRobot
name: UptimeRobot
display_name: UptimeRobot
description: Consume UptimeRobot API
category: output
icon: file:uptimerobot.svg
code_hash: b74303511b0fa831d7dd7988ab722bfae325dcf112b7c4820d7772ee00c7f7f8
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.uptimerobot
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.UptimeRobot = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const MonitorDescription_1 = require("./MonitorDescription");
  const AlertContactDescription_1 = require("./AlertContactDescription");
  const MaintenanceWindowDescription_1 = require("./MaintenanceWindowDescription");
  const PublicStatusPageDescription_1 = require("./PublicStatusPageDescription");
  const moment_timezone_1 = __importDefault(require("moment-timezone"));
  class UptimeRobot {
      constructor() {
          this.description = {
              displayName: 'UptimeRobot',
              name: 'uptimeRobot',
              icon: 'file:uptimerobot.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume UptimeRobot API',
              defaults: {
                  name: 'UptimeRobot',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'uptimeRobotApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Account',
                              value: 'account',
                          },
                          {
                              name: 'Alert Contact',
                              value: 'alertContact',
                          },
                          {
                              name: 'Maintenance Window',
                              value: 'maintenanceWindow',
                          },
                          {
                              name: 'Monitor',
                              value: 'monitor',
                          },
                          {
                              name: 'Public Status Page',
                              value: 'publicStatusPage',
                          },
                      ],
                      default: 'account',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['account'],
                          },
                      },
                      options: [
                          {
                              name: 'Get',
                              value: 'get',
                              description: 'Get account details',
                              action: 'Get an account',
                          },
                      ],
                      default: 'get',
                  },
                  ...MonitorDescription_1.monitorOperations,
                  ...MonitorDescription_1.monitorFields,
                  ...AlertContactDescription_1.alertContactOperations,
                  ...AlertContactDescription_1.alertContactFields,
                  ...MaintenanceWindowDescription_1.maintenanceWindowOperations,
                  ...MaintenanceWindowDescription_1.maintenanceWindowFields,
                  ...PublicStatusPageDescription_1.publicStatusPageOperations,
                  ...PublicStatusPageDescription_1.publicStatusPageFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const timezone = this.getTimezone();
          for (let i = 0; i < length; i++) {
              try {
                  const resource = this.getNodeParameter('resource', 0);
                  const operation = this.getNodeParameter('operation', 0);
                  let body = {};
                  if (resource === 'account') {
                      if (operation === 'get') {
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getAccountDetails');
                          responseData = responseData.account;
                      }
                  }
                  if (resource === 'monitor') {
                      if (operation === 'create') {
                          body = {
                              friendly_name: this.getNodeParameter('friendlyName', i),
                              url: this.getNodeParameter('url', i),
                              type: this.getNodeParameter('type', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/newMonitor', body);
                          responseData = responseData.monitor;
                      }
                      if (operation === 'delete') {
                          body = {
                              id: this.getNodeParameter('id', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/deleteMonitor', body);
                          responseData = responseData.monitor;
                      }
                      if (operation === 'get') {
                          const monitors = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getMonitors', {
                              monitors,
                          });
                          responseData = responseData.monitors;
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filters = this.getNodeParameter('filters', i);
                          body = {
                              ...filters,
                          };
                          if (body.statuses) {
                              body.statuses = body.statuses.join('-');
                          }
                          if (body.types) {
                              body.types = body.types.join('-');
                          }
                          if (body.alert_contacts) {
                              body.alert_contacts = 1;
                          }
                          if (body.logs) {
                              body.logs = 1;
                          }
                          if (body.mwindow) {
                              body.mwindows = 1;
                          }
                          if (body.response_times) {
                              body.response_times = 1;
                          }
                          if (!returnAll) {
                              body.limit = this.getNodeParameter('limit', i);
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getMonitors', body);
                          responseData = responseData.monitors;
                      }
                      if (operation === 'reset') {
                          body = {
                              id: this.getNodeParameter('id', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/resetMonitor', body);
                          responseData = responseData.monitor;
                      }
                      if (operation === 'update') {
                          body = {
                              id: this.getNodeParameter('id', i),
                              ...this.getNodeParameter('updateFields', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/editMonitor', body);
                          responseData = responseData.monitor;
                      }
                  }
                  if (resource === 'alertContact') {
                      if (operation === 'create') {
                          body = {
                              friendly_name: this.getNodeParameter('friendlyName', i),
                              value: this.getNodeParameter('value', i),
                              type: this.getNodeParameter('type', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/newAlertContact', body);
                          responseData = responseData.alertcontact;
                      }
                      if (operation === 'delete') {
                          body = {
                              id: this.getNodeParameter('id', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/deleteAlertContact', body);
                          responseData = responseData.alert_contact;
                      }
                      if (operation === 'get') {
                          const id = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getAlertContacts', {
                              alert_contacts: id,
                          });
                          responseData = responseData.alert_contacts;
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          body = {
                              ...this.getNodeParameter('filters', i),
                          };
                          if (!returnAll) {
                              body.limit = this.getNodeParameter('limit', i);
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getAlertContacts', body);
                          responseData = responseData.alert_contacts;
                      }
                      if (operation === 'update') {
                          body = {
                              id: this.getNodeParameter('id', i),
                              ...this.getNodeParameter('updateFields', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/editAlertContact', body);
                          responseData = responseData.alert_contact;
                      }
                  }
                  if (resource === 'maintenanceWindow') {
                      if (operation === 'create') {
                          const startTime = this.getNodeParameter('start_time', i);
                          const type = this.getNodeParameter('type', i);
                          const parsedStartTime = type === 1
                              ? moment_timezone_1.default.tz(startTime, timezone).unix()
                              : moment_timezone_1.default.tz(startTime, timezone).format('HH:mm');
                          body = {
                              duration: this.getNodeParameter('duration', i),
                              friendly_name: this.getNodeParameter('friendlyName', i),
                              start_time: parsedStartTime,
                              type,
                          };
                          if (type === 3) {
                              body.value = this.getNodeParameter('weekDay', i);
                          }
                          if (type === 4) {
                              body.value = this.getNodeParameter('monthDay', i);
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/newMWindow', body);
                          responseData = responseData.mwindow;
                      }
                      if (operation === 'delete') {
                          body = {
                              id: this.getNodeParameter('id', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/deleteMWindow', body);
                          responseData = { status: responseData.message };
                      }
                      if (operation === 'get') {
                          const mwindows = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getMWindows', {
                              mwindows,
                          });
                          responseData = responseData.mwindows;
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          body = {
                              ...this.getNodeParameter('filters', i),
                          };
                          if (!returnAll) {
                              body.limit = this.getNodeParameter('limit', i);
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getMWindows', body);
                          responseData = responseData.mwindows;
                      }
                      if (operation === 'update') {
                          body = {
                              id: this.getNodeParameter('id', i),
                              duration: this.getNodeParameter('duration', i),
                              ...this.getNodeParameter('updateFields', i),
                          };
                          if (body.type === 1 && body.start_time) {
                              body.start_time = moment_timezone_1.default.tz(body.start_time, timezone).unix();
                          }
                          else {
                              body.start_time = moment_timezone_1.default.tz(body.start_time, timezone).format('HH:mm');
                          }
                          if (body.type === 3) {
                              body.value = body.weekDay;
                              delete body.weekDay;
                          }
                          if (body.type === 4) {
                              body.value = body.monthDay;
                              delete body.monthDay;
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/editMWindow', body);
                          responseData = responseData.mwindow;
                      }
                  }
                  if (resource === 'publicStatusPage') {
                      if (operation === 'create') {
                          body = {
                              friendly_name: this.getNodeParameter('friendlyName', i),
                              monitors: this.getNodeParameter('monitors', i),
                              ...this.getNodeParameter('additionalFields', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/newPSP', body);
                          responseData = responseData.psp;
                      }
                      if (operation === 'delete') {
                          body = {
                              id: this.getNodeParameter('id', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/deletePSP', body);
                          responseData = responseData.psp;
                      }
                      if (operation === 'get') {
                          const psps = this.getNodeParameter('id', i);
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getPSPs', { psps });
                          responseData = responseData.psps;
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          body = {
                              ...this.getNodeParameter('filters', i),
                          };
                          if (!returnAll) {
                              body.limit = this.getNodeParameter('limit', i);
                          }
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/getPSPs', body);
                          responseData = responseData.psps;
                      }
                      if (operation === 'update') {
                          body = {
                              id: this.getNodeParameter('id', i),
                              ...this.getNodeParameter('updateFields', i),
                          };
                          responseData = await GenericFunctions_1.uptimeRobotApiRequest.call(this, 'POST', '/editPSP', body);
                          responseData = responseData.psp;
                      }
                  }
                  Array.isArray(responseData)
                      ? returnData.push(...responseData)
                      : returnData.push(responseData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.UptimeRobot = UptimeRobot;
  //# sourceMappingURL=UptimeRobot.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: UptimeRobot node documentation
  description: Learn how to use the UptimeRobot node in n8n. Follow technical documentation to integrate UptimeRobot node into your workflows.
  contentType: [integration, reference]
  ---

  # UptimeRobot node

  Use the UptimeRobot node to automate work in UptimeRobot, and integrate UptimeRobot with other applications. n8n has built-in support for a wide range of UptimeRobot features, including creating and deleting alerts, as well as getting account details. 

  On this page, you'll find a list of operations the UptimeRobot node supports and links to more resources.

  /// note | Credentials
  Refer to [UptimeRobot credentials](/integrations/builtin/credentials/uptimerobot.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Account
      * Get account details
  * Alert Contact
      * Create an alert contact
      * Delete an alert contact
      * Get an alert contact
      * Get all alert contacts
      * Update an alert contact
  * Maintenance Window
      * Create a maintenance window
      * Delete a maintenance window
      * Get a maintenance window
      * Get all a maintenance windows
      * Update a maintenance window
  * Monitor
      * Create a monitor
      * Delete a monitor
      * Get a monitor
      * Get all monitors
      * Reset a monitor
      * Update a monitor
  * Public Status Page
      * Create a public status page
      * Delete a public status page
      * Get a public status page
      * Get all a public status pages

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'uptimerobot') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"a81da827-0869-4337-b033-09e2fb332b5a","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"bcea7d1a2c2a79046a77c0e25914349028cce134c60910a9898ede5fca377fd0"}}


node_type: n8n-nodes-base.UrlScanIo
name: UrlScanIo
display_name: urlscan.io
description: Provides various utilities for monitoring websites like health checks or screenshots
category: transform
icon: file:urlScanIo.svg
code_hash: 9d774c970553defa6ffa786a53b69a8392799fa2e1f24be57c6343bc85d66c0f
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.urlscanio
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:36
updated_at: 2025-06-08 09:18:36
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.UrlScanIo = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const descriptions_1 = require("./descriptions");
  const GenericFunctions_1 = require("./GenericFunctions");
  class UrlScanIo {
      constructor() {
          this.description = {
              displayName: 'urlscan.io',
              name: 'urlScanIo',
              icon: 'file:urlScanIo.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Provides various utilities for monitoring websites like health checks or screenshots',
              defaults: {
                  name: 'urlscan.io',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'urlScanIoApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      noDataExpression: true,
                      type: 'options',
                      options: [
                          {
                              name: 'Scan',
                              value: 'scan',
                          },
                      ],
                      default: 'scan',
                  },
                  ...descriptions_1.scanOperations,
                  ...descriptions_1.scanFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          let responseData;
          for (let i = 0; i < items.length; i++) {
              try {
                  if (resource === 'scan') {
                      if (operation === 'get') {
                          const scanId = this.getNodeParameter('scanId', i);
                          responseData = await GenericFunctions_1.urlScanIoApiRequest.call(this, 'GET', `/result/${scanId}`);
                      }
                      else if (operation === 'getAll') {
                          const filters = this.getNodeParameter('filters', i);
                          const qs = {};
                          if (filters === null || filters === void 0 ? void 0 : filters.query) {
                              qs.q = filters.query;
                          }
                          responseData = await GenericFunctions_1.handleListing.call(this, '/search', qs);
                          responseData = responseData.map(GenericFunctions_1.normalizeId);
                      }
                      else if (operation === 'perform') {
                          const { tags: rawTags, ...rest } = this.getNodeParameter('additionalFields', i);
                          const body = {
                              url: this.getNodeParameter('url', i),
                              ...rest,
                          };
                          if (rawTags) {
                              const tags = rawTags.split(',').map((tag) => tag.trim());
                              if (tags.length > 10) {
                                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter at most 10 tags', {
                                      itemIndex: i,
                                  });
                              }
                              body.tags = tags;
                          }
                          responseData = await GenericFunctions_1.urlScanIoApiRequest.call(this, 'POST', '/scan', body);
                          responseData = (0, GenericFunctions_1.normalizeId)(responseData);
                      }
                  }
                  Array.isArray(responseData)
                      ? returnData.push(...responseData)
                      : returnData.push(responseData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.UrlScanIo = UrlScanIo;
  //# sourceMappingURL=UrlScanIo.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: urlscan.io node documentation
  description: Learn how to use the urlscan.io node in n8n. Follow technical documentation to integrate urlscan.io node into your workflows.
  contentType: [integration, reference]
  ---

  # urlscan.io node

  Use the urlscan.io node to automate work in urlscan.io, and integrate urlscan.io with other applications. n8n has built-in support for a wide range of urlscan.io features, including getting and performing scans. 

  On this page, you'll find a list of operations the urlscan.io node supports and links to more resources.

  /// note | Credentials
  Refer to [urlscan.io credentials](/integrations/builtin/credentials/urlscanio.md) for guidance on setting up authentication. 
  ///

  --8<-- "_snippets/integrations/builtin/app-nodes/ai-tools.md"

  ## Operations

  * Scan
      * Get
      * Get All
      * Perform

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'urlscanio') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"9b06c124-b95a-48f4-9834-e20fc962dd3c","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"d91bbb93bb85fdf54f12e7314400fb8de2500c5369360c872ca1e88e1d1316eb"}}


node_type: n8n-nodes-base.Wait
name: Wait
display_name: Wait
description: Wait before continue with execution
category: organization
icon: fa:pause-circle
code_hash: f333ea7964e6b65519eba2d7b53d16012d5933e9da8b9317eb76676b294e709a
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Wait = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const description_1 = require("../Webhook/description");
  const Webhook_node_1 = require("../Webhook/Webhook.node");
  const displayOnWebhook = {
      show: {
          resume: ['webhook'],
      },
  };
  class Wait extends Webhook_node_1.Webhook {
      constructor() {
          var _a, _b;
          super(...arguments);
          this.authPropertyName = 'incomingAuthentication';
          this.description = {
              displayName: 'Wait',
              name: 'wait',
              icon: 'fa:pause-circle',
              group: ['organization'],
              version: 1,
              description: 'Wait before continue with execution',
              defaults: {
                  name: 'Wait',
                  color: '#804050',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
              webhooks: [
                  {
                      ...description_1.defaultWebhookDescription,
                      responseData: '={{$parameter["responseData"]}}',
                      path: '={{$parameter["options"]["webhookSuffix"] || ""}}',
                      restartWebhook: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resume',
                      name: 'resume',
                      type: 'options',
                      options: [
                          {
                              name: 'After Time Interval',
                              value: 'timeInterval',
                              description: 'Waits for a certain amount of time',
                          },
                          {
                              name: 'At Specified Time',
                              value: 'specificTime',
                              description: 'Waits until a specific date and time to continue',
                          },
                          {
                              name: 'On Webhook Call',
                              value: 'webhook',
                              description: 'Waits for a webhook call before continuing',
                          },
                      ],
                      default: 'timeInterval',
                      description: 'Determines the waiting mode to use before the workflow continues',
                  },
                  {
                      ...(0, description_1.authenticationProperty)(this.authPropertyName),
                      description: 'If and how incoming resume-webhook-requests to $execution.resumeUrl should be authenticated for additional security',
                      displayOptions: displayOnWebhook,
                  },
                  {
                      displayName: 'Date and Time',
                      name: 'dateTime',
                      type: 'dateTime',
                      displayOptions: {
                          show: {
                              resume: ['specificTime'],
                          },
                      },
                      default: '',
                      description: 'The date and time to wait for before continuing',
                  },
                  {
                      displayName: 'Wait Amount',
                      name: 'amount',
                      type: 'number',
                      displayOptions: {
                          show: {
                              resume: ['timeInterval'],
                          },
                      },
                      typeOptions: {
                          minValue: 0,
                          numberPrecision: 2,
                      },
                      default: 1,
                      description: 'The time to wait',
                  },
                  {
                      displayName: 'Wait Unit',
                      name: 'unit',
                      type: 'options',
                      displayOptions: {
                          show: {
                              resume: ['timeInterval'],
                          },
                      },
                      options: [
                          {
                              name: 'Seconds',
                              value: 'seconds',
                          },
                          {
                              name: 'Minutes',
                              value: 'minutes',
                          },
                          {
                              name: 'Hours',
                              value: 'hours',
                          },
                          {
                              name: 'Days',
                              value: 'days',
                          },
                      ],
                      default: 'hours',
                      description: 'The time unit of the Wait Amount value',
                  },
                  {
                      displayName: 'The webhook URL will be generated at run time. It can be referenced with the <strong>$execution.resumeUrl</strong> variable. Send it somewhere before getting to this node. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.wait/?utm_source=n8n_app&utm_medium=node_settings_modal-credential_link&utm_campaign=n8n-nodes-base.wait" target="_blank">More info</a>',
                      name: 'webhookNotice',
                      type: 'notice',
                      displayOptions: displayOnWebhook,
                      default: '',
                  },
                  {
                      ...description_1.httpMethodsProperty,
                      displayOptions: displayOnWebhook,
                      description: 'The HTTP method of the Webhook call',
                  },
                  {
                      ...description_1.responseCodeProperty,
                      displayOptions: displayOnWebhook,
                  },
                  {
                      ...description_1.responseModeProperty,
                      displayOptions: displayOnWebhook,
                  },
                  {
                      ...description_1.responseDataProperty,
                      displayOptions: {
                          show: {
                              ...(_a = description_1.responseDataProperty.displayOptions) === null || _a === void 0 ? void 0 : _a.show,
                              ...displayOnWebhook.show,
                          },
                      },
                  },
                  {
                      ...description_1.responseBinaryPropertyNameProperty,
                      displayOptions: {
                          show: {
                              ...(_b = description_1.responseBinaryPropertyNameProperty.displayOptions) === null || _b === void 0 ? void 0 : _b.show,
                              ...displayOnWebhook.show,
                          },
                      },
                  },
                  {
                      displayName: 'Limit Wait Time',
                      name: 'limitWaitTime',
                      type: 'boolean',
                      default: false,
                      description: 'If no webhook call is received, the workflow will automatically resume execution after the specified limit type',
                      displayOptions: displayOnWebhook,
                  },
                  {
                      displayName: 'Limit Type',
                      name: 'limitType',
                      type: 'options',
                      default: 'afterTimeInterval',
                      description: 'Sets the condition for the execution to resume. Can be a specified date or after some time.',
                      displayOptions: {
                          show: {
                              limitWaitTime: [true],
                              ...displayOnWebhook.show,
                          },
                      },
                      options: [
                          {
                              name: 'After Time Interval',
                              description: 'Waits for a certain amount of time',
                              value: 'afterTimeInterval',
                          },
                          {
                              name: 'At Specified Time',
                              description: 'Waits until the set date and time to continue',
                              value: 'atSpecifiedTime',
                          },
                      ],
                  },
                  {
                      displayName: 'Amount',
                      name: 'resumeAmount',
                      type: 'number',
                      displayOptions: {
                          show: {
                              limitType: ['afterTimeInterval'],
                              limitWaitTime: [true],
                              ...displayOnWebhook.show,
                          },
                      },
                      typeOptions: {
                          minValue: 0,
                          numberPrecision: 2,
                      },
                      default: 1,
                      description: 'The time to wait',
                  },
                  {
                      displayName: 'Unit',
                      name: 'resumeUnit',
                      type: 'options',
                      displayOptions: {
                          show: {
                              limitType: ['afterTimeInterval'],
                              limitWaitTime: [true],
                              ...displayOnWebhook.show,
                          },
                      },
                      options: [
                          {
                              name: 'Seconds',
                              value: 'seconds',
                          },
                          {
                              name: 'Minutes',
                              value: 'minutes',
                          },
                          {
                              name: 'Hours',
                              value: 'hours',
                          },
                          {
                              name: 'Days',
                              value: 'days',
                          },
                      ],
                      default: 'hours',
                      description: 'Unit of the interval value',
                  },
                  {
                      displayName: 'Max Date and Time',
                      name: 'maxDateAndTime',
                      type: 'dateTime',
                      displayOptions: {
                          show: {
                              limitType: ['atSpecifiedTime'],
                              limitWaitTime: [true],
                              ...displayOnWebhook.show,
                          },
                      },
                      default: '',
                      description: 'Continue execution after the specified date and time',
                  },
                  {
                      ...description_1.optionsProperty,
                      displayOptions: displayOnWebhook,
                      options: [
                          ...description_1.optionsProperty.options,
                          {
                              displayName: 'Webhook Suffix',
                              name: 'webhookSuffix',
                              type: 'string',
                              default: '',
                              placeholder: 'webhook',
                              description: 'This suffix path will be appended to the restart URL. Helpful when using multiple wait nodes. Note: Does not support expressions.',
                          },
                      ],
                  },
              ],
          };
      }
      async execute(context) {
          const resume = context.getNodeParameter('resume', 0);
          if (resume === 'webhook') {
              return this.handleWebhookResume(context);
          }
          let waitTill;
          if (resume === 'timeInterval') {
              const unit = context.getNodeParameter('unit', 0);
              let waitAmount = context.getNodeParameter('amount', 0);
              if (unit === 'minutes') {
                  waitAmount *= 60;
              }
              if (unit === 'hours') {
                  waitAmount *= 60 * 60;
              }
              if (unit === 'days') {
                  waitAmount *= 60 * 60 * 24;
              }
              waitAmount *= 1000;
              waitTill = new Date(new Date().getTime() + waitAmount);
          }
          else {
              const dateTime = context.getNodeParameter('dateTime', 0);
              waitTill = new Date(dateTime);
          }
          const waitValue = Math.max(waitTill.getTime() - new Date().getTime(), 0);
          if (waitValue < 65000) {
              return new Promise((resolve, _reject) => {
                  setTimeout(() => {
                      resolve([context.getInputData()]);
                  }, waitValue);
              });
          }
          return this.putToWait(context, waitTill);
      }
      async handleWebhookResume(context) {
          let waitTill = new Date(n8n_workflow_1.WAIT_TIME_UNLIMITED);
          const limitWaitTime = context.getNodeParameter('limitWaitTime', 0);
          if (limitWaitTime === true) {
              const limitType = context.getNodeParameter('limitType', 0);
              if (limitType === 'afterTimeInterval') {
                  let waitAmount = context.getNodeParameter('resumeAmount', 0);
                  const resumeUnit = context.getNodeParameter('resumeUnit', 0);
                  if (resumeUnit === 'minutes') {
                      waitAmount *= 60;
                  }
                  if (resumeUnit === 'hours') {
                      waitAmount *= 60 * 60;
                  }
                  if (resumeUnit === 'days') {
                      waitAmount *= 60 * 60 * 24;
                  }
                  waitAmount *= 1000;
                  waitTill = new Date(new Date().getTime() + waitAmount);
              }
              else {
                  waitTill = new Date(context.getNodeParameter('maxDateAndTime', 0));
              }
          }
          return this.putToWait(context, waitTill);
      }
      async putToWait(context, waitTill) {
          await context.putExecutionToWait(waitTill);
          return [context.getInputData()];
      }
  }
  exports.Wait = Wait;
  //# sourceMappingURL=Wait.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Wait
  description: Documentation for the Wait node in n8n, a workflow automation platform. Includes guidance on usage, and links to examples.
  contentType: [integration, reference]
  priority: critical
  ---

  # Wait

  Use the Wait node pause your workflow's execution. When the workflow pauses it offloads the execution data to the database. When the resume condition is met, the workflow reloads the data and the execution continues.

  ## Operations

  The Wait node can **Resume** on the following conditions:

  * [**After Time Interval**](#after-time-interval): The node waits for a certain amount of time.
  * [**At Specified Time**](#at-specified-time): The node waits until a specific time.
  * [**On Webhook Call**](#on-webhook-call): The node waits until it receives an HTTP call.
  * [**On Form Submitted**](#on-form-submitted): The node waits until it receives a form submission.

  Refer to the more detailed sections below for more detailed instructions.

  ### After Time Interval

  Wait for a certain amount of time.

  This parameter includes two more fields:

  * **Wait Amount**: Enter the amount of time to wait.
  * **Wait Unit**: Select the unit of measure for the **Wait Amount**. Choose from:
  	* **Seconds**
  	* **Minutes**
  	* **Hours**
  	* **Days**

  Refer to [Time-based operations](#time-based-operations) for more detail on how these intervals work and the timezone used.

  ### At Specified Time

  Wait until a specific date and time to continue. Use the date and time picker to set the **Date and Time**.

  Refer to [Time-based operations](#time-based-operations) for more detail on the timezone used.

  ### On Webhook Call

  This parameter enables your workflows to resume when the Wait node receives an HTTP call.

  The webhook URL that resumes the execution when called is generated at runtime. The Wait node provides the `$execution.resumeUrl` variable so that you can reference and send the yet-to-be-generated URL wherever needed, for example to a third-party service or in an email. 

  When the workflow executes, the Wait node generates the resume URL and the webhook(s) in your workflow using the `$execution.resumeUrl`. This generated URL is unique to each execution, so your workflow can contain multiple Wait nodes and as the webhook URL is called it will resume each Wait node sequentially.

  For this **Resume** style, set more parameters listed below.

  #### Authentication

  Select if and how incoming resume-webhook-requests to `$execution.resumeUrl` should be authenticated. Options include:

  * **Basic Auth**: Use basic authentication. Select or enter a new **Credential for Basic Auth** to use.
  * **Header Auth**: Use header authentication. Select or enter a new **Credential for Header Auth** to use.
  * **JWT Auth**: Use JWT authentication. Select or enter a new **Credential for JWT Auth** to use.
  * **None**: Don't use authentication.

  /// note | Auth reference
  Refer to the [Webhook node | Authentication documentation](/integrations/builtin/core-nodes/n8n-nodes-base.webhook/index.md#supported-authentication-methods) for more information on each auth type.
  ///

  #### HTTP Method

  Select the HTTP method the webhook should use. Refer to the [Webhook node | HTTP Method documentation](/integrations/builtin/core-nodes/n8n-nodes-base.webhook/index.md#http-method) for more information.

  #### Response Code

  Enter the Response Code the webhook should return. You can use common codes or enter a custom code.

  #### Respond

  Set when and how to respond to the webhook from these options:

  * **Immediately**: Respond as soon as the node executes.
  * **When Last Node Finishes**: Return the response code and the data output from the last node executed in the workflow. If you select this option, also set:
  	* **Response Data**: Select what data should be returned and what format to use. Options include:
  		* **All Entries**: Returns all the entries of the last node in an array.
  		* **First Entry JSON**: Return the JSON data of the first entry of the last node in a JSON object.
  		* **First Entry Binary**: Return the binary data of the first entry of the last node in a binary file.
  		* **No Response Body**: Return with no body.
  * **Using 'Respond to Webhook' Node**: Respond as defined in the [Respond to Webhook](/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook.md) node.

  #### Limit Wait Time

  Set whether the workflow will automatically resume execution after a specific limit type (turned on) or not (turned off). If turned on, also set:

  * **Limit Type**: Select what type of limit to enforce from these options:
  	* **After Time Interval**: Wait for a certain amount of time.
  		* Enter the limit's **Amount** of time.
  		* Select the limit's **Unit** of time.
  	* **At Specified Time**: Wait until a specific date and time to resume.
  		* **Max Date and Time**: Use the date and time picker to set the specified time the node should resume.

  #### On Webhook Call options

  * **Binary Property**: Enter the name of the binary property to write the data of the received file to. This option's only relevant if binary data is received.
  * **Ignore Bots**: Set whether to ignore requests from bots like link previewers and web crawlers (turned on) or not (turned off).
  * **IP(s) Whitelist**: Enter IP addresses here to limit who (or what) can invoke the webhook URL. Enter a comma-separated list of allowed IP addresses. Access from IPs outside the whitelist throws a 403 error. If left blank, all IP addresses can invoke the webhook URL.
  * **No Response Body**: Set whether n8n should send a body in the response (turned off) or prevent n8n from sending a body in the response (turned on).
  * **Raw Body**: Set whether to return the body in a raw format like JSON or XML (turned on) or not (turned off).
  * **Response Data**: Enter any custom data you want to send in the response.
  * **Response Headers**: Send more headers in the webhook response. Refer to [MDN Web Docs | Response header](https://developer.mozilla.org/en-US/docs/Glossary/Response_header){:target=_blank .external-link} to learn more about response headers.
  * **Webhook Suffix**: Enter a suffix to append to the resume URL. This is useful for creating unique webhook URLs for each Wait node when a workflow contains multiple Wait nodes. Note that the generated `$resumeWebhookUrl` won't automatically include this suffix, you must manually append it to the webhook URL before exposing it.

  #### On Webhook Call limitations

  There are some limitations to keep in mind when using On Webhook Call:

  * Partial executions of your workflow changes the `$resumeWebhookUrl`, so be sure that the node sending this URL to your desired third-party runs in the same execution as the Wait node.

  ### On Form Submitted

  Wait for a form submission before continuing. Set up these parameters:

  #### Form Title

  Enter the title to display at the top of the form.

  #### Form Description

  Enter a form description to display beneath the title. This description can help prompt the user on how to complete the form.

  #### Form Fields

  Set up each field you want to appear on your form using these parameters:

  * **Field Label**: Enter the field label you want to appear in the form.
  * **Field Type**: Select the type of field to display in the form. Choose from:
  	* **Date**
  	* **Dropdown List**: Enter each dropdown options in the **Field Options**.
  		* **Multiple Choice**: Select whether the user can select a single dropdown option (turned off) or multiple dropdown options (turned on)
  	* **Number**
  	* **Password**
  	* **Text**
  	* **Textarea**
  * **Required Field**: Set whether the user must complete this field in order to submit the form (turned on) or if the user can submit the form without completing it (turned off).

  #### Respond When

  Set when to respond to the form submission. Choose from:

  * **Form Is Submitted**: Respond as soon as this node receives the form submission.
  * **Workflow Finishes**: Respond when the last node of this workflow finishes.
  * **Using 'Respond to Webhook' Node**: Respond when the [Respond to Webhook](/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook.md) node executes.

  #### Limit Wait Time

  Set whether the workflow will automatically resume execution after a specific limit type (turned on) or not (turned off).

  If turned on, also set:
  * **Limit Type**: Select what type of limit to enforce from these options:
  	* **After Time Interval**: Wait for a certain amount of time.
  		* Enter the limit's **Amount** of time.
  		* Select the limit's **Unit** of time.
  	* **At Specified Time**: Wait until a specific date and time to resume.
  		* **Max Date and Time**: Use the date and time picker to set the specified time the node should resume.

  #### On Form Response options

  * **Form Response**: Choose how and what you want the form to **Respond With** from these options:
  	* **Form Submitted Text**: The form displays whatever text is entered in **Text to Show** after a user fills out the form. Use this option if you want to display a confirmation message.
  	* **Redirect URL**: The form will redirect the user to the **URL to Redirect to** after they fill out the form. This must be a valid URL.
  * **Webhook Suffix**: Enter a suffix to append to the resume URL. This is useful for creating unique webhook URLs for each Wait node when a workflow contains multiple Wait nodes. Note that the generated `$resumeWebhookUrl` won't automatically include this suffix, you must manually append it to the webhook URL before exposing it.

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'wait') ]]

  ## Time-based operations

  For the time-based resume operations, note that:

  * For wait times less than 65 seconds, the workflow doesn't offload execution data to the database. Instead, the process continues to run and the execution resumes after the specified interval passes.
  * The n8n server time is always used regardless of the timezone setting. Workflow timezone settings, and any changes made to them, don't affect the Wait node interval or specified time. 

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"ee7dfa36-a12d-4a64-8388-be3f4a549571","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"c403e845a4d4f2a23cb1786a936c86b2659814c84dbaee297df25b1690d24077"}}


node_type: n8n-nodes-base.Vonage
name: Vonage
display_name: Vonage
description: Consume Vonage API
category: input
icon: file:vonage.png
code_hash: e56e55473d1585492c17d8199060fe1141d9eb4abc7d0d136b4a41da521a523e
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.vonage
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Vonage = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  class Vonage {
      constructor() {
          this.description = {
              displayName: 'Vonage',
              name: 'vonage',
              icon: 'file:vonage.png',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Vonage API',
              defaults: {
                  name: 'Vonage',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'vonageApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'SMS',
                              value: 'sms',
                          },
                      ],
                      default: 'sms',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Send',
                              value: 'send',
                              action: 'Send an SMS',
                          },
                      ],
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                          },
                      },
                      default: 'send',
                  },
                  {
                      displayName: 'From',
                      name: 'from',
                      type: 'string',
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                              operation: ['send'],
                          },
                      },
                      default: '',
                      description: 'The name or number the message should be sent from',
                  },
                  {
                      displayName: 'To',
                      name: 'to',
                      type: 'string',
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                              operation: ['send'],
                          },
                      },
                      default: '',
                      description: 'The number that the message should be sent to. Numbers are specified in E.164 format.',
                  },
                  {
                      displayName: 'Message',
                      name: 'message',
                      type: 'string',
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                              operation: ['send'],
                          },
                      },
                      default: '',
                      description: 'The body of the message being sent',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      displayOptions: {
                          show: {
                              resource: ['sms'],
                              operation: ['send'],
                          },
                      },
                      default: {},
                      options: [
                          {
                              displayName: 'Account Ref',
                              name: 'account-ref',
                              type: 'string',
                              default: '',
                              description: 'An optional string used to identify separate accounts using the SMS endpoint for billing purposes. To use this feature, please email support@nexmo.com.',
                          },
                          {
                              displayName: 'Callback',
                              name: 'callback',
                              type: 'string',
                              default: '',
                              description: 'The webhook endpoint the delivery receipt for this sms is sent to. This parameter overrides the webhook endpoint you set in Dashboard.',
                          },
                          {
                              displayName: 'Client Ref',
                              name: 'client-ref',
                              type: 'string',
                              default: '',
                              description: 'You can optionally include your own reference of up to 40 characters',
                          },
                          {
                              displayName: 'Message Class',
                              name: 'message-class',
                              type: 'options',
                              options: [
                                  {
                                      name: '0',
                                      value: 0,
                                  },
                                  {
                                      name: '1',
                                      value: 1,
                                  },
                                  {
                                      name: '2',
                                      value: 2,
                                  },
                                  {
                                      name: '3',
                                      value: 3,
                                  },
                              ],
                              default: '',
                              description: 'The Data Coding Scheme value of the message',
                          },
                          {
                              displayName: 'Protocol ID',
                              name: 'protocol-id',
                              type: 'string',
                              default: '',
                              description: 'The value of the protocol identifier to use. Ensure that the value is aligned with udh.',
                          },
                          {
                              displayName: 'Status Report Req',
                              name: 'status-report-req',
                              type: 'boolean',
                              default: false,
                              description: 'Whether to receive a Delivery Receipt',
                          },
                          {
                              displayName: 'TTL (in Minutes)',
                              name: 'ttl',
                              type: 'number',
                              default: 4320,
                              description: 'By default Nexmo attempt delivery for 72 hours',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'sms') {
                      if (operation === 'send') {
                          const from = this.getNodeParameter('from', i);
                          const to = this.getNodeParameter('to', i);
                          const type = this.getNodeParameter('type', i, 'text');
                          const body = {
                              from,
                              to,
                              type,
                          };
                          if (type === 'text' || type === 'unicode') {
                              const message = this.getNodeParameter('message', i);
                              body.text = message;
                          }
                          if (type === 'binary') {
                              const data = this.getNodeParameter('body', i);
                              const udh = this.getNodeParameter('udh', i);
                              body.udh = udh;
                              body.body = data;
                          }
                          if (type === 'wappush') {
                              const title = this.getNodeParameter('title', i);
                              const url = this.getNodeParameter('url', i);
                              const validity = this.getNodeParameter('validity', i);
                              body.title = title;
                              body.url = url;
                              body.validity = validity * 60000;
                          }
                          if (type === 'vcard') {
                              const vcard = this.getNodeParameter('vcard', i);
                              body.vcard = vcard;
                          }
                          if (type === 'vcal') {
                              const vcal = this.getNodeParameter('vcal', i);
                              body.vcal = vcal;
                          }
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(body, additionalFields);
                          if (body.ttl) {
                              body.ttl = body.ttl * 60000;
                          }
                          responseData = await GenericFunctions_1.vonageApiRequest.call(this, 'POST', '/sms/json', body);
                          responseData = responseData.messages;
                      }
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
              if (Array.isArray(responseData)) {
                  returnData.push.apply(returnData, responseData);
              }
              else if (responseData !== undefined) {
                  returnData.push(responseData);
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Vonage = Vonage;
  //# sourceMappingURL=Vonage.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Vonage node documentation
  description: Learn how to use the Vonage node in n8n. Follow technical documentation to integrate Vonage node into your workflows.
  contentType: [integration, reference]
  ---

  # Vonage node

  Use the Vonage node to automate work in Vonage, and integrate Vonage with other applications. n8n supports sending SMS with Vonage. 

  On this page, you'll find a list of operations the Vonage node supports and links to more resources.

  /// note | Credentials
  Refer to [Vonage credentials](/integrations/builtin/credentials/vonage.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * SMS
      * Send

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'vonage') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"e8c9c8cb-736a-4417-8703-f7b45b47dfdb","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"cee77bce486e3e07cbd7cbe73aada01429c2353b2491322cba70112bee3bb4b6"}}


node_type: n8n-nodes-base.Webflow
name: Webflow
display_name: Webflow
description: Consume the Webflow API
category: transform
icon: file:webflow.svg
code_hash: 6862aa4d34cdafe233189a97054c7356a36907c43238db2ef115afd5041849b0
documentation_url: https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.webflowtrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Webflow = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const ItemDescription_1 = require("./ItemDescription");
  class Webflow {
      constructor() {
          this.description = {
              displayName: 'Webflow',
              name: 'webflow',
              icon: 'file:webflow.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the Webflow API',
              defaults: {
                  name: 'Webflow',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'webflowApi',
                      required: true,
                      displayOptions: {
                          show: {
                              authentication: ['accessToken'],
                          },
                      },
                  },
                  {
                      name: 'webflowOAuth2Api',
                      required: true,
                      displayOptions: {
                          show: {
                              authentication: ['oAuth2'],
                          },
                      },
                  },
              ],
              properties: [
                  {
                      displayName: 'Authentication',
                      name: 'authentication',
                      type: 'options',
                      options: [
                          {
                              name: 'Access Token',
                              value: 'accessToken',
                          },
                          {
                              name: 'OAuth2',
                              value: 'oAuth2',
                          },
                      ],
                      default: 'accessToken',
                  },
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Item',
                              value: 'item',
                          },
                      ],
                      default: 'item',
                  },
                  ...ItemDescription_1.itemOperations,
                  ...ItemDescription_1.itemFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getSites() {
                      const returnData = [];
                      const sites = await GenericFunctions_1.webflowApiRequest.call(this, 'GET', '/sites');
                      for (const site of sites) {
                          returnData.push({
                              name: site.name,
                              value: site._id,
                          });
                      }
                      return returnData;
                  },
                  async getCollections() {
                      const returnData = [];
                      const siteId = this.getCurrentNodeParameter('siteId');
                      const collections = await GenericFunctions_1.webflowApiRequest.call(this, 'GET', `/sites/${siteId}/collections`);
                      for (const collection of collections) {
                          returnData.push({
                              name: collection.name,
                              value: collection._id,
                          });
                      }
                      return returnData;
                  },
                  async getFields() {
                      const returnData = [];
                      const collectionId = this.getCurrentNodeParameter('collectionId');
                      const { fields } = await GenericFunctions_1.webflowApiRequest.call(this, 'GET', `/collections/${collectionId}`);
                      for (const field of fields) {
                          returnData.push({
                              name: `${field.name} (${field.type}) ${field.required ? ' (required)' : ''}`,
                              value: field.slug,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          let responseData;
          const returnData = [];
          for (let i = 0; i < items.length; i++) {
              try {
                  if (resource === 'item') {
                      if (operation === 'create') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const properties = this.getNodeParameter('fieldsUi.fieldValues', i, []);
                          const live = this.getNodeParameter('live', i);
                          const fields = {};
                          properties.forEach((data) => (fields[data.fieldId] = data.fieldValue));
                          const body = {
                              fields,
                          };
                          responseData = await GenericFunctions_1.webflowApiRequest.call(this, 'POST', `/collections/${collectionId}/items`, body, { live });
                      }
                      else if (operation === 'delete') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          responseData = await GenericFunctions_1.webflowApiRequest.call(this, 'DELETE', `/collections/${collectionId}/items/${itemId}`);
                      }
                      else if (operation === 'get') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          responseData = await GenericFunctions_1.webflowApiRequest.call(this, 'GET', `/collections/${collectionId}/items/${itemId}`);
                          responseData = responseData.items;
                      }
                      else if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', 0);
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const qs = {};
                          if (returnAll) {
                              responseData = await GenericFunctions_1.webflowApiRequestAllItems.call(this, 'GET', `/collections/${collectionId}/items`, {}, qs);
                          }
                          else {
                              qs.limit = this.getNodeParameter('limit', 0);
                              responseData = await GenericFunctions_1.webflowApiRequest.call(this, 'GET', `/collections/${collectionId}/items`, {}, qs);
                              responseData = responseData.items;
                          }
                      }
                      else if (operation === 'update') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          const properties = this.getNodeParameter('fieldsUi.fieldValues', i, []);
                          const live = this.getNodeParameter('live', i);
                          const fields = {};
                          properties.forEach((data) => (fields[data.fieldId] = data.fieldValue));
                          const body = {
                              fields,
                          };
                          responseData = await GenericFunctions_1.webflowApiRequest.call(this, 'PUT', `/collections/${collectionId}/items/${itemId}`, body, { live });
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ json: { error: error.message } });
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.Webflow = Webflow;
  //# sourceMappingURL=Webflow.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Webflow Trigger node documentation
  description: Learn how to use the Webflow Trigger node in n8n. Follow technical documentation to integrate Webflow Trigger node into your workflows.
  contentType: [integration, reference]
  ---

  # Webflow Trigger node

  [Webflow](https://webflow.com){:target=_blank .external-link} is an application that allows you to build responsive websites with browser-based visual editing software.

  /// note | Credentials
  You can find authentication information for this node [here](/integrations/builtin/credentials/webflow.md).
  ///

  ///  note  | Examples and templates
  For usage examples and templates to help you get started, refer to n8n's [Webflow Trigger integrations](https://n8n.io/integrations/webflow-trigger/){:target=_blank .external-link} page.
  ///

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"fabd35bc-59d6-4c75-ae07-5171536fcada","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"23d50b03fdc7a1cbd4ba7842317f6db67733be4d7a008d93c109e342f063a538"}}


node_type: n8n-nodes-base.Vero
name: Vero
display_name: Vero
description: Consume Vero API
category: output
icon: file:vero.svg
code_hash: 37d697c0a7127e11a8f6dd2ee542a7dfbbf0ba4c38649c1acd4b7496c07fbeef
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.vero
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Vero = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const UserDescription_1 = require("./UserDescription");
  const EventDescripion_1 = require("./EventDescripion");
  class Vero {
      constructor() {
          this.description = {
              displayName: 'Vero',
              name: 'vero',
              icon: 'file:vero.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Vero API',
              defaults: {
                  name: 'Vero',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'veroApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'User',
                              value: 'user',
                              description: 'Create, update and manage the subscription status of your users',
                          },
                          {
                              name: 'Event',
                              value: 'event',
                              description: 'Track events based on actions your customers take in real time',
                          },
                      ],
                      default: 'user',
                  },
                  ...UserDescription_1.userOperations,
                  ...EventDescripion_1.eventOperations,
                  ...UserDescription_1.userFields,
                  ...EventDescripion_1.eventFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          for (let i = 0; i < length; i++) {
              try {
                  const resource = this.getNodeParameter('resource', 0);
                  const operation = this.getNodeParameter('operation', 0);
                  if (resource === 'user') {
                      if (operation === 'create') {
                          const id = this.getNodeParameter('id', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const jsonActive = this.getNodeParameter('jsonParameters', i);
                          const body = {
                              id,
                          };
                          if (additionalFields.email) {
                              body.email = additionalFields.email;
                          }
                          if (!jsonActive) {
                              const dataAttributesValues = this.getNodeParameter('dataAttributesUi', i).dataAttributesValues;
                              if (dataAttributesValues) {
                                  const dataAttributes = {};
                                  for (let index = 0; index < dataAttributesValues.length; index++) {
                                      dataAttributes[dataAttributesValues[index].key] =
                                          dataAttributesValues[index].value;
                                      body.data = dataAttributes;
                                  }
                              }
                          }
                          else {
                              const dataAttributesJson = (0, GenericFunctions_1.validateJSON)(this.getNodeParameter('dataAttributesJson', i));
                              if (dataAttributesJson) {
                                  body.data = dataAttributesJson;
                              }
                          }
                          try {
                              responseData = await GenericFunctions_1.veroApiRequest.call(this, 'POST', '/users/track', body);
                          }
                          catch (error) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
                          }
                      }
                      if (operation === 'alias') {
                          const id = this.getNodeParameter('id', i);
                          const newId = this.getNodeParameter('newId', i);
                          const body = {
                              id,
                              new_id: newId,
                          };
                          try {
                              responseData = await GenericFunctions_1.veroApiRequest.call(this, 'PUT', '/users/reidentify', body);
                          }
                          catch (error) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
                          }
                      }
                      if (operation === 'unsubscribe' ||
                          operation === 'resubscribe' ||
                          operation === 'delete') {
                          const id = this.getNodeParameter('id', i);
                          const body = {
                              id,
                          };
                          try {
                              responseData = await GenericFunctions_1.veroApiRequest.call(this, 'POST', `/users/${operation}`, body);
                          }
                          catch (error) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
                          }
                      }
                      if (operation === 'addTags' || operation === 'removeTags') {
                          const id = this.getNodeParameter('id', i);
                          const tags = this.getNodeParameter('tags', i).split(',');
                          const body = {
                              id,
                          };
                          if (operation === 'addTags') {
                              body.add = JSON.stringify(tags);
                          }
                          if (operation === 'removeTags') {
                              body.remove = JSON.stringify(tags);
                          }
                          try {
                              responseData = await GenericFunctions_1.veroApiRequest.call(this, 'PUT', '/users/tags/edit', body);
                          }
                          catch (error) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
                          }
                      }
                  }
                  if (resource === 'event') {
                      if (operation === 'track') {
                          const id = this.getNodeParameter('id', i);
                          const email = this.getNodeParameter('email', i);
                          const eventName = this.getNodeParameter('eventName', i);
                          const jsonActive = this.getNodeParameter('jsonParameters', i);
                          const body = {
                              identity: { id, email },
                              event_name: eventName,
                              email,
                          };
                          if (!jsonActive) {
                              const dataAttributesValues = this.getNodeParameter('dataAttributesUi', i).dataAttributesValues;
                              if (dataAttributesValues) {
                                  const dataAttributes = {};
                                  for (let index = 0; index < dataAttributesValues.length; index++) {
                                      dataAttributes[dataAttributesValues[index].key] =
                                          dataAttributesValues[index].value;
                                      body.data = JSON.stringify(dataAttributes);
                                  }
                              }
                              const extraAttributesValues = this.getNodeParameter('extraAttributesUi', i).extraAttributesValues;
                              if (extraAttributesValues) {
                                  const extraAttributes = {};
                                  for (let index = 0; index < extraAttributesValues.length; index++) {
                                      extraAttributes[extraAttributesValues[index].key] =
                                          extraAttributesValues[index].value;
                                      body.extras = JSON.stringify(extraAttributes);
                                  }
                              }
                          }
                          else {
                              const dataAttributesJson = (0, GenericFunctions_1.validateJSON)(this.getNodeParameter('dataAttributesJson', i));
                              if (dataAttributesJson) {
                                  body.data = JSON.stringify(dataAttributesJson);
                              }
                              const extraAttributesJson = (0, GenericFunctions_1.validateJSON)(this.getNodeParameter('extraAttributesJson', i));
                              if (extraAttributesJson) {
                                  body.extras = JSON.stringify(extraAttributesJson);
                              }
                          }
                          try {
                              responseData = await GenericFunctions_1.veroApiRequest.call(this, 'POST', '/events/track', body);
                          }
                          catch (error) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
                          }
                      }
                  }
                  if (Array.isArray(responseData)) {
                      returnData.push.apply(returnData, responseData);
                  }
                  else {
                      returnData.push(responseData);
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.message });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Vero = Vero;
  //# sourceMappingURL=Vero.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Vero node documentation
  description: Learn how to use the Vero node in n8n. Follow technical documentation to integrate Vero node into your workflows.
  contentType: [integration, reference]
  ---

  # Vero node

  Use the Vero node to automate work in Vero and integrate Vero with other applications. n8n has built-in support for a wide range of Vero features, including creating and deleting users. 

  On this page, you'll find a list of operations the Vero node supports and links to more resources.

  /// note | Credentials
  Refer to [Vero credentials](/integrations/builtin/credentials/vero.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * User
      * Create or update a user profile
      * Change a users identifier
      * Unsubscribe a user.
      * Resubscribe a user.
      * Delete a user.
      * Adds a tag to a users profile.
      * Removes a tag from a users profile.
  * Event
      * Track an event for a specific customer

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'vero') ]]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"a06e8acd-abf3-47eb-af37-03b920cf40ed","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"715c53956506b2c2f459d32e3c3c3e662c2a30004da06d99aab6865f934a6fa8"}}


node_type: n8n-nodes-base.Webhook
name: Webhook
display_name: Webhook
description: Starts the workflow when a webhook is called
category: trigger
icon: file:webhook.svg
code_hash: 143d6bbdce335c5a9204112b2c1e8b92e4061d75ba3cb23301845f6fed9e6c71
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Webhook = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const promises_1 = require("stream/promises");
  const fs_1 = require("fs");
  const uuid_1 = require("uuid");
  const basic_auth_1 = __importDefault(require("basic-auth"));
  const isbot_1 = __importDefault(require("isbot"));
  const tmp_promise_1 = require("tmp-promise");
  const description_1 = require("./description");
  const error_1 = require("./error");
  class Webhook extends n8n_workflow_1.Node {
      constructor() {
          super(...arguments);
          this.authPropertyName = 'authentication';
          this.description = {
              displayName: 'Webhook',
              icon: 'file:webhook.svg',
              name: 'webhook',
              group: ['trigger'],
              version: 1,
              description: 'Starts the workflow when a webhook is called',
              eventTriggerDescription: 'Waiting for you to call the Test URL',
              activationMessage: 'You can now make calls to your production webhook URL.',
              defaults: {
                  name: 'Webhook',
              },
              triggerPanel: {
                  header: '',
                  executionsHelp: {
                      inactive: 'Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the \'listen\' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. <a data-key="activate">Activate</a> the workflow, then make requests to the production URL. These executions will show up in the executions list, but not in the editor.',
                      active: 'Webhooks have two modes: test and production. <br /> <br /> <b>Use test mode while you build your workflow</b>. Click the \'listen\' button, then make a request to the test URL. The executions will show up in the editor.<br /> <br /> <b>Use production mode to run your workflow automatically</b>. Since the workflow is activated, you can make requests to the production URL. These executions will show up in the <a data-key="executions">executions list</a>, but not in the editor.',
                  },
                  activationHint: 'Once you’ve finished building your workflow, run it without having to click this button by using the production webhook URL.',
              },
              inputs: [],
              outputs: ['main'],
              credentials: (0, description_1.credentialsProperty)(this.authPropertyName),
              webhooks: [description_1.defaultWebhookDescription],
              properties: [
                  (0, description_1.authenticationProperty)(this.authPropertyName),
                  description_1.httpMethodsProperty,
                  {
                      displayName: 'Path',
                      name: 'path',
                      type: 'string',
                      default: '',
                      placeholder: 'webhook',
                      required: true,
                      description: 'The path to listen to',
                  },
                  description_1.responseModeProperty,
                  {
                      displayName: 'Insert a \'Respond to Webhook\' node to control when and how you respond. <a href="https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.respondtowebhook/" target="_blank">More details</a>',
                      name: 'webhookNotice',
                      type: 'notice',
                      displayOptions: {
                          show: {
                              responseMode: ['responseNode'],
                          },
                      },
                      default: '',
                  },
                  description_1.responseCodeProperty,
                  description_1.responseDataProperty,
                  description_1.responseBinaryPropertyNameProperty,
                  description_1.optionsProperty,
              ],
          };
      }
      async webhook(context) {
          var _a;
          const options = context.getNodeParameter('options', {});
          const req = context.getRequestObject();
          const resp = context.getResponseObject();
          try {
              if (options.ignoreBots && (0, isbot_1.default)(req.headers['user-agent']))
                  throw new error_1.WebhookAuthorizationError(403);
              await this.validateAuth(context);
          }
          catch (error) {
              if (error instanceof error_1.WebhookAuthorizationError) {
                  resp.writeHead(error.responseCode, { 'WWW-Authenticate': 'Basic realm="Webhook"' });
                  resp.end(error.message);
                  return { noWebhookResponse: true };
              }
              throw error;
          }
          if (options.binaryData) {
              return this.handleBinaryData(context);
          }
          if (req.contentType === 'multipart/form-data') {
              return this.handleFormData(context);
          }
          const response = {
              json: {
                  headers: req.headers,
                  params: req.params,
                  query: req.query,
                  body: req.body,
              },
              binary: options.rawBody
                  ? {
                      data: {
                          data: req.rawBody.toString(n8n_workflow_1.BINARY_ENCODING),
                          mimeType: (_a = req.contentType) !== null && _a !== void 0 ? _a : 'application/json',
                      },
                  }
                  : undefined,
          };
          return {
              webhookResponse: options.responseData,
              workflowData: [[response]],
          };
      }
      async validateAuth(context) {
          const authentication = context.getNodeParameter(this.authPropertyName);
          if (authentication === 'none')
              return;
          const req = context.getRequestObject();
          const headers = context.getHeaderData();
          if (authentication === 'basicAuth') {
              let expectedAuth;
              try {
                  expectedAuth = await context.getCredentials('httpBasicAuth');
              }
              catch { }
              if (expectedAuth === undefined || !expectedAuth.user || !expectedAuth.password) {
                  throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
              }
              const providedAuth = (0, basic_auth_1.default)(req);
              if (!providedAuth)
                  throw new error_1.WebhookAuthorizationError(401);
              if (providedAuth.name !== expectedAuth.user || providedAuth.pass !== expectedAuth.password) {
                  throw new error_1.WebhookAuthorizationError(403);
              }
          }
          else if (authentication === 'headerAuth') {
              let expectedAuth;
              try {
                  expectedAuth = await context.getCredentials('httpHeaderAuth');
              }
              catch { }
              if (expectedAuth === undefined || !expectedAuth.name || !expectedAuth.value) {
                  throw new error_1.WebhookAuthorizationError(500, 'No authentication data defined on node!');
              }
              const headerName = expectedAuth.name.toLowerCase();
              const expectedValue = expectedAuth.value;
              if (!headers.hasOwnProperty(headerName) ||
                  headers[headerName] !== expectedValue) {
                  throw new error_1.WebhookAuthorizationError(403);
              }
          }
      }
      async handleFormData(context) {
          var _a;
          const req = context.getRequestObject();
          const options = context.getNodeParameter('options', {});
          const { data, files } = req.body;
          const returnItem = {
              binary: {},
              json: {
                  headers: req.headers,
                  params: req.params,
                  query: req.query,
                  body: data,
              },
          };
          let count = 0;
          for (const key of Object.keys(files)) {
              const processFiles = [];
              let multiFile = false;
              if (Array.isArray(files[key])) {
                  processFiles.push(...files[key]);
                  multiFile = true;
              }
              else {
                  processFiles.push(files[key]);
              }
              let fileCount = 0;
              for (const file of processFiles) {
                  let binaryPropertyName = key;
                  if (binaryPropertyName.endsWith('[]')) {
                      binaryPropertyName = binaryPropertyName.slice(0, -2);
                  }
                  if (multiFile) {
                      binaryPropertyName += fileCount++;
                  }
                  if (options.binaryPropertyName) {
                      binaryPropertyName = `${options.binaryPropertyName}${count}`;
                  }
                  returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(file.filepath, (_a = file.originalFilename) !== null && _a !== void 0 ? _a : file.newFilename, file.mimetype);
                  count += 1;
              }
          }
          return { workflowData: [[returnItem]] };
      }
      async handleBinaryData(context) {
          var _a, _b, _c;
          const req = context.getRequestObject();
          const options = context.getNodeParameter('options', {});
          const binaryFile = await (0, tmp_promise_1.file)({ prefix: 'n8n-webhook-' });
          try {
              await (0, promises_1.pipeline)(req, (0, fs_1.createWriteStream)(binaryFile.path));
              const returnItem = {
                  binary: {},
                  json: {
                      headers: req.headers,
                      params: req.params,
                      query: req.query,
                      body: {},
                  },
              };
              const binaryPropertyName = (options.binaryPropertyName || 'data');
              const fileName = (_b = (_a = req.contentDisposition) === null || _a === void 0 ? void 0 : _a.filename) !== null && _b !== void 0 ? _b : (0, uuid_1.v4)();
              returnItem.binary[binaryPropertyName] = await context.nodeHelpers.copyBinaryFile(binaryFile.path, fileName, (_c = req.contentType) !== null && _c !== void 0 ? _c : 'application/octet-stream');
              return { workflowData: [[returnItem]] };
          }
          catch (error) {
              throw new n8n_workflow_1.NodeOperationError(context.getNode(), error);
          }
          finally {
              await binaryFile.cleanup();
          }
      }
  }
  exports.Webhook = Webhook;
  //# sourceMappingURL=Webhook.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Respond to Webhook
  description: Documentation for the Respond to Webhook node in n8n, a workflow automation platform. Includes guidance on usage, and links to examples.
  contentType: [integration, reference]
  priority: critical
  ---

  # Respond to Webhook

  Use the Respond to Webhook node to control the response to incoming webhooks. This node works with the [Webhook](/integrations/builtin/core-nodes/n8n-nodes-base.webhook/index.md) node.

  /// note | Runs once for the first data item
  The Respond to Webhook node runs once, using the first incoming data item. Refer to [Return more than one data item](#return-more-than-one-data-item-deprecated) for more information.
  ///

  ## How to use Respond to Webhook

  To use the Respond to Webhook node:

  1. Add a [Webhook](/integrations/builtin/core-nodes/n8n-nodes-base.webhook/index.md) node as the trigger node for the workflow.
  1. In the Webhook node, set **Respond** to **Using 'Respond to Webhook' node**.
  1. Add the Respond to Webhook node anywhere in your workflow. If you want it to return data from other nodes, place it after those nodes.

  ## Node parameters

  Configure the node behavior using these parameters.

  ### Respond With

  Choose what data to send in the webhook response.

  - **All Incoming Items**: Respond with all the JSON items from the input.
  - **Binary**: Respond with a binary file defined in **Response Data Source**.
  - **First Incoming Item**: Respond with the first incoming item's JSON.
  - **JSON**: Respond with a JSON object defined in **Response Body**.
  - **No Data**: No response payload.
  - **Redirect**: Redirect to a URL set in **Redirect URL**.
  - **Text**: Respond with text set in **Response Body**.

  ## Node options

  Select **Add Option** to view and set the options.

  - **Response Code**: Set the [response code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status){:target=_blank .external-link} to use.
  - **Response Headers**: Define the response headers to send.
  - **Put Response in Field**: Available when you respond with **All Incoming Items** or **First Incoming Item**. Set the field name for the field containing the response data.

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'respond-to-webhook') ]]

  ## Workflow behavior

  When using the Respond to Webhook node, workflows behave as follows:

  - The workflow finishes without executing the Respond to Webhook node: it returns a standard message with a 200 status.
  - The workflow errors before the first Respond to Webhook node executes: the workflow returns an error message with a 500 status.
  - A second Respond to Webhook node executes after the first one: the workflow ignores it.
  - A Respond to Webhook node executes but there was no webhook: the workflow ignores the Respond to Webhook node.

  ## Return more than one data item (deprecated)

  /// note | Deprecated in 1.22.0
  n8n 1.22.0 added support for returning all data items using the **All Incoming Items** option. n8n recommends upgrading to the latest version of n8n, instead of using the workarounds described in this section.
  ///

  The Respond to Webhook node runs once, using the first incoming data item. This includes when using [expressions](/code/expressions.md). You can't force looping using the Loop node: the workflow will run, but the webhook response will still only contain the results of the first execution. 

  If you need to return more than one data item, choose one of these options:

  - Instead of using the Respond to Webhook node, use the **When Last Node Finishes** option in **Respond** in the Webhook node. Use this when you want to return the final data that the workflow outputs.
  - Use the [Aggregate](/integrations/builtin/core-nodes/n8n-nodes-base.aggregate.md) node to turn multiple items into a single item before passing the data to the Respond to Webhook node. Set **Aggregate** to **All Item Data (Into a Single List)**.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"3c63e54b-09ff-4034-947e-a5847e7e6d26","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"3b815a18d0114f6c1adf5d560dd6eb75f9651713bd5422c323bc4db957697720"}}


node_type: n8n-nodes-base.Wekan
name: Wekan
display_name: Wekan
description: Consume Wekan API
category: transform
icon: file:wekan.png
code_hash: 7fa9339c04210a8df356f15f28131919effd00d88c7ed637e194ef9000461f1a
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.wekan
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:38
updated_at: 2025-06-08 09:18:38
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Wekan = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const BoardDescription_1 = require("./BoardDescription");
  const CardDescription_1 = require("./CardDescription");
  const CardCommentDescription_1 = require("./CardCommentDescription");
  const ChecklistDescription_1 = require("./ChecklistDescription");
  const ChecklistItemDescription_1 = require("./ChecklistItemDescription");
  const ListDescription_1 = require("./ListDescription");
  const utilities_1 = require("../../utils/utilities");
  class Wekan {
      constructor() {
          this.description = {
              displayName: 'Wekan',
              name: 'wekan',
              icon: 'file:wekan.png',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Wekan API',
              defaults: {
                  name: 'Wekan',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'wekanApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Board',
                              value: 'board',
                          },
                          {
                              name: 'Card',
                              value: 'card',
                          },
                          {
                              name: 'Card Comment',
                              value: 'cardComment',
                          },
                          {
                              name: 'Checklist',
                              value: 'checklist',
                          },
                          {
                              name: 'Checklist Item',
                              value: 'checklistItem',
                          },
                          {
                              name: 'List',
                              value: 'list',
                          },
                      ],
                      default: 'card',
                  },
                  ...BoardDescription_1.boardOperations,
                  ...CardDescription_1.cardOperations,
                  ...CardCommentDescription_1.cardCommentOperations,
                  ...ChecklistDescription_1.checklistOperations,
                  ...ChecklistItemDescription_1.checklistItemOperations,
                  ...ListDescription_1.listOperations,
                  ...BoardDescription_1.boardFields,
                  ...CardDescription_1.cardFields,
                  ...CardCommentDescription_1.cardCommentFields,
                  ...ChecklistDescription_1.checklistFields,
                  ...ChecklistItemDescription_1.checklistItemFields,
                  ...ListDescription_1.listFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getUsers() {
                      const returnData = [];
                      const users = await GenericFunctions_1.apiRequest.call(this, 'GET', 'users', {}, {});
                      for (const user of users) {
                          returnData.push({
                              name: user.username,
                              value: user._id,
                          });
                      }
                      return returnData;
                  },
                  async getBoards() {
                      const returnData = [];
                      const user = await GenericFunctions_1.apiRequest.call(this, 'GET', 'user', {}, {});
                      const boards = await GenericFunctions_1.apiRequest.call(this, 'GET', `users/${user._id}/boards`, {}, {});
                      for (const board of boards) {
                          returnData.push({
                              name: board.title,
                              value: board._id,
                          });
                      }
                      return returnData;
                  },
                  async getLists() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const lists = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/lists`, {}, {});
                      for (const list of lists) {
                          returnData.push({
                              name: list.title,
                              value: list._id,
                          });
                      }
                      return returnData;
                  },
                  async getSwimlanes() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const swimlanes = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/swimlanes`, {}, {});
                      for (const swimlane of swimlanes) {
                          returnData.push({
                              name: swimlane.title,
                              value: swimlane._id,
                          });
                      }
                      return returnData;
                  },
                  async getCards() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const listId = this.getCurrentNodeParameter('listId');
                      const cards = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/lists/${listId}/cards`, {}, {});
                      for (const card of cards) {
                          returnData.push({
                              name: card.title,
                              value: card._id,
                          });
                      }
                      return returnData;
                  },
                  async getChecklists() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const cardId = this.getCurrentNodeParameter('cardId');
                      const checklists = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/cards/${cardId}/checklists`, {}, {});
                      for (const checklist of checklists) {
                          returnData.push({
                              name: checklist.title,
                              value: checklist._id,
                          });
                      }
                      return returnData;
                  },
                  async getChecklistItems() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const cardId = this.getCurrentNodeParameter('cardId');
                      const checklistId = this.getCurrentNodeParameter('checklistId');
                      const checklist = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/cards/${cardId}/checklists/${checklistId}`, {}, {});
                      for (const item of checklist.items) {
                          returnData.push({
                              name: item.title,
                              value: item._id,
                          });
                      }
                      return returnData;
                  },
                  async getComments() {
                      const returnData = [];
                      const boardId = this.getCurrentNodeParameter('boardId');
                      const cardId = this.getCurrentNodeParameter('cardId');
                      const comments = await GenericFunctions_1.apiRequest.call(this, 'GET', `boards/${boardId}/cards/${cardId}/comments`, {}, {});
                      for (const comment of comments) {
                          returnData.push({
                              name: comment.comment,
                              value: comment._id,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          let returnAll;
          let limit;
          const operation = this.getNodeParameter('operation', 0);
          const resource = this.getNodeParameter('resource', 0);
          let body;
          let qs;
          let requestMethod;
          let endpoint;
          for (let i = 0; i < items.length; i++) {
              try {
                  requestMethod = 'GET';
                  endpoint = '';
                  body = {};
                  qs = {};
                  if (resource === 'board') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          endpoint = 'boards';
                          body.title = this.getNodeParameter('title', i);
                          body.owner = this.getNodeParameter('owner', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(body, additionalFields);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          endpoint = `boards/${boardId}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          endpoint = `boards/${boardId}`;
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const userId = this.getNodeParameter('IdUser', i);
                          returnAll = this.getNodeParameter('returnAll', i);
                          endpoint = `users/${userId}/boards`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'card') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          endpoint = `boards/${boardId}/lists/${listId}/cards`;
                          body.title = this.getNodeParameter('title', i);
                          body.swimlaneId = this.getNodeParameter('swimlaneId', i);
                          body.authorId = this.getNodeParameter('authorId', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          Object.assign(body, additionalFields);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/lists/${listId}/cards/${cardId}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/lists/${listId}/cards/${cardId}`;
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const fromObject = this.getNodeParameter('fromObject', i);
                          returnAll = this.getNodeParameter('returnAll', i);
                          if (fromObject === 'list') {
                              const listId = this.getNodeParameter('listId', i);
                              endpoint = `boards/${boardId}/lists/${listId}/cards`;
                          }
                          if (fromObject === 'swimlane') {
                              const swimlaneId = this.getNodeParameter('swimlaneId', i);
                              endpoint = `boards/${boardId}/swimlanes/${swimlaneId}/cards`;
                          }
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/lists/${listId}/cards/${cardId}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(body, updateFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'cardComment') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/comments`;
                          body.authorId = this.getNodeParameter('authorId', i);
                          body.comment = this.getNodeParameter('comment', i);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const commentId = this.getNodeParameter('commentId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/comments/${commentId}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const commentId = this.getNodeParameter('commentId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/comments/${commentId}`;
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/comments`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'list') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const boardId = this.getNodeParameter('boardId', i);
                          endpoint = `boards/${boardId}/lists`;
                          body.title = this.getNodeParameter('title', i);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          endpoint = `boards/${boardId}/lists/${listId}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const listId = this.getNodeParameter('listId', i);
                          endpoint = `boards/${boardId}/lists/${listId}`;
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          returnAll = this.getNodeParameter('returnAll', i);
                          endpoint = `boards/${boardId}/lists`;
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'checklist') {
                      if (operation === 'create') {
                          requestMethod = 'POST';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists`;
                          body.title = this.getNodeParameter('title', i);
                          body.items = this.getNodeParameter('items', i);
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}`;
                      }
                      else if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}`;
                      }
                      else if (operation === 'getAll') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          returnAll = this.getNodeParameter('returnAll', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists`;
                      }
                      else if (operation === 'getCheckItem') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                      }
                      else if (operation === 'deleteCheckItem') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                      }
                      else if (operation === 'updateCheckItem') {
                          requestMethod = 'PUT';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('itemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(body, updateFields);
                      }
                      else {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not known!`, { itemIndex: i });
                      }
                  }
                  else if (resource === 'checklistItem') {
                      if (operation === 'get') {
                          requestMethod = 'GET';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('checklistItemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                      }
                      else if (operation === 'delete') {
                          requestMethod = 'DELETE';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('checklistItemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                      }
                      else if (operation === 'update') {
                          requestMethod = 'PUT';
                          const boardId = this.getNodeParameter('boardId', i);
                          const cardId = this.getNodeParameter('cardId', i);
                          const checklistId = this.getNodeParameter('checklistId', i);
                          const itemId = this.getNodeParameter('checklistItemId', i);
                          endpoint = `boards/${boardId}/cards/${cardId}/checklists/${checklistId}/items/${itemId}`;
                          const updateFields = this.getNodeParameter('updateFields', i);
                          Object.assign(body, updateFields);
                      }
                  }
                  let responseData = await GenericFunctions_1.apiRequest.call(this, requestMethod, endpoint, body, qs);
                  if (returnAll === false && Array.isArray(responseData)) {
                      limit = this.getNodeParameter('limit', i);
                      responseData = responseData.splice(0, limit);
                  }
                  const executionData = this.helpers.constructExecutionMetaData((0, utilities_1.wrapData)(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
                      continue;
                  }
                  throw error;
              }
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Wekan = Wekan;
  //# sourceMappingURL=Wekan.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Wekan node documentation
  description: Learn how to use the Wekan node in n8n. Follow technical documentation to integrate Wekan node into your workflows.
  contentType: [integration, reference]
  ---

  # Wekan node

  Use the Wekan node to automate work in Wekan, and integrate Wekan with other applications. n8n has built-in support for a wide range of Wekan features, including creating, updating, deleting, and getting boards and cards. 

  On this page, you'll find a list of operations the Wekan node supports and links to more resources.

  /// note | Credentials
  Refer to [Wekan credentials](/integrations/builtin/credentials/wekan.md) for guidance on setting up authentication. 
  ///

  ## Operations

  * Board
      * Create a new board
      * Delete a board
      * Get the data of a board
      * Get all user boards
  * Card
      * Create a new card
      * Delete a card
      * Get a card
      * Get all cards
      * Update a card
  * Card Comment
      * Create a comment on a card
      * Delete a comment from a card
      * Get a card comment
      * Get all card comments
  * Checklist
      * Create a new checklist
      * Delete a checklist
      * Get the data of a checklist
      * Returns all checklists for the card
  * Checklist Item
      * Delete a checklist item
      * Get a checklist item
      * Update a checklist item
  * List
      * Create a new list
      * Delete a list
      * Get the data of a list
      * Get all board lists

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'wekan') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

  ## Load all the parameters for the node

  To load all the parameters, for example, Author ID, you need to give admin permissions to the user. Refer to the [Wekan documentation](https://github.com/wekan/wekan/wiki/Features#members-click-member-initials-or-avatar--permissions-adminnormalcomment-only){:target=_blank .external-link} to learn how to change permissions.

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"3c89a0ee-f6bf-43ea-83f2-a9c823fc123b","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"47d0ff678424eda15ee30abce6d9a0addeae946a97c8bcbfec28a973003ec5af"}}


node_type: n8n-nodes-base.WriteBinaryFile
name: WriteBinaryFile
display_name: Write Binary File
description: Writes a binary file to disk
category: output
icon: fa:file-export
code_hash: 20162b6ab682660dc6c2229e1af0ac916ec38d2570006eaf9b0b6df2be10f946
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.WriteBinaryFile = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  class WriteBinaryFile {
      constructor() {
          this.description = {
              displayName: 'Write Binary File',
              name: 'writeBinaryFile',
              icon: 'fa:file-export',
              group: ['output'],
              version: 1,
              description: 'Writes a binary file to disk',
              defaults: {
                  name: 'Write Binary File',
                  color: '#CC2233',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'File Name',
                      name: 'fileName',
                      type: 'string',
                      default: '',
                      required: true,
                      placeholder: '/data/example.jpg',
                      description: 'Path to which the file should be written',
                  },
                  {
                      displayName: 'Property Name',
                      name: 'dataPropertyName',
                      type: 'string',
                      default: 'data',
                      required: true,
                      description: 'Name of the binary property which contains the data for the file to be written',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Append',
                              name: 'append',
                              type: 'boolean',
                              default: false,
                              description: 'Whether to append to an existing file',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let item;
          for (let itemIndex = 0; itemIndex < length; itemIndex++) {
              try {
                  const dataPropertyName = this.getNodeParameter('dataPropertyName', itemIndex);
                  const fileName = this.getNodeParameter('fileName', itemIndex);
                  const options = this.getNodeParameter('options', 0, {});
                  const flag = options.append ? 'a' : 'w';
                  item = items[itemIndex];
                  const newItem = {
                      json: {},
                      pairedItem: {
                          item: itemIndex,
                      },
                  };
                  Object.assign(newItem.json, item.json);
                  const binaryData = this.helpers.assertBinaryData(itemIndex, dataPropertyName);
                  let fileContent;
                  if (binaryData.id) {
                      fileContent = await this.helpers.getBinaryStream(binaryData.id);
                  }
                  else {
                      fileContent = Buffer.from(binaryData.data, n8n_workflow_1.BINARY_ENCODING);
                  }
                  await this.helpers.writeContentToFile(fileName, fileContent, flag);
                  if (item.binary !== undefined) {
                      newItem.binary = {};
                      Object.assign(newItem.binary, item.binary);
                  }
                  newItem.json.fileName = fileName;
                  returnData.push(newItem);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({
                          json: {
                              error: error.message,
                          },
                          pairedItem: {
                              item: itemIndex,
                          },
                      });
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.WriteBinaryFile = WriteBinaryFile;
  //# sourceMappingURL=WriteBinaryFile.node.js.map

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"92db50f1-0385-40cf-ae92-981dd5441b98","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"1321f00ae811d17294f76cc5de86e2ff7b8c083bde6a71580e1887231794719a"}}


node_type: n8n-nodes-base.WhatsApp
name: WhatsApp
display_name: WhatsApp Business Cloud
description: Access WhatsApp API
category: output
icon: file:whatsapp.svg
code_hash: f36be4f477cb2d0526f7bfdf3caeae4ed3518eb4a3b170d72e96b88e2dc44367
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.WhatsApp = void 0;
  const MessagesDescription_1 = require("./MessagesDescription");
  const MediaDescription_1 = require("./MediaDescription");
  class WhatsApp {
      constructor() {
          this.description = {
              displayName: 'WhatsApp Business Cloud',
              name: 'whatsApp',
              icon: 'file:whatsapp.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{ $parameter["resource"] + ": " + $parameter["operation"] }}',
              description: 'Access WhatsApp API',
              defaults: {
                  name: 'WhatsApp Business Cloud',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'whatsAppApi',
                      required: true,
                  },
              ],
              requestDefaults: {
                  baseURL: 'https://graph.facebook.com/v13.0/',
              },
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Message',
                              value: 'message',
                          },
                          {
                              name: 'Media',
                              value: 'media',
                          },
                      ],
                      default: 'message',
                  },
                  ...MessagesDescription_1.messageFields,
                  ...MediaDescription_1.mediaFields,
                  ...MessagesDescription_1.messageTypeFields,
                  ...MediaDescription_1.mediaTypeFields,
              ],
          };
      }
  }
  exports.WhatsApp = WhatsApp;
  //# sourceMappingURL=WhatsApp.node.js.map

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"7bae7d2f-ad8f-406c-8461-4a46b592bea3","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"7426893bae6c4b958dffe9873513820d17ed6ddf8041e277a1c505c623bd0570"}}


node_type: n8n-nodes-base.Wise
name: Wise
display_name: Wise
description: Consume the Wise API
category: transform
icon: file:wise.svg
code_hash: 07a5d221159d4a3ca44885812009b5ebf053effe21c97ccc94fde861dd9a5607
documentation_url: https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.wisetrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  var __importDefault = (this && this.__importDefault) || function (mod) {
      return (mod && mod.__esModule) ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Wise = void 0;
  const descriptions_1 = require("./descriptions");
  const GenericFunctions_1 = require("./GenericFunctions");
  const omit_1 = __importDefault(require("lodash/omit"));
  const moment_timezone_1 = __importDefault(require("moment-timezone"));
  const uuid_1 = require("uuid");
  class Wise {
      constructor() {
          this.description = {
              displayName: 'Wise',
              name: 'wise',
              icon: 'file:wise.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the Wise API',
              defaults: {
                  name: 'Wise',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'wiseApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Account',
                              value: 'account',
                          },
                          {
                              name: 'Exchange Rate',
                              value: 'exchangeRate',
                          },
                          {
                              name: 'Profile',
                              value: 'profile',
                          },
                          {
                              name: 'Quote',
                              value: 'quote',
                          },
                          {
                              name: 'Recipient',
                              value: 'recipient',
                          },
                          {
                              name: 'Transfer',
                              value: 'transfer',
                          },
                      ],
                      default: 'account',
                  },
                  ...descriptions_1.accountOperations,
                  ...descriptions_1.accountFields,
                  ...descriptions_1.exchangeRateOperations,
                  ...descriptions_1.exchangeRateFields,
                  ...descriptions_1.profileOperations,
                  ...descriptions_1.profileFields,
                  ...descriptions_1.quoteOperations,
                  ...descriptions_1.quoteFields,
                  ...descriptions_1.recipientOperations,
                  ...descriptions_1.recipientFields,
                  ...descriptions_1.transferOperations,
                  ...descriptions_1.transferFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getBorderlessAccounts() {
                      const qs = {
                          profileId: this.getNodeParameter('profileId', 0),
                      };
                      const accounts = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/borderless-accounts', {}, qs);
                      return accounts.map(({ id, balances }) => ({
                          name: balances.map(({ currency }) => currency).join(' - '),
                          value: id,
                      }));
                  },
                  async getProfiles() {
                      const profiles = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/profiles');
                      return profiles.map(({ id, type }) => ({
                          name: type.charAt(0).toUpperCase() + type.slice(1),
                          value: id,
                      }));
                  },
                  async getRecipients() {
                      const qs = {
                          profileId: this.getNodeParameter('profileId', 0),
                      };
                      const recipients = (await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/accounts', {}, qs));
                      return recipients.reduce((activeRecipients, { active, id, accountHolderName, currency, country, type }) => {
                          if (active) {
                              const recipient = {
                                  name: `[${currency}] ${accountHolderName} - (${country !== null ? country + ' - ' : ''}${type})`,
                                  value: id,
                              };
                              activeRecipients.push(recipient);
                          }
                          return activeRecipients;
                      }, []);
                  },
              },
          };
      }
      async execute() {
          var _a, _b;
          const items = this.getInputData();
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          const timezone = this.getTimezone();
          let responseData;
          const returnData = [];
          let binaryOutput = false;
          for (let i = 0; i < items.length; i++) {
              try {
                  if (resource === 'account') {
                      if (operation === 'getBalances') {
                          const qs = {
                              profileId: this.getNodeParameter('profileId', i),
                          };
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/borderless-accounts', {}, qs);
                      }
                      else if (operation === 'getCurrencies') {
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/borderless-accounts/balance-currencies');
                      }
                      else if (operation === 'getStatement') {
                          const profileId = this.getNodeParameter('profileId', i);
                          const borderlessAccountId = this.getNodeParameter('borderlessAccountId', i);
                          const format = this.getNodeParameter('format', i);
                          const endpoint = `v3/profiles/${profileId}/borderless-accounts/${borderlessAccountId}/statement.${format}`;
                          const qs = {
                              currency: this.getNodeParameter('currency', i),
                          };
                          const { lineStyle, range } = this.getNodeParameter('additionalFields', i);
                          if (lineStyle !== undefined) {
                              qs.type = lineStyle;
                          }
                          if (range !== undefined) {
                              qs.intervalStart = moment_timezone_1.default
                                  .tz(range.rangeProperties.intervalStart, timezone)
                                  .utc()
                                  .format();
                              qs.intervalEnd = moment_timezone_1.default
                                  .tz(range.rangeProperties.intervalEnd, timezone)
                                  .utc()
                                  .format();
                          }
                          else {
                              qs.intervalStart = (0, moment_timezone_1.default)().subtract(1, 'months').utc().format();
                              qs.intervalEnd = (0, moment_timezone_1.default)().utc().format();
                          }
                          if (format === 'json') {
                              responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', endpoint, {}, qs);
                          }
                          else {
                              const data = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', endpoint, {}, qs, {
                                  encoding: 'arraybuffer',
                              });
                              const binaryProperty = this.getNodeParameter('binaryProperty', i);
                              items[i].binary = (_a = items[i].binary) !== null && _a !== void 0 ? _a : {};
                              items[i].binary[binaryProperty] = await this.helpers.prepareBinaryData(data, this.getNodeParameter('fileName', i));
                              responseData = items;
                              binaryOutput = true;
                          }
                      }
                  }
                  else if (resource === 'exchangeRate') {
                      if (operation === 'get') {
                          const qs = {
                              source: this.getNodeParameter('source', i),
                              target: this.getNodeParameter('target', i),
                          };
                          const { interval, range, time } = this.getNodeParameter('additionalFields', i);
                          if (interval !== undefined) {
                              qs.group = interval;
                          }
                          if (time !== undefined) {
                              qs.time = time;
                          }
                          if (range !== undefined && time === undefined) {
                              qs.from = moment_timezone_1.default.tz(range.rangeProperties.from, timezone).utc().format();
                              qs.to = moment_timezone_1.default.tz(range.rangeProperties.to, timezone).utc().format();
                          }
                          else if (time === undefined) {
                              qs.from = (0, moment_timezone_1.default)().subtract(1, 'months').utc().format();
                              qs.to = (0, moment_timezone_1.default)().format();
                          }
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/rates', {}, qs);
                      }
                  }
                  else if (resource === 'profile') {
                      if (operation === 'get') {
                          const profileId = this.getNodeParameter('profileId', i);
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', `v1/profiles/${profileId}`);
                      }
                      else if (operation === 'getAll') {
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/profiles');
                      }
                  }
                  else if (resource === 'recipient') {
                      if (operation === 'getAll') {
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/accounts');
                          const returnAll = this.getNodeParameter('returnAll', i);
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', i);
                              responseData = responseData.slice(0, limit);
                          }
                      }
                  }
                  else if (resource === 'quote') {
                      if (operation === 'create') {
                          const body = {
                              profile: this.getNodeParameter('profileId', i),
                              sourceCurrency: this.getNodeParameter('sourceCurrency', i).toUpperCase(),
                              targetCurrency: this.getNodeParameter('targetCurrency', i).toUpperCase(),
                          };
                          const amountType = this.getNodeParameter('amountType', i);
                          if (amountType === 'source') {
                              body.sourceAmount = this.getNodeParameter('amount', i);
                          }
                          else if (amountType === 'target') {
                              body.targetAmount = this.getNodeParameter('amount', i);
                          }
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'POST', 'v2/quotes', body, {});
                      }
                      else if (operation === 'get') {
                          const quoteId = this.getNodeParameter('quoteId', i);
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', `v2/quotes/${quoteId}`);
                      }
                  }
                  else if (resource === 'transfer') {
                      if (operation === 'create') {
                          const body = {
                              quoteUuid: this.getNodeParameter('quoteId', i),
                              targetAccount: this.getNodeParameter('targetAccountId', i),
                              customerTransactionId: (0, uuid_1.v4)(),
                          };
                          const { reference } = this.getNodeParameter('additionalFields', i);
                          if (reference !== undefined) {
                              body.details = { reference };
                          }
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'POST', 'v1/transfers', body, {});
                      }
                      else if (operation === 'delete') {
                          const transferId = this.getNodeParameter('transferId', i);
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'PUT', `v1/transfers/${transferId}/cancel`);
                      }
                      else if (operation === 'execute') {
                          const profileId = this.getNodeParameter('profileId', i);
                          const transferId = this.getNodeParameter('transferId', i);
                          const endpoint = `v3/profiles/${profileId}/transfers/${transferId}/payments`;
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'POST', endpoint, { type: 'BALANCE' }, {});
                          const { environment } = await this.getCredentials('wiseApi');
                          if (environment === 'test') {
                              for (const testEndpoint of [
                                  'processing',
                                  'funds_converted',
                                  'outgoing_payment_sent',
                              ]) {
                                  await GenericFunctions_1.wiseApiRequest.call(this, 'GET', `v1/simulation/transfers/${transferId}/${testEndpoint}`);
                              }
                          }
                      }
                      else if (operation === 'get') {
                          const transferId = this.getNodeParameter('transferId', i);
                          const downloadReceipt = this.getNodeParameter('downloadReceipt', i);
                          if (downloadReceipt) {
                              const data = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', `v1/transfers/${transferId}/receipt.pdf`, {}, {}, { encoding: 'arraybuffer' });
                              const binaryProperty = this.getNodeParameter('binaryProperty', i);
                              items[i].binary = (_b = items[i].binary) !== null && _b !== void 0 ? _b : {};
                              items[i].binary[binaryProperty] = await this.helpers.prepareBinaryData(data, this.getNodeParameter('fileName', i));
                              responseData = items;
                              binaryOutput = true;
                          }
                          else {
                              responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', `v1/transfers/${transferId}`);
                          }
                      }
                      else if (operation === 'getAll') {
                          const qs = {
                              profile: this.getNodeParameter('profileId', i),
                          };
                          const filters = this.getNodeParameter('filters', i);
                          Object.keys((0, omit_1.default)(filters, 'range')).forEach((key) => {
                              qs[key] = filters[key];
                          });
                          if (filters.range !== undefined) {
                              qs.createdDateStart = (0, moment_timezone_1.default)(filters.range.rangeProperties.createdDateStart).format();
                              qs.createdDateEnd = (0, moment_timezone_1.default)(filters.range.rangeProperties.createdDateEnd).format();
                          }
                          else {
                              qs.createdDateStart = (0, moment_timezone_1.default)().subtract(1, 'months').format();
                              qs.createdDateEnd = (0, moment_timezone_1.default)().format();
                          }
                          const returnAll = this.getNodeParameter('returnAll', i);
                          if (!returnAll) {
                              qs.limit = this.getNodeParameter('limit', i);
                          }
                          responseData = await GenericFunctions_1.wiseApiRequest.call(this, 'GET', 'v1/transfers', {}, qs);
                      }
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ error: error.toString() });
                      continue;
                  }
                  throw error;
              }
              Array.isArray(responseData)
                  ? returnData.push(...responseData)
                  : returnData.push(responseData);
          }
          if (binaryOutput && responseData !== undefined) {
              return [responseData];
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Wise = Wise;
  //# sourceMappingURL=Wise.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: Wise Trigger node documentation
  description: Learn how to use the Wise Trigger node in n8n. Follow technical documentation to integrate Wise Trigger node into your workflows.
  contentType: [integration, reference]
  ---

  # Wise Trigger node

  [Wise](https://wise.com) allows you to transfer money abroad with low-cost money transfers, receive money with international account details, and track transactions on your phone.

  /// note | Credentials
  You can find authentication information for this node [here](/integrations/builtin/credentials/wise.md).
  ///

  /// note | Examples and templates
  For usage examples and templates to help you get started, refer to n8n's [Wise Trigger integrations](https://n8n.io/integrations/wise-trigger/){:target=_blank .external-link} page.
  ///

  ## Events

  - Triggered every time a balance account is credited
  - Triggered every time a balance account is credited or debited
  - Triggered every time a transfer's list of active cases is updated
  - Triggered every time a transfer's status is updated 

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"d8642029-4b59-4526-9ffa-2a06390babdf","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"c0fd9cb791e05a6ff6c3b3023fa70aaee4825fd3cf20cf50db20330d1970c10e"}}


node_type: n8n-nodes-base.WooCommerce
name: WooCommerce
display_name: WooCommerce
description: Consume WooCommerce API
category: output
icon: file:wooCommerce.svg
code_hash: 32e6ebee88d5a70ca7263620ddae947e08465e8c9a0eede9550f542ea9ab9e60
documentation_url: https://docs.n8n.io/integrations/builtin/trigger-nodes/n8n-nodes-base.woocommercetrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.WooCommerce = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const ProductDescription_1 = require("./ProductDescription");
  const OrderDescription_1 = require("./OrderDescription");
  const descriptions_1 = require("./descriptions");
  class WooCommerce {
      constructor() {
          this.description = {
              displayName: 'WooCommerce',
              name: 'wooCommerce',
              icon: 'file:wooCommerce.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume WooCommerce API',
              defaults: {
                  name: 'WooCommerce',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'wooCommerceApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Customer',
                              value: 'customer',
                          },
                          {
                              name: 'Order',
                              value: 'order',
                          },
                          {
                              name: 'Product',
                              value: 'product',
                          },
                      ],
                      default: 'product',
                  },
                  ...descriptions_1.customerOperations,
                  ...descriptions_1.customerFields,
                  ...ProductDescription_1.productOperations,
                  ...ProductDescription_1.productFields,
                  ...OrderDescription_1.orderOperations,
                  ...OrderDescription_1.orderFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getCategories() {
                      const returnData = [];
                      const categories = await GenericFunctions_1.woocommerceApiRequestAllItems.call(this, 'GET', '/products/categories', {});
                      for (const category of categories) {
                          const categoryName = category.name;
                          const categoryId = category.id;
                          returnData.push({
                              name: categoryName,
                              value: categoryId,
                          });
                      }
                      return returnData;
                  },
                  async getTags() {
                      const returnData = [];
                      const tags = await GenericFunctions_1.woocommerceApiRequestAllItems.call(this, 'GET', '/products/tags', {});
                      for (const tag of tags) {
                          const tagName = tag.name;
                          const tagId = tag.id;
                          returnData.push({
                              name: tagName,
                              value: tagId,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const qs = {};
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              if (resource === 'customer') {
                  if (operation === 'create') {
                      const body = {
                          email: this.getNodeParameter('email', i),
                      };
                      const additionalFields = this.getNodeParameter('additionalFields', i);
                      if (Object.keys(additionalFields).length) {
                          Object.assign(body, (0, GenericFunctions_1.adjustMetadata)(additionalFields));
                      }
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'POST', '/customers', body);
                  }
                  else if (operation === 'delete') {
                      const customerId = this.getNodeParameter('customerId', i);
                      qs.force = true;
                      const endpoint = `/customers/${customerId}`;
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'DELETE', endpoint, {}, qs);
                  }
                  else if (operation === 'get') {
                      const customerId = this.getNodeParameter('customerId', i);
                      const endpoint = `/customers/${customerId}`;
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', endpoint);
                  }
                  else if (operation === 'getAll') {
                      const filters = this.getNodeParameter('filters', i);
                      const returnAll = this.getNodeParameter('returnAll', i);
                      if (Object.keys(filters).length) {
                          Object.assign(qs, filters);
                      }
                      if (returnAll) {
                          responseData = await GenericFunctions_1.woocommerceApiRequestAllItems.call(this, 'GET', '/customers', {}, {});
                      }
                      else {
                          qs.per_page = this.getNodeParameter('limit', i);
                          responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', '/customers', {}, qs);
                      }
                  }
                  else if (operation === 'update') {
                      const body = {};
                      const updateFields = this.getNodeParameter('updateFields', i);
                      if (Object.keys(updateFields).length) {
                          Object.assign(body, (0, GenericFunctions_1.adjustMetadata)(updateFields));
                      }
                      const customerId = this.getNodeParameter('customerId', i);
                      const endpoint = `/customers/${customerId}`;
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'PUT', endpoint, body);
                  }
              }
              else if (resource === 'product') {
                  if (operation === 'create') {
                      const name = this.getNodeParameter('name', i);
                      const additionalFields = this.getNodeParameter('additionalFields', i);
                      const body = {
                          name,
                      };
                      (0, GenericFunctions_1.setFields)(additionalFields, body);
                      if (additionalFields.categories) {
                          body.categories = additionalFields.categories.map((category) => ({
                              id: parseInt(category, 10),
                          }));
                      }
                      const images = this.getNodeParameter('imagesUi', i)
                          .imagesValues;
                      if (images) {
                          body.images = images;
                      }
                      const dimension = this.getNodeParameter('dimensionsUi', i)
                          .dimensionsValues;
                      if (dimension) {
                          body.dimensions = dimension;
                      }
                      const metadata = this.getNodeParameter('metadataUi', i)
                          .metadataValues;
                      if (metadata) {
                          body.meta_data = metadata;
                      }
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'POST', '/products', body);
                  }
                  if (operation === 'update') {
                      const productId = this.getNodeParameter('productId', i);
                      const updateFields = this.getNodeParameter('updateFields', i);
                      const body = {};
                      (0, GenericFunctions_1.setFields)(updateFields, body);
                      const images = this.getNodeParameter('imagesUi', i)
                          .imagesValues;
                      if (images) {
                          body.images = images;
                      }
                      const dimension = this.getNodeParameter('dimensionsUi', i)
                          .dimensionsValues;
                      if (dimension) {
                          body.dimensions = dimension;
                      }
                      const metadata = this.getNodeParameter('metadataUi', i)
                          .metadataValues;
                      if (metadata) {
                          body.meta_data = metadata;
                      }
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'PUT', `/products/${productId}`, body);
                  }
                  if (operation === 'get') {
                      const productId = this.getNodeParameter('productId', i);
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', `/products/${productId}`, {}, qs);
                  }
                  if (operation === 'getAll') {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const options = this.getNodeParameter('options', i);
                      if (options.after) {
                          qs.after = options.after;
                      }
                      if (options.before) {
                          qs.before = options.before;
                      }
                      if (options.category) {
                          qs.category = options.category;
                      }
                      if (options.context) {
                          qs.context = options.context;
                      }
                      if (options.featured) {
                          qs.featured = options.featured;
                      }
                      if (options.maxPrice) {
                          qs.max_price = options.maxPrice;
                      }
                      if (options.minPrice) {
                          qs.max_price = options.minPrice;
                      }
                      if (options.order) {
                          qs.order = options.order;
                      }
                      if (options.orderBy) {
                          qs.orderby = options.orderBy;
                      }
                      if (options.search) {
                          qs.search = options.search;
                      }
                      if (options.sku) {
                          qs.sku = options.sku;
                      }
                      if (options.slug) {
                          qs.slug = options.slug;
                      }
                      if (options.status) {
                          qs.status = options.status;
                      }
                      if (options.stockStatus) {
                          qs.stock_status = options.stockStatus;
                      }
                      if (options.tag) {
                          qs.tag = options.tag;
                      }
                      if (options.taxClass) {
                          qs.tax_class = options.taxClass;
                      }
                      if (options.type) {
                          qs.type = options.type;
                      }
                      if (returnAll) {
                          responseData = await GenericFunctions_1.woocommerceApiRequestAllItems.call(this, 'GET', '/products', {}, qs);
                      }
                      else {
                          qs.per_page = this.getNodeParameter('limit', i);
                          responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', '/products', {}, qs);
                      }
                  }
                  if (operation === 'delete') {
                      const productId = this.getNodeParameter('productId', i);
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'DELETE', `/products/${productId}`, {}, { force: true });
                  }
              }
              if (resource === 'order') {
                  if (operation === 'create') {
                      const additionalFields = this.getNodeParameter('additionalFields', i);
                      const body = {};
                      (0, GenericFunctions_1.setFields)(additionalFields, body);
                      const billing = this.getNodeParameter('billingUi', i)
                          .billingValues;
                      if (billing !== undefined) {
                          body.billing = billing;
                          (0, GenericFunctions_1.toSnakeCase)(billing);
                      }
                      const shipping = this.getNodeParameter('shippingUi', i)
                          .shippingValues;
                      if (shipping !== undefined) {
                          body.shipping = shipping;
                          (0, GenericFunctions_1.toSnakeCase)(shipping);
                      }
                      const couponLines = this.getNodeParameter('couponLinesUi', i)
                          .couponLinesValues;
                      if (couponLines) {
                          body.coupon_lines = couponLines;
                          (0, GenericFunctions_1.setMetadata)(couponLines);
                          (0, GenericFunctions_1.toSnakeCase)(couponLines);
                      }
                      const feeLines = this.getNodeParameter('feeLinesUi', i)
                          .feeLinesValues;
                      if (feeLines) {
                          body.fee_lines = feeLines;
                          (0, GenericFunctions_1.setMetadata)(feeLines);
                          (0, GenericFunctions_1.toSnakeCase)(feeLines);
                      }
                      const lineItems = this.getNodeParameter('lineItemsUi', i)
                          .lineItemsValues;
                      if (lineItems) {
                          body.line_items = lineItems;
                          (0, GenericFunctions_1.setMetadata)(lineItems);
                          (0, GenericFunctions_1.toSnakeCase)(lineItems);
                      }
                      const metadata = this.getNodeParameter('metadataUi', i)
                          .metadataValues;
                      if (metadata) {
                          body.meta_data = metadata;
                      }
                      const shippingLines = this.getNodeParameter('shippingLinesUi', i)
                          .shippingLinesValues;
                      if (shippingLines) {
                          body.shipping_lines = shippingLines;
                          (0, GenericFunctions_1.setMetadata)(shippingLines);
                          (0, GenericFunctions_1.toSnakeCase)(shippingLines);
                      }
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'POST', '/orders', body);
                  }
                  if (operation === 'update') {
                      const orderId = this.getNodeParameter('orderId', i);
                      const updateFields = this.getNodeParameter('updateFields', i);
                      const body = {};
                      if (updateFields.currency) {
                          body.currency = updateFields.currency;
                      }
                      if (updateFields.customerId) {
                          body.customer_id = parseInt(updateFields.customerId, 10);
                      }
                      if (updateFields.customerNote) {
                          body.customer_note = updateFields.customerNote;
                      }
                      if (updateFields.parentId) {
                          body.parent_id = parseInt(updateFields.parentId, 10);
                      }
                      if (updateFields.paymentMethodId) {
                          body.payment_method = updateFields.paymentMethodId;
                      }
                      if (updateFields.paymentMethodTitle) {
                          body.payment_method_title = updateFields.paymentMethodTitle;
                      }
                      if (updateFields.status) {
                          body.status = updateFields.status;
                      }
                      if (updateFields.transactionID) {
                          body.transaction_id = updateFields.transactionID;
                      }
                      const billing = this.getNodeParameter('billingUi', i)
                          .billingValues;
                      if (billing !== undefined) {
                          body.billing = billing;
                          (0, GenericFunctions_1.toSnakeCase)(billing);
                      }
                      const shipping = this.getNodeParameter('shippingUi', i)
                          .shippingValues;
                      if (shipping !== undefined) {
                          body.shipping = shipping;
                          (0, GenericFunctions_1.toSnakeCase)(shipping);
                      }
                      const couponLines = this.getNodeParameter('couponLinesUi', i)
                          .couponLinesValues;
                      if (couponLines) {
                          body.coupon_lines = couponLines;
                          (0, GenericFunctions_1.setMetadata)(couponLines);
                          (0, GenericFunctions_1.toSnakeCase)(couponLines);
                      }
                      const feeLines = this.getNodeParameter('feeLinesUi', i)
                          .feeLinesValues;
                      if (feeLines) {
                          body.fee_lines = feeLines;
                          (0, GenericFunctions_1.setMetadata)(feeLines);
                          (0, GenericFunctions_1.toSnakeCase)(feeLines);
                      }
                      const lineItems = this.getNodeParameter('lineItemsUi', i)
                          .lineItemsValues;
                      if (lineItems) {
                          body.line_items = lineItems;
                          (0, GenericFunctions_1.setMetadata)(lineItems);
                          (0, GenericFunctions_1.toSnakeCase)(lineItems);
                      }
                      const metadata = this.getNodeParameter('metadataUi', i)
                          .metadataValues;
                      if (metadata) {
                          body.meta_data = metadata;
                      }
                      const shippingLines = this.getNodeParameter('shippingLinesUi', i)
                          .shippingLinesValues;
                      if (shippingLines) {
                          body.shipping_lines = shippingLines;
                          (0, GenericFunctions_1.setMetadata)(shippingLines);
                          (0, GenericFunctions_1.toSnakeCase)(shippingLines);
                      }
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'PUT', `/orders/${orderId}`, body);
                  }
                  if (operation === 'get') {
                      const orderId = this.getNodeParameter('orderId', i);
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', `/orders/${orderId}`, {}, qs);
                  }
                  if (operation === 'getAll') {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const options = this.getNodeParameter('options', i);
                      if (options.after) {
                          qs.after = options.after;
                      }
                      if (options.before) {
                          qs.before = options.before;
                      }
                      if (options.category) {
                          qs.category = options.category;
                      }
                      if (options.customer) {
                          qs.customer = parseInt(options.customer, 10);
                      }
                      if (options.decimalPoints) {
                          qs.dp = options.decimalPoints;
                      }
                      if (options.product) {
                          qs.product = parseInt(options.product, 10);
                      }
                      if (options.order) {
                          qs.order = options.order;
                      }
                      if (options.orderBy) {
                          qs.orderby = options.orderBy;
                      }
                      if (options.search) {
                          qs.search = options.search;
                      }
                      if (options.status) {
                          qs.status = options.status;
                      }
                      if (returnAll) {
                          responseData = await GenericFunctions_1.woocommerceApiRequestAllItems.call(this, 'GET', '/orders', {}, qs);
                      }
                      else {
                          qs.per_page = this.getNodeParameter('limit', i);
                          responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'GET', '/orders', {}, qs);
                      }
                  }
                  if (operation === 'delete') {
                      const orderId = this.getNodeParameter('orderId', i);
                      responseData = await GenericFunctions_1.woocommerceApiRequest.call(this, 'DELETE', `/orders/${orderId}`, {}, { force: true });
                  }
              }
              const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
              returnData.push(...executionData);
          }
          return [returnData];
      }
  }
  exports.WooCommerce = WooCommerce;
  //# sourceMappingURL=WooCommerce.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: WooCommerce Trigger node documentation
  description: Learn how to use the WooCommerce Trigger node in n8n. Follow technical documentation to integrate WooCommerce Trigger node into your workflows.
  contentType: [integration, reference]
  priority: medium
  ---

  # WooCommerce Trigger node

  [WooCommerce](https://woocommerce.com/){:target=_blank .external-link} is a customizable, open-source e-commerce plugin for WordPress.

  /// note | Credentials
  You can find authentication information for this node [here](/integrations/builtin/credentials/woocommerce.md).
  ///

  ///  note  | Examples and templates
  For usage examples and templates to help you get started, refer to n8n's [WooCommerce Trigger integrations](https://n8n.io/integrations/woocommerce-trigger/){:target=_blank .external-link} page.
  ///

  ## Events

  - coupon.created
  - coupon.updated
  - coupon.deleted
  - customer.created
  - customer.updated
  - customer.deleted
  - order.created
  - order.updated
  - order.deleted
  - product.created
  - product.updated
  - product.deleted

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"76c1f80e-ea78-47d5-8489-0a7f6f6edde2","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"1963899e54cede6b5d4ba3ed61b012b3d96d59116fa56827b3c0dc480916bae3"}}


node_type: n8n-nodes-base.WorkflowTrigger
name: WorkflowTrigger
display_name: Workflow Trigger
description: Triggers based on various lifecycle events, like when a workflow is activated
category: trigger
icon: fa:network-wired
code_hash: 254166977ea09fe9d47202b97e9ab3e90bae00f8a02f4072c9d221a554e687ce
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.executeworkflowtrigger
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.WorkflowTrigger = void 0;
  class WorkflowTrigger {
      constructor() {
          this.description = {
              displayName: 'Workflow Trigger',
              name: 'workflowTrigger',
              icon: 'fa:network-wired',
              group: ['trigger'],
              version: 1,
              description: 'Triggers based on various lifecycle events, like when a workflow is activated',
              eventTriggerDescription: '',
              mockManualExecution: true,
              activationMessage: 'Your workflow will now trigger executions on the event you have defined.',
              defaults: {
                  name: 'Workflow Trigger',
                  color: '#ff6d5a',
              },
              inputs: [],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'Events',
                      name: 'events',
                      type: 'multiOptions',
                      required: true,
                      default: [],
                      description: `Specifies under which conditions an execution should happen:
  					<ul>
  						<li><b>Active Workflow Updated</b>: Triggers when this workflow is updated</li>
  						<li><b>Workflow Activated</b>: Triggers when this workflow is activated</li>
  					</ul>`,
                      options: [
                          {
                              name: 'Active Workflow Updated',
                              value: 'update',
                              description: 'Triggers when this workflow is updated',
                          },
                          {
                              name: 'Workflow Activated',
                              value: 'activate',
                              description: 'Triggers when this workflow is activated',
                          },
                      ],
                  },
              ],
          };
      }
      async trigger() {
          const events = this.getNodeParameter('events', []);
          const activationMode = this.getActivationMode();
          if (events.includes(activationMode)) {
              let event;
              if (activationMode === 'activate') {
                  event = 'Workflow activated';
              }
              if (activationMode === 'update') {
                  event = 'Workflow updated';
              }
              this.emit([
                  this.helpers.returnJsonArray([
                      { event, timestamp: new Date().toISOString(), workflow_id: this.getWorkflow().id },
                  ]),
              ]);
          }
          const manualTriggerFunction = async () => {
              this.emit([
                  this.helpers.returnJsonArray([
                      {
                          event: 'Manual execution',
                          timestamp: new Date().toISOString(),
                          workflow_id: this.getWorkflow().id,
                      },
                  ]),
              ]);
          };
          return {
              manualTriggerFunction,
          };
      }
  }
  exports.WorkflowTrigger = WorkflowTrigger;
  //# sourceMappingURL=WorkflowTrigger.node.js.map

documentation_markdown:
[cell repeats an earlier one in this file: 1466 characters]

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"78966256-fb4f-49e7-8557-1efa961655ab","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"43c302872631f19170b1c9b5ed90b3e9a7130c636608ff81fc0fc17ed1aef56b"}}


node_type: n8n-nodes-base.Wordpress
name: Wordpress
display_name: Wordpress
description: Consume Wordpress API
category: output
icon: file:wordpress.svg
code_hash: 1aa9205e0c6d3a7ea7839b9436e584331e3ac4a84917f24f07219a83e8fbd60f
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.wordpress
example_parameters: {}
properties_schema: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-08 09:18:40
updated_at: 2025-06-08 09:18:40
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Wordpress = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const PostDescription_1 = require("./PostDescription");
  const UserDescription_1 = require("./UserDescription");
  class Wordpress {
      constructor() {
          this.description = {
              displayName: 'Wordpress',
              name: 'wordpress',
              icon: 'file:wordpress.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Wordpress API',
              defaults: {
                  name: 'Wordpress',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'wordpressApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Post',
                              value: 'post',
                          },
                          {
                              name: 'User',
                              value: 'user',
                          },
                      ],
                      default: 'post',
                  },
                  ...PostDescription_1.postOperations,
                  ...PostDescription_1.postFields,
                  ...UserDescription_1.userOperations,
                  ...UserDescription_1.userFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getCategories() {
                      const returnData = [];
                      const categories = await GenericFunctions_1.wordpressApiRequestAllItems.call(this, 'GET', '/categories', {});
                      for (const category of categories) {
                          const categoryName = category.name;
                          const categoryId = category.id;
                          returnData.push({
                              name: categoryName,
                              value: categoryId,
                          });
                      }
                      return returnData;
                  },
                  async getTags() {
                      const returnData = [];
                      const tags = await GenericFunctions_1.wordpressApiRequestAllItems.call(this, 'GET', '/tags', {});
                      for (const tag of tags) {
                          const tagName = tag.name;
                          const tagId = tag.id;
                          returnData.push({
                              name: tagName,
                              value: tagId,
                          });
                      }
                      return returnData;
                  },
                  async getAuthors() {
                      const returnData = [];
                      const authors = await GenericFunctions_1.wordpressApiRequestAllItems.call(this, 'GET', '/users', {}, { who: 'authors' });
                      for (const author of authors) {
                          const authorName = author.name;
                          const authorId = author.id;
                          returnData.push({
                              name: authorName,
                              value: authorId,
                          });
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let responseData;
          const qs = {};
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < length; i++) {
              try {
                  if (resource === 'post') {
                      if (operation === 'create') {
                          const title = this.getNodeParameter('title', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              title,
                          };
                          if (additionalFields.authorId) {
                              body.author = additionalFields.authorId;
                          }
                          if (additionalFields.content) {
                              body.content = additionalFields.content;
                          }
                          if (additionalFields.slug) {
                              body.slug = additionalFields.slug;
                          }
                          if (additionalFields.password) {
                              body.password = additionalFields.password;
                          }
                          if (additionalFields.status) {
                              body.status = additionalFields.status;
                          }
                          if (additionalFields.commentStatus) {
                              body.comment_status = additionalFields.commentStatus;
                          }
                          if (additionalFields.pingStatus) {
                              body.ping_status = additionalFields.pingStatus;
                          }
                          if (additionalFields.sticky) {
                              body.sticky = additionalFields.sticky;
                          }
                          if (additionalFields.postTemplate) {
                              body.template = this.getNodeParameter('additionalFields.postTemplate.values.template', i, '');
                          }
                          if (additionalFields.categories) {
                              body.categories = additionalFields.categories;
                          }
                          if (additionalFields.tags) {
                              body.tags = additionalFields.tags;
                          }
                          if (additionalFields.format) {
                              body.format = additionalFields.format;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'POST', '/posts', body);
                      }
                      if (operation === 'update') {
                          const postId = this.getNodeParameter('postId', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id: parseInt(postId, 10),
                          };
                          if (updateFields.authorId) {
                              body.author = updateFields.authorId;
                          }
                          if (updateFields.title) {
                              body.title = updateFields.title;
                          }
                          if (updateFields.content) {
                              body.content = updateFields.content;
                          }
                          if (updateFields.slug) {
                              body.slug = updateFields.slug;
                          }
                          if (updateFields.password) {
                              body.password = updateFields.password;
                          }
                          if (updateFields.status) {
                              body.status = updateFields.status;
                          }
                          if (updateFields.commentStatus) {
                              body.comment_status = updateFields.commentStatus;
                          }
                          if (updateFields.pingStatus) {
                              body.ping_status = updateFields.pingStatus;
                          }
                          if (updateFields.sticky) {
                              body.sticky = updateFields.sticky;
                          }
                          if (updateFields.postTemplate) {
                              body.template = this.getNodeParameter('updateFields.postTemplate.values.template', i, '');
                          }
                          if (updateFields.categories) {
                              body.categories = updateFields.categories;
                          }
                          if (updateFields.tags) {
                              body.tags = updateFields.tags;
                          }
                          if (updateFields.format) {
                              body.format = updateFields.format;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'POST', `/posts/${postId}`, body);
                      }
                      if (operation === 'get') {
                          const postId = this.getNodeParameter('postId', i);
                          const options = this.getNodeParameter('options', i);
                          if (options.password) {
                              qs.password = options.password;
                          }
                          if (options.context) {
                              qs.context = options.context;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'GET', `/posts/${postId}`, {}, qs);
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const options = this.getNodeParameter('options', i);
                          if (options.context) {
                              qs.context = options.context;
                          }
                          if (options.orderBy) {
                              qs.orderby = options.orderBy;
                          }
                          if (options.order) {
                              qs.order = options.order;
                          }
                          if (options.search) {
                              qs.search = options.search;
                          }
                          if (options.after) {
                              qs.after = options.after;
                          }
                          if (options.author) {
                              qs.author = options.author;
                          }
                          if (options.categories) {
                              qs.categories = options.categories;
                          }
                          if (options.excludedCategories) {
                              qs.categories_exclude = options.excludedCategories;
                          }
                          if (options.tags) {
                              qs.tags = options.tags;
                          }
                          if (options.excludedTags) {
                              qs.tags_exclude = options.excludedTags;
                          }
                          if (options.sticky) {
                              qs.sticky = options.sticky;
                          }
                          if (options.status) {
                              qs.status = options.status;
                          }
                          if (returnAll) {
                              responseData = await GenericFunctions_1.wordpressApiRequestAllItems.call(this, 'GET', '/posts', {}, qs);
                          }
                          else {
                              qs.per_page = this.getNodeParameter('limit', i);
                              responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'GET', '/posts', {}, qs);
                          }
                      }
                      if (operation === 'delete') {
                          const postId = this.getNodeParameter('postId', i);
                          const options = this.getNodeParameter('options', i);
                          if (options.force) {
                              qs.force = options.force;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'DELETE', `/posts/${postId}`, {}, qs);
                      }
                  }
                  if (resource === 'user') {
                      if (operation === 'create') {
                          const name = this.getNodeParameter('name', i);
                          const username = this.getNodeParameter('username', i);
                          const firstName = this.getNodeParameter('firstName', i);
                          const lastName = this.getNodeParameter('lastName', i);
                          const email = this.getNodeParameter('email', i);
                          const password = this.getNodeParameter('password', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          const body = {
                              name,
                              username,
                              first_name: firstName,
                              last_name: lastName,
                              email,
                              password,
                          };
                          if (additionalFields.url) {
                              body.url = additionalFields.url;
                          }
                          if (additionalFields.description) {
                              body.description = additionalFields.description;
                          }
                          if (additionalFields.nickname) {
                              body.nickname = additionalFields.nickname;
                          }
                          if (additionalFields.slug) {
                              body.slug = additionalFields.slug;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'POST', '/users', body);
                      }
                      if (operation === 'update') {
                          const userId = this.getNodeParameter('userId', i);
                          const updateFields = this.getNodeParameter('updateFields', i);
                          const body = {
                              id: userId,
                          };
                          if (updateFields.name) {
                              body.name = updateFields.name;
                          }
                          if (updateFields.firstName) {
                              body.first_name = updateFields.firstName;
                          }
                          if (updateFields.lastName) {
                              body.last_name = updateFields.lastName;
                          }
                          if (updateFields.email) {
                              body.email = updateFields.email;
                          }
                          if (updateFields.password) {
                              body.password = updateFields.password;
                          }
                          if (updateFields.username) {
                              body.username = updateFields.username;
                          }
                          if (updateFields.url) {
                              body.url = updateFields.url;
                          }
                          if (updateFields.description) {
                              body.description = updateFields.description;
                          }
                          if (updateFields.nickname) {
                              body.nickname = updateFields.nickname;
                          }
                          if (updateFields.slug) {
                              body.slug = updateFields.slug;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'POST', `/users/${userId}`, body);
                      }
                      if (operation === 'get') {
                          const userId = this.getNodeParameter('userId', i);
                          const options = this.getNodeParameter('options', i);
                          if (options.context) {
                              qs.context = options.context;
                          }
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'GET', `/users/${userId}`, {}, qs);
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const options = this.getNodeParameter('options', i);
                          if (options.context) {
                              qs.context = options.context;
                          }
                          if (options.orderBy) {
                              qs.orderby = options.orderBy;
                          }
                          if (options.order) {
                              qs.order = options.order;
                          }
                          if (options.search) {
                              qs.search = options.search;
                          }
                          if (options.who) {
                              qs.who = options.who;
                          }
                          if (returnAll) {
                              responseData = await GenericFunctions_1.wordpressApiRequestAllItems.call(this, 'GET', '/users', {}, qs);
                          }
                          else {
                              qs.per_page = this.getNodeParameter('limit', i);
                              responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'GET', '/users', {}, qs);
                          }
                      }
                      if (operation === 'delete') {
                          const reassign = this.getNodeParameter('reassign', i);
                          qs.reassign = reassign;
                          qs.force = true;
                          responseData = await GenericFunctions_1.wordpressApiRequest.call(this, 'DELETE', '/users/me', {}, qs);
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                  returnData.push(...executionData);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({ json: { error: error.message } });
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.Wordpress = Wordpress;
  //# sourceMappingURL=Wordpress.node.js.map

documentation_markdown:
  ---
  #https://www.notion.so/n8n/Frontmatter-432c2b8dff1f43d4b1c8d20075510fe4
  title: WordPress node documentation
  description: Learn how to use the WordPress node in n8n. Follow technical documentation to integrate WordPress node into your workflows.
  contentType: [integration, reference]
  priority: medium
  ---

  # WordPress node

  Use the WordPress node to automate work in WordPress, and integrate WordPress with other applications. n8n has built-in support for a wide range of WordPress features, including creating, updating, and getting posts and users.

  On this page, you'll find a list of operations the WordPress node supports and links to more resources.

  /// note | Credentials
  Refer to [WordPress credentials](/integrations/builtin/credentials/wordpress.md) for guidance on setting up authentication. 
  ///

  --8<-- "_snippets/integrations/builtin/app-nodes/ai-tools.md"

  ## Operations

  * Post
      * Create a post
      * Get a post
      * Get all posts
      * Update a post
  * Pages
      * Create a page
      * Get a page
      * Get all pages
      * Update a page
  * User
      * Create a user
      * Get a user
      * Get all users
      * Update a user

  ## Templates and examples

  <!-- see https://www.notion.so/n8n/Pull-in-templates-for-the-integrations-pages-37c716837b804d30a33b47475f6e3780 -->
  [[ templatesWidget(page.title, 'wordpress') ]]

  --8<-- "_snippets/integrations/builtin/app-nodes/operation-not-supported.md"

example_workflow:
  {"nodes":[{"parameters":{},"type":"n8n-nodes-base.node","typeVersion":1,"position":[220,120],"id":"8812bf04-1886-49bd-9f2f-63cb96e22f7c","name":"Node"}],"connections":{"Node":{"main":[[]]}},"pinData":{},"meta":{"templateCredsSetupCompleted":true,"instanceId":"d9c211ba201e58df590d68b559429f43d6c0ea6435e68994137f9b4952318197"}}


