# nodes

node_type: n8n-nodes-base.Plivo
name: Plivo
display_name: Plivo
description: Send SMS/MMS messages or make phone calls
category: transform
icon: file:plivo.svg
code_hash: 59e0f9f644243d74ed88941e6038e4e863bd1fdf3166997922be2484773ead0c
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Plivo
documentation_title: Plivo node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"plivo","description":"Templates for plivo"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"call","dynamic_property":null}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:04
updated_at: 2025-06-12 08:59:04
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Plivo = void 0;
  const SmsDescription_1 = require("./SmsDescription");
  const MmsDescription_1 = require("./MmsDescription");
  const CallDescription_1 = require("./CallDescription");
  const GenericFunctions_1 = require("./GenericFunctions");
  class Plivo {
      constructor() {
          this.description = {
              displayName: 'Plivo',
              name: 'plivo',
              icon: 'file:plivo.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Send SMS/MMS messages or make phone calls',
              defaults: {
                  name: 'Plivo',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'plivoApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Call',
                              value: 'call',
                          },
                          {
                              name: 'MMS',
                              value: 'mms',
                          },
                          {
                              name: 'SMS',
                              value: 'sms',
                          },
                      ],
                      default: 'sms',
                      required: true,
                  },
                  ...SmsDescription_1.smsOperations,
                  ...SmsDescription_1.smsFields,
                  ...MmsDescription_1.mmsOperations,
                  ...MmsDescription_1.mmsFields,
                  ...CallDescription_1.callOperations,
                  ...CallDescription_1.callFields,
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          for (let i = 0; i < items.length; i++) {
              let responseData;
              if (resource === 'sms') {
                  if (operation === 'send') {
                      const body = {
                          src: this.getNodeParameter('from', i),
                          dst: this.getNodeParameter('to', i),
                          text: this.getNodeParameter('message', i),
                      };
                      responseData = await GenericFunctions_1.plivoApiRequest.call(this, 'POST', '/Message', body);
                  }
              }
              else if (resource === 'call') {
                  if (operation === 'make') {
                      const body = {
                          from: this.getNodeParameter('from', i),
                          to: this.getNodeParameter('to', i),
                          answer_url: this.getNodeParameter('answer_url', i),
                          answer_method: this.getNodeParameter('answer_method', i),
                      };
                      responseData = await GenericFunctions_1.plivoApiRequest.call(this, 'POST', '/Call', body);
                  }
              }
              else if (resource === 'mms') {
                  if (operation === 'send') {
                      const body = {
                          src: this.getNodeParameter('from', i),
                          dst: this.getNodeParameter('to', i),
                          text: this.getNodeParameter('message', i),
                          type: 'mms',
                          media_urls: this.getNodeParameter('media_urls', i),
                      };
                      responseData = await GenericFunctions_1.plivoApiRequest.call(this, 'POST', '/Message', body);
                  }
              }
              Array.isArray(responseData)
                  ? returnData.push(...responseData)
                  : returnData.push(responseData);
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Plivo = Plivo;
  //# sourceMappingURL=Plivo.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PlivoApi = void 0;
  class PlivoApi {
      constructor() {
          this.name = 'plivoApi';
          this.displayName = 'Plivo API';
          this.documentationUrl = 'plivo';
          this.properties = [
              {
                  displayName: 'Auth ID',
                  name: 'authId',
                  type: 'string',
                  default: '',
              },
              {
                  displayName: 'Auth Token',
                  name: 'authToken',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
      }
  }
  exports.PlivoApi = PlivoApi;
  //# sourceMappingURL=PlivoApi.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PlivoApi = void 0;
  class PlivoApi {
      constructor() {
          this.name = 'plivoApi';
          this.displayName = 'Plivo API';
          this.documentationUrl = 'plivo';
          this.properties = [
              {
                  displayName: 'Auth ID',
                  name: 'authId',
                  type: 'string',
                  default: '',
              },
              {
                  displayName: 'Auth Token',
                  name: 'authToken',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
      }
  }
  exports.PlivoApi = PlivoApi;
  //# sourceMappingURL=PlivoApi.credentials.js.map

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

  # Plivo node

  Use the Plivo node to automate work in Plivo, and integrate Plivo with other applications. n8n has built-in support for a wide range of Plivo features, including making calls, and sending SMS/MMS. 

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

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

  ## Operations

  * Call
      * Make a voice call
  * MMS
      * Send an MMS message (US/Canada only)
  * SMS
      * Send an SMS message.

  ## Templates and examples

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

example_workflow:
  {"name":"Plivo Example Workflow","nodes":[{"parameters":{"resource":"call","dynamic_property":null},"id":"bjva5ehjtw3113lyb4idi","name":"Plivo","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"sms","required":true,"options":[{"name":"Call","value":"call"},{"name":"MMS","value":"mms"},{"name":"SMS","value":"sms"}]},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...SmsDescription_1.smsOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...SmsDescription_1.smsFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...MmsDescription_1.mmsOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...MmsDescription_1.mmsFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...CallDescription_1.callOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...CallDescription_1.callFields"}]


node_type: n8n-nodes-base.Pushbullet
name: Pushbullet
display_name: Pushbullet
description: Consume Pushbullet API
category: input
icon: file:pushbullet.svg
code_hash: 6352a9ed63d4fb5cd185cf85a29778fb67757992f84c8013c03bf4eab023e94a
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Pushbullet
documentation_title: Pushbullet node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"pushbullet","description":"Templates for pushbullet"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:04
updated_at: 2025-06-12 08:59:04
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.Pushbullet = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  const moment_timezone_1 = __importDefault(require("moment-timezone"));
  class Pushbullet {
      constructor() {
          this.description = {
              displayName: 'Pushbullet',
              name: 'pushbullet',
              icon: 'file:pushbullet.svg',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Pushbullet API',
              defaults: {
                  name: 'Pushbullet',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'pushbulletOAuth2Api',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Push',
                              value: 'push',
                          },
                      ],
                      default: 'push',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                          },
                      },
                      options: [
                          {
                              name: 'Create',
                              value: 'create',
                              description: 'Create a push',
                              action: 'Create a push',
                          },
                          {
                              name: 'Delete',
                              value: 'delete',
                              description: 'Delete a push',
                              action: 'Delete a push',
                          },
                          {
                              name: 'Get Many',
                              value: 'getAll',
                              description: 'Get many pushes',
                              action: 'Get many pushes',
                          },
                          {
                              name: 'Update',
                              value: 'update',
                              description: 'Update a push',
                              action: 'Update a push',
                          },
                      ],
                      default: 'create',
                  },
                  {
                      displayName: 'Type',
                      name: 'type',
                      type: 'options',
                      options: [
                          {
                              name: 'File',
                              value: 'file',
                          },
                          {
                              name: 'Link',
                              value: 'link',
                          },
                          {
                              name: 'Note',
                              value: 'note',
                          },
                      ],
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                          },
                      },
                      default: 'note',
                  },
                  {
                      displayName: 'Title',
                      name: 'title',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                              type: ['note', 'link'],
                          },
                      },
                      default: '',
                      description: 'Title of the push',
                  },
                  {
                      displayName: 'Body',
                      name: 'body',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                              type: ['note', 'link', 'file'],
                          },
                      },
                      default: '',
                      description: 'Body of the push',
                  },
                  {
                      displayName: 'URL',
                      name: 'url',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                              type: ['link'],
                          },
                      },
                      default: '',
                      description: 'URL of the push',
                  },
                  {
                      displayName: 'Binary Property',
                      name: 'binaryPropertyName',
                      type: 'string',
                      default: 'data',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                              type: ['file'],
                          },
                      },
                      placeholder: '',
                      description: 'Name of the binary property which contains the data for the file to be created',
                  },
                  {
                      displayName: 'Target',
                      name: 'target',
                      type: 'options',
                      options: [
                          {
                              name: 'Channel Tag',
                              value: 'channel_tag',
                              description: 'Send the push to all subscribers to your channel that has this tag',
                          },
                          {
                              name: 'Default',
                              value: 'default',
                              description: "Broadcast it to all of the user's devices",
                          },
                          {
                              name: 'Device ID',
                              value: 'device_iden',
                              description: 'Send the push to a specific device',
                          },
                          {
                              name: 'Email',
                              value: 'email',
                              description: 'Send the push to this email address',
                          },
                      ],
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                          },
                      },
                      default: 'default',
                      description: 'Define the medium that will be used to send the push',
                  },
                  {
                      displayName: 'Value',
                      name: 'value',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                          },
                          hide: {
                              target: ['default', 'device_iden'],
                          },
                      },
                      default: '',
                      description: 'The value to be set depending on the target selected. For example, if the target selected is email then this field would take the email address of the person you are trying to send the push to.',
                  },
                  {
                      displayName: 'Value Name or ID',
                      name: 'value',
                      type: 'options',
                      typeOptions: {
                          loadOptionsMethod: 'getDevices',
                      },
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['create'],
                              target: ['device_iden'],
                          },
                      },
                      default: '',
                      description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>',
                  },
                  {
                      displayName: 'Push ID',
                      name: 'pushId',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['delete'],
                          },
                      },
                      default: '',
                  },
                  {
                      displayName: 'Return All',
                      name: 'returnAll',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['getAll'],
                              resource: ['push'],
                          },
                      },
                      default: false,
                      description: 'Whether to return all results or only up to a given limit',
                  },
                  {
                      displayName: 'Limit',
                      name: 'limit',
                      type: 'number',
                      displayOptions: {
                          show: {
                              operation: ['getAll'],
                              resource: ['push'],
                              returnAll: [false],
                          },
                      },
                      typeOptions: {
                          minValue: 1,
                          maxValue: 500,
                      },
                      default: 100,
                      description: 'Max number of results to return',
                  },
                  {
                      displayName: 'Filters',
                      name: 'filters',
                      type: 'collection',
                      placeholder: 'Add Filter',
                      default: {},
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['getAll'],
                          },
                      },
                      options: [
                          {
                              displayName: 'Active',
                              name: 'active',
                              type: 'boolean',
                              default: false,
                              description: "Don't return deleted pushes",
                          },
                          {
                              displayName: 'Modified After',
                              name: 'modified_after',
                              type: 'dateTime',
                              default: '',
                              description: 'Request pushes modified after this timestamp',
                          },
                      ],
                  },
                  {
                      displayName: 'Push ID',
                      name: 'pushId',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['update'],
                          },
                      },
                      default: '',
                  },
                  {
                      displayName: 'Dismissed',
                      name: 'dismissed',
                      type: 'boolean',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['push'],
                              operation: ['update'],
                          },
                      },
                      default: false,
                      description: 'Whether to mark a push as having been dismissed by the user, will cause any notifications for the push to be hidden if possible',
                  },
              ],
          };
          this.methods = {
              loadOptions: {
                  async getDevices() {
                      const returnData = [];
                      const { devices } = await GenericFunctions_1.pushbulletApiRequest.call(this, 'GET', '/devices');
                      for (const device of devices) {
                          returnData.push({
                              name: device.nickname,
                              value: device.iden,
                          });
                      }
                      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 === 'push') {
                      if (operation === 'create') {
                          const type = this.getNodeParameter('type', i);
                          const message = this.getNodeParameter('body', i);
                          const target = this.getNodeParameter('target', i);
                          const body = {
                              type,
                              body: message,
                          };
                          if (target !== 'default') {
                              const value = this.getNodeParameter('value', i);
                              body[target] = value;
                          }
                          if (['note', 'link'].includes(type)) {
                              body.title = this.getNodeParameter('title', i);
                              if (type === 'link') {
                                  body.url = this.getNodeParameter('url', i);
                              }
                          }
                          if (type === 'file') {
                              const binaryPropertyName = this.getNodeParameter('binaryPropertyName', 0);
                              const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
                              const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
                              const { upload_url: uploadUrl, file_name, file_type, file_url, } = await GenericFunctions_1.pushbulletApiRequest.call(this, 'POST', '/upload-request', {
                                  file_name: binaryData.fileName,
                                  file_type: binaryData.mimeType,
                              });
                              await GenericFunctions_1.pushbulletApiRequest.call(this, 'POST', '', {}, {}, uploadUrl, {
                                  formData: {
                                      file: {
                                          value: dataBuffer,
                                          options: {
                                              filename: binaryData.fileName,
                                          },
                                      },
                                  },
                                  json: false,
                              });
                              body.file_name = file_name;
                              body.file_type = file_type;
                              body.file_url = file_url;
                          }
                          responseData = await GenericFunctions_1.pushbulletApiRequest.call(this, 'POST', '/pushes', body);
                      }
                      if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', 0);
                          const filters = this.getNodeParameter('filters', i);
                          Object.assign(qs, filters);
                          if (qs.modified_after) {
                              qs.modified_after = (0, moment_timezone_1.default)(qs.modified_after).unix();
                          }
                          if (returnAll) {
                              responseData = await GenericFunctions_1.pushbulletApiRequestAllItems.call(this, 'pushes', 'GET', '/pushes', {}, qs);
                          }
                          else {
                              qs.limit = this.getNodeParameter('limit', 0);
                              responseData = await GenericFunctions_1.pushbulletApiRequest.call(this, 'GET', '/pushes', {}, qs);
                              responseData = responseData.pushes;
                          }
                      }
                      if (operation === 'delete') {
                          const pushId = this.getNodeParameter('pushId', i);
                          responseData = await GenericFunctions_1.pushbulletApiRequest.call(this, 'DELETE', `/pushes/${pushId}`);
                          responseData = { success: true };
                      }
                      if (operation === 'update') {
                          const pushId = this.getNodeParameter('pushId', i);
                          const dismissed = this.getNodeParameter('dismissed', i);
                          responseData = await GenericFunctions_1.pushbulletApiRequest.call(this, 'POST', `/pushes/${pushId}`, {
                              dismissed,
                          });
                      }
                  }
                  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.Pushbullet = Pushbullet;
  //# sourceMappingURL=Pushbullet.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushbulletOAuth2Api = void 0;
  class PushbulletOAuth2Api {
      constructor() {
          this.name = 'pushbulletOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Pushbullet OAuth2 API';
          this.documentationUrl = 'pushbullet';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://www.pushbullet.com/authorize',
                  required: true,
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://api.pushbullet.com/oauth2/token',
                  required: true,
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'body',
              },
          ];
      }
  }
  exports.PushbulletOAuth2Api = PushbulletOAuth2Api;
  //# sourceMappingURL=PushbulletOAuth2Api.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushbulletOAuth2Api = void 0;
  class PushbulletOAuth2Api {
      constructor() {
          this.name = 'pushbulletOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Pushbullet OAuth2 API';
          this.documentationUrl = 'pushbullet';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://www.pushbullet.com/authorize',
                  required: true,
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://api.pushbullet.com/oauth2/token',
                  required: true,
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'body',
              },
          ];
      }
  }
  exports.PushbulletOAuth2Api = PushbulletOAuth2Api;
  //# sourceMappingURL=PushbulletOAuth2Api.credentials.js.map

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

  # Pushbullet node

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

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

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

  ## Operations

  * Push
      * Create a push
      * Delete a push
      * Get all pushes
      * Update a push

  ## Templates and examples

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

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

example_workflow:
  {"name":"Pushbullet Example Workflow","nodes":[{"parameters":{"resource":"push","operation":"create","type":"file","title":"example-value","body":"example-value","url":"https://example.com","binaryPropertyName":"Example Name","target":"channel_tag","value":"","pushId":"example-value","returnAll":false,"limit":100,"filters":{},"dismissed":false},"id":"gxgx4nsexdglndzn85x07l","name":"Pushbullet","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"resource":"push","operation":"create","type":"file","title":"example-value","body":"example-value","url":"https://example.com","binaryPropertyName":"Example Name","target":"channel_tag","value":"","pushId":"example-value","returnAll":false,"limit":100,"filters":{},"dismissed":false}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"push","options":[{"name":"Push","value":"push"}]},{"displayName":"Operation","name":"operation","type":"options","default":"create","description":"Create a push","options":[{"name":"Create","value":"create","description":"Create a push"},{"name":"Delete","value":"delete","description":"Delete a push"},{"name":"Get Many","value":"getAll","description":"Get many pushes"},{"name":"Update","value":"update","description":"Update a push"}]},{"displayName":"Type","name":"type","type":"options","default":"note","required":true,"options":[{"name":"File","value":"file"},{"name":"Link","value":"link"},{"name":"Note","value":"note"}]},{"displayName":"Title","name":"title","type":"string","default":"","required":true,"description":"Title of the push"},{"displayName":"Body","name":"body","type":"string","default":"","required":true,"description":"Body of the push"},{"displayName":"URL","name":"url","type":"string","default":"","required":true,"description":"URL of the push"},{"displayName":"Binary Property","name":"binaryPropertyName","type":"string","default":"data","required":true,"description":"Name of the binary property which contains the data for the file to be created"},{"displayName":"Target","name":"target","type":"options","default":"default","required":true,"description":"Send the push to all subscribers to your channel that has this tag","options":[{"name":"Channel Tag","value":"channel_tag","description":"Send the push to all subscribers to your channel that has this tag"},{"name":"Default","value":"default","description":"Broadcast it to all of the user"},{"name":"Device ID","value":"device_iden","description":"Send the push to a specific device"},{"name":"Email","value":"email","description":"Send the push to this email address"}]},{"displayName":"Value","name":"value","type":"string","default":"","required":true,"description":"The value to be set depending on the target selected. For example, if the target selected is email then this field would take the email address of the person you are trying to send the push to."},{"displayName":"Value Name or ID","name":"value","type":"options","default":"","required":true,"description":"Choose from the list, or specify an ID using an <a href="},{"displayName":"Push ID","name":"pushId","type":"string","default":"","required":true},{"displayName":"Return All","name":"returnAll","type":"boolean","default":false,"description":"Whether to return all results or only up to a given limit"},{"displayName":"Limit","name":"limit","type":"number","default":100,"description":"Max number of results to return"},{"displayName":"Filters","name":"filters","type":"collection","default":"{","description":"Don","placeholder":"Add Filter"},{"displayName":"Push ID","name":"pushId","type":"string","default":"","required":true},{"displayName":"Dismissed","name":"dismissed","type":"boolean","default":false,"required":true,"description":"Whether to mark a push as having been dismissed by the user, will cause any notifications for the push to be hidden if possible"}]


node_type: n8n-nodes-base.Pushcut
name: Pushcut
display_name: Pushcut
description: Consume Pushcut API
category: input
icon: file:pushcut.png
code_hash: 7b69beb7d523647571e05d593f709612aad72eb64f56b0f87ac030ea69eb03eb
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Pushcut
documentation_title: Pushcut node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"pushcut","description":"Templates for pushcut"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"notification","operation":"send","notificationName":"","additionalFields":{}}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:04
updated_at: 2025-06-12 08:59:04
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Pushcut = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  class Pushcut {
      constructor() {
          this.description = {
              displayName: 'Pushcut',
              name: 'pushcut',
              icon: 'file:pushcut.png',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Pushcut API',
              defaults: {
                  name: 'Pushcut',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'pushcutApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Notification',
                              value: 'notification',
                          },
                      ],
                      default: 'notification',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['notification'],
                          },
                      },
                      options: [
                          {
                              name: 'Send',
                              value: 'send',
                              description: 'Send a notification',
                              action: 'Send a notification',
                          },
                      ],
                      default: 'send',
                  },
                  {
                      displayName: 'Notification Name or ID',
                      name: 'notificationName',
                      type: 'options',
                      description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>',
                      typeOptions: {
                          loadOptionsMethod: 'getNotifications',
                      },
                      displayOptions: {
                          show: {
                              resource: ['notification'],
                              operation: ['send'],
                          },
                      },
                      default: '',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      displayOptions: {
                          show: {
                              operation: ['send'],
                              resource: ['notification'],
                          },
                      },
                      default: {},
                      options: [
                          {
                              displayName: 'Device Names or IDs',
                              name: 'devices',
                              type: 'multiOptions',
                              typeOptions: {
                                  loadOptionsMethod: 'getDevices',
                              },
                              default: [],
                              description: 'List of devices this notification is sent to. (default is all devices). Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
                          },
                          {
                              displayName: 'Input',
                              name: 'input',
                              type: 'string',
                              default: '',
                              description: 'Value that is passed as input to the notification action',
                          },
                          {
                              displayName: 'Text',
                              name: 'text',
                              type: 'string',
                              default: '',
                              description: 'Text that is used instead of the one defined in the app',
                          },
                          {
                              displayName: 'Title',
                              name: 'title',
                              type: 'string',
                              default: '',
                              description: 'Title that is used instead of the one defined in the app',
                          },
                      ],
                  },
              ],
          };
          this.methods = {
              loadOptions: {
                  async getDevices() {
                      const returnData = [];
                      const devices = await GenericFunctions_1.pushcutApiRequest.call(this, 'GET', '/devices');
                      for (const device of devices) {
                          returnData.push({
                              name: device.id,
                              value: device.id,
                          });
                      }
                      return returnData;
                  },
                  async getNotifications() {
                      const returnData = [];
                      const notifications = await GenericFunctions_1.pushcutApiRequest.call(this, 'GET', '/notifications');
                      for (const notification of notifications) {
                          returnData.push({
                              name: notification.title,
                              value: notification.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 === 'notification') {
                  if (operation === 'send') {
                      const notificationName = this.getNodeParameter('notificationName', i);
                      const additionalFields = this.getNodeParameter('additionalFields', i);
                      const body = {};
                      Object.assign(body, additionalFields);
                      responseData = await GenericFunctions_1.pushcutApiRequest.call(this, 'POST', `/notifications/${encodeURI(notificationName)}`, body);
                  }
              }
          }
          if (Array.isArray(responseData)) {
              returnData.push.apply(returnData, responseData);
          }
          else if (responseData !== undefined) {
              returnData.push(responseData);
          }
          return [this.helpers.returnJsonArray(returnData)];
      }
  }
  exports.Pushcut = Pushcut;
  //# sourceMappingURL=Pushcut.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushcutApi = void 0;
  class PushcutApi {
      constructor() {
          this.name = 'pushcutApi';
          this.displayName = 'Pushcut API';
          this.documentationUrl = 'pushcut';
          this.properties = [
              {
                  displayName: 'API Key',
                  name: 'apiKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
      }
  }
  exports.PushcutApi = PushcutApi;
  //# sourceMappingURL=PushcutApi.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushcutApi = void 0;
  class PushcutApi {
      constructor() {
          this.name = 'pushcutApi';
          this.displayName = 'Pushcut API';
          this.documentationUrl = 'pushcut';
          this.properties = [
              {
                  displayName: 'API Key',
                  name: 'apiKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
      }
  }
  exports.PushcutApi = PushcutApi;
  //# sourceMappingURL=PushcutApi.credentials.js.map

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

  # Pushcut node

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

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

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

  ## Operations

  * Notification
      * Send a notification

  ## Templates and examples

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

example_workflow:
  {"name":"Pushcut Example Workflow","nodes":[{"parameters":{"resource":"notification","operation":"send","notificationName":"","additionalFields":{}},"id":"mg0m779vlzh8clhaxdi2p","name":"Pushcut","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"notification","options":[{"name":"Notification","value":"notification"}]},{"displayName":"Operation","name":"operation","type":"options","default":"send","description":"Send a notification","options":[{"name":"Send","value":"send","description":"Send a notification"}]},{"displayName":"Notification Name or ID","name":"notificationName","type":"options","default":"","description":"Choose from the list, or specify an ID using an <a href="},{"displayName":"Additional Fields","name":"additionalFields","type":"collection","default":"{","description":"List of devices this notification is sent to. (default is all devices). Choose from the list, or specify IDs using an <a href=","placeholder":"Add Field"}]


node_type: n8n-nodes-base.QuestDb
name: QuestDb
display_name: QuestDB
description: Get, add and update data in QuestDB
category: input
icon: file:questdb.png
code_hash: 574aabe37688781da940acac0261aa5557874f116089eed6b378a603b7580b71
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.QuestDb
documentation_title: QuestDB node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"questdb","description":"Templates for questdb"}]
related_resources: []
required_scopes: []
parameter_schemas: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
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.QuestDb = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const pg_promise_1 = __importDefault(require("pg-promise"));
  const genericFunctions_1 = require("../Postgres/v1/genericFunctions");
  class QuestDb {
      constructor() {
          this.description = {
              displayName: 'QuestDB',
              name: 'questDb',
              icon: 'file:questdb.png',
              group: ['input'],
              version: 1,
              description: 'Get, add and update data in QuestDB',
              defaults: {
                  name: 'QuestDB',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'questDb',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Execute Query',
                              value: 'executeQuery',
                              description: 'Executes a SQL query',
                              action: 'Execute a SQL query',
                          },
                          {
                              name: 'Insert',
                              value: 'insert',
                              description: 'Insert rows in database',
                              action: 'Insert 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: 'hidden',
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                      default: '',
                      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: 'Return Fields',
                      name: 'returnFields',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                      default: '*',
                      description: 'Comma-separated list of the fields that the operation will return',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      default: {},
                      displayOptions: {
                          show: {
                              operation: ['executeQuery'],
                          },
                      },
                      options: [
                          {
                              displayName: 'Mode',
                              name: 'mode',
                              type: 'options',
                              options: [
                                  {
                                      name: 'Independently',
                                      value: 'independently',
                                      description: 'Execute each query independently',
                                  },
                                  {
                                      name: 'Transaction',
                                      value: 'transaction',
                                      description: 'Executes all queries in a single transaction',
                                  },
                              ],
                              default: 'independently',
                              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.questdb/">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',
                          },
                      ],
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'hidden',
                      default: {},
                      displayOptions: {
                          show: {
                              operation: ['insert'],
                          },
                      },
                  },
              ],
          };
      }
      async execute() {
          const credentials = await this.getCredentials('questDb');
          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 additionalFields = this.getNodeParameter('additionalFields', 0);
              const mode = (additionalFields.mode || 'independently');
              const queryResult = await genericFunctions_1.pgQueryV2.call(this, pgp, db, items, this.continueOnFail(), {
                  overrideMode: mode,
                  resolveExpression: true,
              });
              returnItems = this.helpers.returnJsonArray(queryResult);
          }
          else if (operation === 'insert') {
              await (0, genericFunctions_1.pgInsert)(this.getNodeParameter, pgp, db, items, this.continueOnFail(), 'independently');
              const returnFields = this.getNodeParameter('returnFields', 0);
              const table = this.getNodeParameter('table', 0);
              const insertData = await db.any('SELECT ${columns:name} from ${table:name}', {
                  columns: returnFields
                      .split(',')
                      .map((value) => value.trim())
                      .filter((value) => !!value),
                  table,
              });
              returnItems = this.helpers.returnJsonArray(insertData);
          }
          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.QuestDb = QuestDb;
  //# sourceMappingURL=QuestDb.node.js.map

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

  # QuestDB node

  Use the QuestDB node to automate work in QuestDB, and integrate QuestDB with other applications. n8n supports executing an SQL query and inserting rows in a database with QuestDB.

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

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

  ## Operations

  * Executes a SQL query.
  * Insert rows in database.

  ## Templates and examples

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

  ## Node reference

  ### 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 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`.

troubleshooting_info:
  [{"issue":"Specify a column's data type","solution":"To specify a column's data type, append the column name with `:type`, where `type` is the data type you want for 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:
  {"name":"QuestDB Example Workflow","nodes":[{"parameters":{"operation":"executeQuery","query":"example-value","schema":null,"table":"example-value","columns":"example-value","returnFields":"*","additionalFields":"{"},"id":"xudprbqhinr6vhb3fvzaw8","name":"QuestDB","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"operation":"executeQuery","query":"example-value","schema":null,"table":"example-value","columns":"example-value","returnFields":"*","additionalFields":"{"}

properties_schema:
  [{"displayName":"Operation","name":"operation","type":"options","default":"insert","description":"Executes a SQL query","options":[{"name":"Execute Query","value":"executeQuery","description":"Executes a SQL query"},{"name":"Insert","value":"insert","description":"Insert rows in database"}]},{"displayName":"Query","name":"query","type":"string","default":"","required":true,"description":"The SQL query to execute. You can use n8n expressions or $1 and $2 in conjunction with query parameters.","placeholder":"SELECT id, name FROM product WHERE quantity > $1 AND price <= $2"},{"displayName":"Schema","name":"schema","type":"hidden","default":"","description":"Name of the schema the table belongs to"},{"displayName":"Table","name":"table","type":"string","default":"","required":true,"description":"Name of the table in which to insert data to"},{"displayName":"Columns","name":"columns","type":"string","default":"","description":"Comma-separated list of the properties which should used as columns for the new rows","placeholder":"id,name,description"},{"displayName":"Return Fields","name":"returnFields","type":"string","default":"*","description":"Comma-separated list of the fields that the operation will return"},{"displayName":"Additional Fields","name":"additionalFields","type":"collection","default":"{","description":"Execute each query independently","placeholder":"Add Field"},{"displayName":"Additional Fields","name":"additionalFields","type":"hidden","default":"{"}]


node_type: n8n-nodes-base.QuickChart
name: QuickChart
display_name: QuickChart
description: Create a chart via QuickChart
category: output
icon: file:quickChart.svg
code_hash: 236f4209dd03f420a5ab72f3149e71a3c515733d510f60f8c2bc8db5baa6fbb8
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.QuickChart
documentation_title: QuickChart node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"quickchart","description":"Templates for quickchart"}]
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickChart = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const constants_1 = require("./constants");
  class QuickChart {
      constructor() {
          this.description = {
              displayName: 'QuickChart',
              name: 'quickChart',
              icon: 'file:quickChart.svg',
              group: ['output'],
              description: 'Create a chart via QuickChart',
              version: 1,
              defaults: {
                  name: 'QuickChart',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'Chart Type',
                      name: 'chartType',
                      type: 'options',
                      default: 'bar',
                      options: constants_1.CHART_TYPE_OPTIONS,
                      description: 'The type of chart to create',
                  },
                  {
                      displayName: 'Add Labels',
                      name: 'labelsMode',
                      type: 'options',
                      options: [
                          {
                              name: 'Manually',
                              value: 'manually',
                          },
                          {
                              name: 'From Array',
                              value: 'array',
                          },
                      ],
                      default: 'manually',
                  },
                  {
                      displayName: 'Labels',
                      name: 'labelsUi',
                      type: 'fixedCollection',
                      typeOptions: {
                          multipleValues: true,
                          sortable: true,
                      },
                      default: {},
                      required: true,
                      description: 'Labels to use in the chart',
                      placeholder: 'Add Label',
                      options: [
                          {
                              name: 'labelsValues',
                              displayName: 'Labels',
                              values: [
                                  {
                                      displayName: 'Label',
                                      name: 'label',
                                      type: 'string',
                                      default: '',
                                  },
                              ],
                          },
                      ],
                      displayOptions: {
                          show: {
                              labelsMode: ['manually'],
                          },
                      },
                  },
                  {
                      displayName: 'Labels Array',
                      name: 'labelsArray',
                      type: 'string',
                      required: true,
                      default: '',
                      placeholder: 'e.g. ["Berlin", "Paris", "Rome", "New York"]',
                      displayOptions: {
                          show: {
                              labelsMode: ['array'],
                          },
                      },
                      description: 'The array of labels to be used in the chart',
                  },
                  {
                      displayName: 'Data',
                      name: 'data',
                      type: 'json',
                      default: '',
                      description: 'Data to use for the dataset, documentation and examples <a href="https://quickchart.io/documentation/chart-types/" target="_blank">here</a>',
                      placeholder: 'e.g. [60, 10, 12, 20]',
                      required: true,
                  },
                  {
                      displayName: 'Put Output In Field',
                      name: 'output',
                      type: 'string',
                      default: 'data',
                      required: true,
                      description: 'The binary data will be displayed in the Output panel on the right, under the Binary tab',
                      hint: 'The name of the output field to put the binary file data in',
                  },
                  {
                      displayName: 'Chart Options',
                      name: 'chartOptions',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Background Color',
                              name: 'backgroundColor',
                              type: 'color',
                              typeOptions: {
                                  showAlpha: true,
                              },
                              default: '',
                              description: 'Background color of the chart',
                          },
                          {
                              displayName: 'Device Pixel Ratio',
                              name: 'devicePixelRatio',
                              type: 'number',
                              default: 2,
                              typeOptions: {
                                  minValue: 1,
                                  maxValue: 2,
                              },
                              description: 'Pixel ratio of the chart',
                          },
                          {
                              displayName: 'Format',
                              name: 'format',
                              type: 'options',
                              default: 'png',
                              description: 'File format of the resulting chart',
                              options: [
                                  {
                                      name: 'PNG',
                                      value: 'png',
                                  },
                                  {
                                      name: 'PDF',
                                      value: 'pdf',
                                  },
                                  {
                                      name: 'SVG',
                                      value: 'svg',
                                  },
                                  {
                                      name: 'WebP',
                                      value: 'webp',
                                  },
                              ],
                          },
                          {
                              displayName: 'Height',
                              name: 'height',
                              type: 'number',
                              default: 300,
                              description: 'Height of the chart',
                          },
                          {
                              displayName: 'Horizontal',
                              name: 'horizontal',
                              type: 'boolean',
                              default: false,
                              description: 'Whether the chart should use its Y axis horizontal',
                              displayOptions: {
                                  show: {
                                      '/chartType': constants_1.HORIZONTAL_CHARTS,
                                  },
                              },
                          },
                          {
                              displayName: 'Width',
                              name: 'width',
                              type: 'number',
                              default: 500,
                              description: 'Width of the chart',
                          },
                      ],
                  },
                  {
                      displayName: 'Dataset Options',
                      name: 'datasetOptions',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Background Color',
                              name: 'backgroundColor',
                              type: 'color',
                              default: '',
                              typeOptions: {
                                  showAlpha: true,
                              },
                              description: 'Color used for the background the dataset (area of a line graph, fill of a bar chart, etc.)',
                          },
                          {
                              displayName: 'Border Color',
                              name: 'borderColor',
                              type: 'color',
                              typeOptions: {
                                  showAlpha: true,
                              },
                              default: '',
                              description: 'Color used for lines of the dataset',
                          },
                          {
                              displayName: 'Fill',
                              name: 'fill',
                              type: 'boolean',
                              default: true,
                              description: 'Whether to fill area of the dataset',
                              displayOptions: {
                                  show: {
                                      '/chartType': constants_1.Fill_CHARTS,
                                  },
                              },
                          },
                          {
                              displayName: 'Label',
                              name: 'label',
                              type: 'string',
                              default: '',
                              description: 'The label of the dataset',
                          },
                          {
                              displayName: 'Point Style',
                              name: 'pointStyle',
                              type: 'options',
                              default: 'circle',
                              description: 'Style to use for points of the dataset',
                              options: [
                                  {
                                      name: 'Circle',
                                      value: 'circle',
                                  },
                                  {
                                      name: 'Cross',
                                      value: 'cross',
                                  },
                                  {
                                      name: 'CrossRot',
                                      value: 'crossRot',
                                  },
                                  {
                                      name: 'Dash',
                                      value: 'dash',
                                  },
                                  {
                                      name: 'Line',
                                      value: 'line',
                                  },
                                  {
                                      name: 'Rect',
                                      value: 'rect',
                                  },
                                  {
                                      name: 'Rect Rot',
                                      value: 'rectRot',
                                  },
                                  {
                                      name: 'Rect Rounded',
                                      value: 'rectRounded',
                                  },
                                  {
                                      name: 'Star',
                                      value: 'star',
                                  },
                                  {
                                      name: 'Triangle',
                                      value: 'triangle',
                                  },
                              ],
                              displayOptions: {
                                  show: {
                                      '/chartType': constants_1.POINT_STYLE_CHARTS,
                                  },
                              },
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const datasets = [];
          let chartType = '';
          const labels = [];
          const labelsMode = this.getNodeParameter('labelsMode', 0);
          if (labelsMode === 'manually') {
              const labelsUi = this.getNodeParameter('labelsUi.labelsValues', 0, []);
              if (labelsUi.length) {
                  for (const labelValue of labelsUi) {
                      if (Array.isArray(labelValue.label)) {
                          labels === null || labels === void 0 ? void 0 : labels.push(...labelValue.label);
                      }
                      else {
                          labels === null || labels === void 0 ? void 0 : labels.push(labelValue.label);
                      }
                  }
              }
          }
          else {
              const labelsArray = this.getNodeParameter('labelsArray', 0, '');
              const errorMessage = 'Labels Array is not a valid array, use valid JSON format, or specify it by expressions';
              if (Array.isArray(labelsArray)) {
                  labels.push(...labelsArray);
              }
              else {
                  const labelsArrayParsed = (0, n8n_workflow_1.jsonParse)(labelsArray, {
                      errorMessage,
                  });
                  if (!Array.isArray(labelsArrayParsed)) {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
                  }
                  labels.push(...labelsArrayParsed);
              }
          }
          for (let i = 0; i < items.length; i++) {
              const data = this.getNodeParameter('data', i);
              const datasetOptions = this.getNodeParameter('datasetOptions', i);
              const backgroundColor = datasetOptions.backgroundColor;
              const borderColor = datasetOptions.borderColor;
              const fill = datasetOptions.fill;
              const label = datasetOptions.label || 'Chart';
              const pointStyle = datasetOptions.pointStyle;
              chartType = this.getNodeParameter('chartType', i);
              if (constants_1.HORIZONTAL_CHARTS.includes(chartType)) {
                  const horizontal = this.getNodeParameter('chartOptions.horizontal', i, false);
                  if (horizontal) {
                      chartType =
                          'horizontal' + chartType[0].toUpperCase() + chartType.substring(1, chartType.length);
                  }
              }
              let pointStyleName = 'pointStyle';
              if (constants_1.ITEM_STYLE_CHARTS.includes(chartType)) {
                  pointStyleName = 'itemStyle';
              }
              datasets.push({
                  label,
                  data,
                  backgroundColor,
                  borderColor,
                  type: chartType,
                  fill,
                  [pointStyleName]: pointStyle,
              });
          }
          const output = this.getNodeParameter('output', 0);
          const chartOptions = this.getNodeParameter('chartOptions', 0);
          const chart = {
              type: chartType,
              data: {
                  labels,
                  datasets,
              },
          };
          const options = {
              method: 'GET',
              url: 'https://quickchart.io/chart',
              qs: {
                  chart: JSON.stringify(chart),
                  ...chartOptions,
              },
              returnFullResponse: true,
              encoding: 'arraybuffer',
              json: false,
          };
          const response = (await this.helpers.httpRequest(options));
          let mimeType = response.headers['content-type'];
          mimeType = mimeType ? mimeType.split(';').find((value) => value.includes('/')) : undefined;
          return [
              [
                  {
                      binary: {
                          [output]: await this.helpers.prepareBinaryData(response.body, undefined, mimeType),
                      },
                      json: { chart },
                  },
              ],
          ];
      }
  }
  exports.QuickChart = QuickChart;
  //# sourceMappingURL=QuickChart.node.js.map

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

  # QuickChart node

  Use the QuickChart node to automate work in QuickChart, and integrate QuickChart with other applications. n8n has built-in support for a wide range of QuickChart chart types, including bar, doughnut, line, pie, and polar charts.

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

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

  ## Operations

  Create a chart by selecting the chart type:

  * Chart Type
  	* Bar Chart
  	* Doughnut Chart
  	* Line Chart
  	* Pie Chart
  	* Polar Chart

  ## Templates and examples

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

  ## Related resources

  Refer to [QuickChart's API documentation](https://quickchart.io/documentation/){:target=_blank .external-link} for more information about the service.

related_resources:
  [{"title":"QuickChart's API documentation","url":"https://quickchart.io/documentation/","type":"external"}]

example_workflow:
  {"name":"QuickChart Example Workflow","nodes":[{"parameters":{"chartType":"bar","labelsMode":"manually","labelsUi":{},"labelsArray":"example-value","data":null,"output":"data","chartOptions":{},"datasetOptions":{}},"id":"x7j0klnd72pi999syyowmq","name":"QuickChart","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"chartType":"bar","labelsMode":"manually","labelsUi":{},"labelsArray":"example-value","data":null,"output":"data","chartOptions":{},"datasetOptions":{}}

properties_schema:
  [{"displayName":"Chart Type","name":"chartType","type":"options","default":"bar","description":"The type of chart to create"},{"displayName":"Add Labels","name":"labelsMode","type":"options","default":"manually","options":[{"name":"Manually","value":"manually"},{"name":"From Array","value":"array"}]},{"displayName":"Labels","name":"labelsUi","type":"fixedCollection","default":"{","required":true,"description":"Labels to use in the chart","placeholder":"Add Label"},{"displayName":"Labels Array","name":"labelsArray","type":"string","default":"","required":true,"description":"The array of labels to be used in the chart","placeholder":"e.g. ["},{"displayName":"Data","name":"data","type":"json","default":"","required":true,"description":"Data to use for the dataset, documentation and examples <a href=","placeholder":"e.g. [60, 10, 12, 20]"},{"displayName":"Put Output In Field","name":"output","type":"string","default":"data","required":true,"description":"The binary data will be displayed in the Output panel on the right, under the Binary tab"},{"displayName":"Chart Options","name":"chartOptions","type":"collection","default":"{","description":"Background color of the chart","placeholder":"Add Option"},{"displayName":"Dataset Options","name":"datasetOptions","type":"collection","default":"{","description":"Color used for the background the dataset (area of a line graph, fill of a bar chart, etc.)","placeholder":"Add Option"}]


node_type: n8n-nodes-base.QuickBase
name: QuickBase
display_name: Quick Base
description: Integrate with the Quick Base RESTful API
category: input
icon: file:quickbase.png
code_hash: bfd2ee929fc7e48c79cc4f0913b3f3978c18ae98191cbce71e2b6c95fdc8c1c5
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.QuickBase
documentation_title: Quick Base node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"quick-base","description":"Templates for quick-base"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"field","dynamic_property":null}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickBase = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const FieldDescription_1 = require("./FieldDescription");
  const FileDescription_1 = require("./FileDescription");
  const RecordDescription_1 = require("./RecordDescription");
  const ReportDescription_1 = require("./ReportDescription");
  const utilities_1 = require("../../utils/utilities");
  class QuickBase {
      constructor() {
          this.description = {
              displayName: 'Quick Base',
              name: 'quickbase',
              icon: 'file:quickbase.png',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Integrate with the Quick Base RESTful API',
              defaults: {
                  name: 'Quick Base',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'quickbaseApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Field',
                              value: 'field',
                          },
                          {
                              name: 'File',
                              value: 'file',
                          },
                          {
                              name: 'Record',
                              value: 'record',
                          },
                          {
                              name: 'Report',
                              value: 'report',
                          },
                      ],
                      default: 'record',
                  },
                  ...FieldDescription_1.fieldOperations,
                  ...FieldDescription_1.fieldFields,
                  ...FileDescription_1.fileOperations,
                  ...FileDescription_1.fileFields,
                  ...RecordDescription_1.recordOperations,
                  ...RecordDescription_1.recordFields,
                  ...ReportDescription_1.reportOperations,
                  ...ReportDescription_1.reportFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getTableFields() {
                      const returnData = [];
                      const tableId = this.getCurrentNodeParameter('tableId');
                      const fields = await GenericFunctions_1.quickbaseApiRequest.call(this, 'GET', '/fields', {}, { tableId });
                      for (const field of fields) {
                          returnData.push({
                              name: field.label,
                              value: field.id,
                          });
                      }
                      return returnData;
                  },
                  async getUniqueTableFields() {
                      const returnData = [];
                      const tableId = this.getCurrentNodeParameter('tableId');
                      const fields = await GenericFunctions_1.quickbaseApiRequest.call(this, 'GET', '/fields', {}, { tableId });
                      for (const field of fields) {
                          if (field.unique === true && field.properties.primaryKey === false) {
                              returnData.push({
                                  name: field.label,
                                  value: field.id,
                              });
                          }
                      }
                      return returnData;
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const itemData = (0, utilities_1.generatePairedItemData)(items.length);
          const returnData = [];
          const length = items.length;
          const qs = {};
          let responseData;
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          if (resource === 'field') {
              if (operation === 'getAll') {
                  for (let i = 0; i < length; i++) {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const tableId = this.getNodeParameter('tableId', i);
                      const options = this.getNodeParameter('options', i);
                      Object.assign({
                          tableId,
                      }, options);
                      responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'GET', '/fields', {}, qs);
                      if (!returnAll) {
                          const limit = this.getNodeParameter('limit', i);
                          responseData = responseData.splice(0, limit);
                      }
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
          }
          if (resource === 'file') {
              if (operation === 'delete') {
                  for (let i = 0; i < length; i++) {
                      const tableId = this.getNodeParameter('tableId', i);
                      const recordId = this.getNodeParameter('recordId', i);
                      const fieldId = this.getNodeParameter('fieldId', i);
                      const versionNumber = this.getNodeParameter('versionNumber', i);
                      responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'DELETE', `/files/${tableId}/${recordId}/${fieldId}/${versionNumber}`);
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
              if (operation === 'download') {
                  for (let i = 0; i < length; i++) {
                      const tableId = this.getNodeParameter('tableId', i);
                      const recordId = this.getNodeParameter('recordId', i);
                      const fieldId = this.getNodeParameter('fieldId', i);
                      const versionNumber = this.getNodeParameter('versionNumber', i);
                      const newItem = {
                          json: items[i].json,
                          binary: {},
                      };
                      if (items[i].binary !== undefined) {
                          Object.assign(newItem.binary, items[i].binary);
                      }
                      items[i] = newItem;
                      const dataPropertyNameDownload = this.getNodeParameter('binaryPropertyName', i);
                      responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'GET', `/files/${tableId}/${recordId}/${fieldId}/${versionNumber}`, {}, {}, { json: false, resolveWithFullResponse: true });
                      const contentDisposition = responseData.headers['content-disposition'];
                      const data = Buffer.from(responseData.body, 'base64');
                      items[i].binary[dataPropertyNameDownload] = await this.helpers.prepareBinaryData(data, contentDisposition.split('=')[1]);
                  }
                  return [items];
              }
          }
          if (resource === 'record') {
              if (operation === 'create') {
                  const tableId = this.getNodeParameter('tableId', 0);
                  const simple = this.getNodeParameter('simple', 0);
                  const data = [];
                  const options = this.getNodeParameter('options', 0);
                  for (let i = 0; i < length; i++) {
                      const record = {};
                      const columns = this.getNodeParameter('columns', i);
                      const columnList = columns.split(',').map((column) => column.trim());
                      if (options.useFieldIDs === true) {
                          for (const key of Object.keys(items[i].json)) {
                              record[key] = { value: items[i].json[key] };
                          }
                      }
                      else {
                          const { fieldsLabelKey } = await GenericFunctions_1.getFieldsObject.call(this, tableId);
                          for (const key of Object.keys(items[i].json)) {
                              if (fieldsLabelKey.hasOwnProperty(key) && columnList.includes(key)) {
                                  record[fieldsLabelKey[key].toString()] = { value: items[i].json[key] };
                              }
                          }
                      }
                      data.push(record);
                  }
                  const body = {
                      data,
                      to: tableId,
                  };
                  body.fieldsToReturn = [3];
                  if (options.fields) {
                      body.fieldsToReturn = options.fields;
                  }
                  responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'POST', '/records', body);
                  if (simple) {
                      const { data: records } = responseData;
                      responseData = [];
                      for (const record of records) {
                          const recordData = {};
                          for (const [key, value] of Object.entries(record)) {
                              recordData[key] = value.value;
                          }
                          responseData.push(recordData);
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData });
                  returnData.push(...executionData);
              }
              if (operation === 'delete') {
                  for (let i = 0; i < length; i++) {
                      const tableId = this.getNodeParameter('tableId', i);
                      const where = this.getNodeParameter('where', i);
                      const body = {
                          from: tableId,
                          where,
                      };
                      responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'DELETE', '/records', body);
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
              if (operation === 'getAll') {
                  for (let i = 0; i < length; i++) {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const tableId = this.getNodeParameter('tableId', i);
                      const options = this.getNodeParameter('options', i);
                      const body = {
                          from: tableId,
                      };
                      Object.assign(body, options);
                      if (options.sortByUi) {
                          const sort = options.sortByUi.sortByValues;
                          body.sortBy = sort;
                          delete body.sortByUi;
                      }
                      if (returnAll) {
                          responseData = await GenericFunctions_1.quickbaseApiRequestAllItems.call(this, 'POST', '/records/query', body, qs);
                      }
                      else {
                          body.options = { top: this.getNodeParameter('limit', i) };
                          responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'POST', '/records/query', body, qs);
                          const { data: records, fields } = responseData;
                          responseData = [];
                          const fieldsIdKey = {};
                          for (const field of fields) {
                              fieldsIdKey[field.id] = field.label;
                          }
                          for (const record of records) {
                              const data = {};
                              for (const [key, value] of Object.entries(record)) {
                                  data[fieldsIdKey[key]] = value.value;
                              }
                              responseData.push(data);
                          }
                      }
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
              if (operation === 'update') {
                  const tableId = this.getNodeParameter('tableId', 0);
                  const { fieldsLabelKey: _fieldsLabelKey, fieldsIdKey } = await GenericFunctions_1.getFieldsObject.call(this, tableId);
                  const simple = this.getNodeParameter('simple', 0);
                  const updateKey = this.getNodeParameter('updateKey', 0);
                  const data = [];
                  const options = this.getNodeParameter('options', 0);
                  for (let i = 0; i < length; i++) {
                      const record = {};
                      const columns = this.getNodeParameter('columns', i);
                      const columnList = columns.split(',').map((column) => column.trim());
                      if (options.useFieldIDs === true) {
                          for (const key of Object.keys(items[i].json)) {
                              record[key] = { value: items[i].json[key] };
                          }
                      }
                      else {
                          const { fieldsLabelKey } = await GenericFunctions_1.getFieldsObject.call(this, tableId);
                          for (const key of Object.keys(items[i].json)) {
                              if (fieldsLabelKey.hasOwnProperty(key) && columnList.includes(key)) {
                                  record[fieldsLabelKey[key].toString()] = { value: items[i].json[key] };
                              }
                          }
                      }
                      if (items[i].json[updateKey] === undefined) {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The update key ${updateKey} could not be found in the input`, { itemIndex: i });
                      }
                      data.push(record);
                  }
                  const body = {
                      data,
                      to: tableId,
                  };
                  if (options.fields) {
                      body.fieldsToReturn = options.fields;
                  }
                  responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'POST', '/records', body);
                  if (simple) {
                      const { data: records } = responseData;
                      responseData = [];
                      for (const record of records) {
                          const recordData = {};
                          for (const [key, value] of Object.entries(record)) {
                              recordData[fieldsIdKey[key]] = value.value;
                          }
                          responseData.push(recordData);
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData });
                  returnData.push(...executionData);
              }
              if (operation === 'upsert') {
                  const tableId = this.getNodeParameter('tableId', 0);
                  const simple = this.getNodeParameter('simple', 0);
                  const updateKey = this.getNodeParameter('updateKey', 0);
                  const mergeFieldId = this.getNodeParameter('mergeFieldId', 0);
                  const data = [];
                  const options = this.getNodeParameter('options', 0);
                  for (let i = 0; i < length; i++) {
                      const record = {};
                      const columns = this.getNodeParameter('columns', i);
                      const columnList = columns.split(',').map((column) => column.trim());
                      if (options.useFieldIDs === true) {
                          for (const key of Object.keys(items[i].json)) {
                              record[key] = { value: items[i].json[key] };
                          }
                      }
                      else {
                          const { fieldsLabelKey } = await GenericFunctions_1.getFieldsObject.call(this, tableId);
                          for (const key of Object.keys(items[i].json)) {
                              if (fieldsLabelKey.hasOwnProperty(key) && columnList.includes(key)) {
                                  record[fieldsLabelKey[key].toString()] = { value: items[i].json[key] };
                              }
                          }
                      }
                      if (items[i].json[updateKey] === undefined) {
                          throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The update key ${updateKey} could not be found in the input`, { itemIndex: i });
                      }
                      record[mergeFieldId] = { value: items[i].json[updateKey] };
                      data.push(record);
                  }
                  const body = {
                      data,
                      to: tableId,
                      mergeFieldId,
                  };
                  body.fieldsToReturn = [3];
                  if (options.fields) {
                      body.fieldsToReturn = options.fields;
                  }
                  responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'POST', '/records', body);
                  if (simple) {
                      const { data: records } = responseData;
                      responseData = [];
                      for (const record of records) {
                          const recordData = {};
                          for (const [key, value] of Object.entries(record)) {
                              recordData[key] = value.value;
                          }
                          responseData.push(recordData);
                      }
                  }
                  const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData });
                  returnData.push(...executionData);
              }
          }
          if (resource === 'report') {
              if (operation === 'run') {
                  for (let i = 0; i < length; i++) {
                      const returnAll = this.getNodeParameter('returnAll', i);
                      const tableId = this.getNodeParameter('tableId', i);
                      const reportId = this.getNodeParameter('reportId', i);
                      qs.tableId = tableId;
                      if (returnAll) {
                          responseData = await GenericFunctions_1.quickbaseApiRequestAllItems.call(this, 'POST', `/reports/${reportId}/run`, {}, qs);
                      }
                      else {
                          qs.top = this.getNodeParameter('limit', i);
                          responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'POST', `/reports/${reportId}/run`, {}, qs);
                          const { data: records, fields } = responseData;
                          responseData = [];
                          const fieldsIdKey = {};
                          for (const field of fields) {
                              fieldsIdKey[field.id] = field.label;
                          }
                          for (const record of records) {
                              const data = {};
                              for (const [key, value] of Object.entries(record)) {
                                  data[fieldsIdKey[key]] = value.value;
                              }
                              responseData.push(data);
                          }
                      }
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
              if (operation === 'get') {
                  for (let i = 0; i < length; i++) {
                      const reportId = this.getNodeParameter('reportId', i);
                      const tableId = this.getNodeParameter('tableId', i);
                      qs.tableId = tableId;
                      responseData = await GenericFunctions_1.quickbaseApiRequest.call(this, 'GET', `/reports/${reportId}`, {}, qs);
                      const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
                      returnData.push(...executionData);
                  }
              }
          }
          return [returnData];
      }
  }
  exports.QuickBase = QuickBase;
  //# sourceMappingURL=QuickBase.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickBaseApi = void 0;
  class QuickBaseApi {
      constructor() {
          this.name = 'quickbaseApi';
          this.displayName = 'Quick Base API';
          this.documentationUrl = 'quickbase';
          this.properties = [
              {
                  displayName: 'Hostname',
                  name: 'hostname',
                  type: 'string',
                  default: '',
                  required: true,
                  placeholder: 'demo.quickbase.com',
              },
              {
                  displayName: 'User Token',
                  name: 'userToken',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
                  required: true,
              },
          ];
      }
  }
  exports.QuickBaseApi = QuickBaseApi;
  //# sourceMappingURL=QuickBaseApi.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickBaseApi = void 0;
  class QuickBaseApi {
      constructor() {
          this.name = 'quickbaseApi';
          this.displayName = 'Quick Base API';
          this.documentationUrl = 'quickbase';
          this.properties = [
              {
                  displayName: 'Hostname',
                  name: 'hostname',
                  type: 'string',
                  default: '',
                  required: true,
                  placeholder: 'demo.quickbase.com',
              },
              {
                  displayName: 'User Token',
                  name: 'userToken',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
                  required: true,
              },
          ];
      }
  }
  exports.QuickBaseApi = QuickBaseApi;
  //# sourceMappingURL=QuickBaseApi.credentials.js.map

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

  # Quick Base node

  Use the Quick Base node to automate work in Quick Base, and integrate Quick Base with other applications. n8n has built-in support for a wide range of Quick Base features, including creating, updating, deleting, and getting records, as well as getting fields, and downloading files. 

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

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

  ## Operations

  * Field
      * Get all fields
  * File
      * Delete a file
      * Download a file
  * Record
      * Create a record
      * Delete a record
      * Get all records
      * Update a record
      * Upsert a record
  * Report
      * Get a report
      * Run a report

  ## Templates and examples

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

example_workflow:
  {"name":"Quick Base Example Workflow","nodes":[{"parameters":{"resource":"field","dynamic_property":null},"id":"b1095709ugjmuklgnr77mn","name":"Quick Base","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"record","options":[{"name":"Field","value":"field"},{"name":"File","value":"file"},{"name":"Record","value":"record"},{"name":"Report","value":"report"}]},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...FieldDescription_1.fieldOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...FieldDescription_1.fieldFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...FileDescription_1.fileOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...FileDescription_1.fileFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...RecordDescription_1.recordOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...RecordDescription_1.recordFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...ReportDescription_1.reportOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...ReportDescription_1.reportFields"}]


node_type: n8n-nodes-base.QuickBooks
name: QuickBooks
display_name: QuickBooks Online
description: Consume the QuickBooks Online API
category: transform
icon: file:quickbooks.svg
code_hash: fec11a5217d27572bb5cc124a06c9011a104bab890905afe4e7c04e3abf95f7f
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.QuickBooks
documentation_title: QuickBooks Online node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"quickbooks-online","description":"Templates for quickbooks-online"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"bill","dynamic_property":null}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
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.QuickBooks = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const descriptions_1 = require("./descriptions");
  const GenericFunctions_1 = require("./GenericFunctions");
  const change_case_1 = require("change-case");
  const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
  class QuickBooks {
      constructor() {
          this.description = {
              displayName: 'QuickBooks Online',
              name: 'quickbooks',
              icon: 'file:quickbooks.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the QuickBooks Online API',
              defaults: {
                  name: 'QuickBooks Online',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'quickBooksOAuth2Api',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Bill',
                              value: 'bill',
                          },
                          {
                              name: 'Customer',
                              value: 'customer',
                          },
                          {
                              name: 'Employee',
                              value: 'employee',
                          },
                          {
                              name: 'Estimate',
                              value: 'estimate',
                          },
                          {
                              name: 'Invoice',
                              value: 'invoice',
                          },
                          {
                              name: 'Item',
                              value: 'item',
                          },
                          {
                              name: 'Payment',
                              value: 'payment',
                          },
                          {
                              name: 'Purchase',
                              value: 'purchase',
                          },
                          {
                              name: 'Transaction',
                              value: 'transaction',
                          },
                          {
                              name: 'Vendor',
                              value: 'vendor',
                          },
                      ],
                      default: 'customer',
                  },
                  ...descriptions_1.billOperations,
                  ...descriptions_1.billFields,
                  ...descriptions_1.customerOperations,
                  ...descriptions_1.customerFields,
                  ...descriptions_1.employeeOperations,
                  ...descriptions_1.employeeFields,
                  ...descriptions_1.estimateOperations,
                  ...descriptions_1.estimateFields,
                  ...descriptions_1.invoiceOperations,
                  ...descriptions_1.invoiceFields,
                  ...descriptions_1.itemOperations,
                  ...descriptions_1.itemFields,
                  ...descriptions_1.paymentOperations,
                  ...descriptions_1.paymentFields,
                  ...descriptions_1.purchaseOperations,
                  ...descriptions_1.purchaseFields,
                  ...descriptions_1.transactionOperations,
                  ...descriptions_1.transactionFields,
                  ...descriptions_1.vendorOperations,
                  ...descriptions_1.vendorFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getCustomers() {
                      return GenericFunctions_1.loadResource.call(this, 'customer');
                  },
                  async getCustomFields() {
                      return GenericFunctions_1.loadResource.call(this, 'preferences');
                  },
                  async getDepartments() {
                      return GenericFunctions_1.loadResource.call(this, 'department');
                  },
                  async getItems() {
                      return GenericFunctions_1.loadResource.call(this, 'item');
                  },
                  async getMemos() {
                      return GenericFunctions_1.loadResource.call(this, 'CreditMemo');
                  },
                  async getPurchases() {
                      return GenericFunctions_1.loadResource.call(this, 'purchase');
                  },
                  async getTaxCodeRefs() {
                      return GenericFunctions_1.loadResource.call(this, 'TaxCode');
                  },
                  async getTerms() {
                      return GenericFunctions_1.loadResource.call(this, 'Term');
                  },
                  async getVendors() {
                      return GenericFunctions_1.loadResource.call(this, 'vendor');
                  },
              },
          };
      }
      async execute() {
          const items = this.getInputData();
          const resource = this.getNodeParameter('resource', 0);
          const operation = this.getNodeParameter('operation', 0);
          let responseData;
          const returnData = [];
          const { oauthTokenData } = (await this.getCredentials('quickBooksOAuth2Api'));
          const companyId = oauthTokenData.callbackQueryString.realmId;
          for (let i = 0; i < items.length; i++) {
              try {
                  if (resource === 'bill') {
                      if (operation === 'create') {
                          const lines = this.getNodeParameter('Line', i);
                          if (!lines.length) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one line for the ${resource}.`, { itemIndex: i });
                          }
                          if (lines.some((line) => line.DetailType === undefined ||
                              line.Amount === undefined ||
                              line.Description === undefined)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter detail type, amount and description for every line.', { itemIndex: i });
                          }
                          lines.forEach((line) => {
                              if (line.DetailType === 'AccountBasedExpenseLineDetail' &&
                                  line.accountId === undefined) {
                                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter an account ID for the associated line.', { itemIndex: i });
                              }
                              else if (line.DetailType === 'ItemBasedExpenseLineDetail' &&
                                  line.itemId === undefined) {
                                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter an item ID for the associated line.', { itemIndex: i });
                              }
                          });
                          let body = {
                              VendorRef: {
                                  value: this.getNodeParameter('VendorRef', i),
                              },
                          };
                          body.Line = GenericFunctions_1.processLines.call(this, body, lines, resource);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'delete') {
                          const qs = {
                              operation: 'delete',
                          };
                          const body = {
                              Id: this.getNodeParameter('billId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const billId = this.getNodeParameter('billId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${billId}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'update') {
                          const { ref, syncToken } = await GenericFunctions_1.getRefAndSyncToken.call(this, i, companyId, resource, 'VendorRef');
                          let body = {
                              Id: this.getNodeParameter('billId', i),
                              SyncToken: syncToken,
                              sparse: true,
                              VendorRef: {
                                  name: ref.name,
                                  value: ref.value,
                              },
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'customer') {
                      if (operation === 'create') {
                          let body = {
                              DisplayName: this.getNodeParameter('displayName', i),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const customerId = this.getNodeParameter('customerId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${customerId}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'update') {
                          let body = {
                              Id: this.getNodeParameter('customerId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                              sparse: true,
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'employee') {
                      if (operation === 'create') {
                          let body = {
                              FamilyName: this.getNodeParameter('FamilyName', i),
                              GivenName: this.getNodeParameter('GivenName', i),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const employeeId = this.getNodeParameter('employeeId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${employeeId}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'update') {
                          let body = {
                              Id: this.getNodeParameter('employeeId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                              sparse: true,
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'estimate') {
                      if (operation === 'create') {
                          const lines = this.getNodeParameter('Line', i);
                          if (!lines.length) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one line for the ${resource}.`, { itemIndex: i });
                          }
                          if (lines.some((line) => line.DetailType === undefined ||
                              line.Amount === undefined ||
                              line.Description === undefined)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter detail type, amount and description for every line.', { itemIndex: i });
                          }
                          lines.forEach((line) => {
                              if (line.DetailType === 'SalesItemLineDetail' && line.itemId === undefined) {
                                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter an item ID for the associated line.', { itemIndex: i });
                              }
                          });
                          let body = {
                              CustomerRef: {
                                  value: this.getNodeParameter('CustomerRef', i),
                              },
                          };
                          body.Line = GenericFunctions_1.processLines.call(this, body, lines, resource);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'delete') {
                          const qs = {
                              operation: 'delete',
                          };
                          const body = {
                              Id: this.getNodeParameter('estimateId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const estimateId = this.getNodeParameter('estimateId', i);
                          const download = this.getNodeParameter('download', i);
                          if (download) {
                              responseData = await GenericFunctions_1.handleBinaryData.call(this, items, i, companyId, resource, estimateId);
                          }
                          else {
                              const endpoint = `/v3/company/${companyId}/${resource}/${estimateId}`;
                              responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                              responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                          }
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'send') {
                          const estimateId = this.getNodeParameter('estimateId', i);
                          const qs = {
                              sendTo: this.getNodeParameter('email', i),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}/${estimateId}/send`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'update') {
                          const { ref, syncToken } = await GenericFunctions_1.getRefAndSyncToken.call(this, i, companyId, resource, 'CustomerRef');
                          let body = {
                              Id: this.getNodeParameter('estimateId', i),
                              SyncToken: syncToken,
                              sparse: true,
                              CustomerRef: {
                                  name: ref.name,
                                  value: ref.value,
                              },
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'invoice') {
                      if (operation === 'create') {
                          const lines = this.getNodeParameter('Line', i);
                          if (!lines.length) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one line for the ${resource}.`, { itemIndex: i });
                          }
                          if (lines.some((line) => line.DetailType === undefined ||
                              line.Amount === undefined ||
                              line.Description === undefined)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter detail type, amount and description for every line.', { itemIndex: i });
                          }
                          lines.forEach((line) => {
                              if (line.DetailType === 'SalesItemLineDetail' && line.itemId === undefined) {
                                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Please enter an item ID for the associated line.', { itemIndex: i });
                              }
                          });
                          let body = {
                              CustomerRef: {
                                  value: this.getNodeParameter('CustomerRef', i),
                              },
                          };
                          body.Line = GenericFunctions_1.processLines.call(this, body, lines, resource);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'delete') {
                          const qs = {
                              operation: 'delete',
                          };
                          const body = {
                              Id: this.getNodeParameter('invoiceId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const invoiceId = this.getNodeParameter('invoiceId', i);
                          const download = this.getNodeParameter('download', i);
                          if (download) {
                              responseData = await GenericFunctions_1.handleBinaryData.call(this, items, i, companyId, resource, invoiceId);
                          }
                          else {
                              const endpoint = `/v3/company/${companyId}/${resource}/${invoiceId}`;
                              responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                              responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                          }
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'send') {
                          const invoiceId = this.getNodeParameter('invoiceId', i);
                          const qs = {
                              sendTo: this.getNodeParameter('email', i),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}/${invoiceId}/send`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'update') {
                          const { ref, syncToken } = await GenericFunctions_1.getRefAndSyncToken.call(this, i, companyId, resource, 'CustomerRef');
                          let body = {
                              Id: this.getNodeParameter('invoiceId', i),
                              SyncToken: syncToken,
                              sparse: true,
                              CustomerRef: {
                                  name: ref.name,
                                  value: ref.value,
                              },
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'void') {
                          const qs = {
                              Id: this.getNodeParameter('invoiceId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                              operation: 'void',
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'item') {
                      if (operation === 'get') {
                          const item = this.getNodeParameter('itemId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${item}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                  }
                  else if (resource === 'payment') {
                      if (operation === 'create') {
                          let body = {
                              CustomerRef: {
                                  value: this.getNodeParameter('CustomerRef', i),
                              },
                              TotalAmt: this.getNodeParameter('TotalAmt', i),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'delete') {
                          const qs = {
                              operation: 'delete',
                          };
                          const body = {
                              Id: this.getNodeParameter('paymentId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const paymentId = this.getNodeParameter('paymentId', i);
                          const download = this.getNodeParameter('download', i);
                          if (download) {
                              responseData = await GenericFunctions_1.handleBinaryData.call(this, items, i, companyId, resource, paymentId);
                          }
                          else {
                              const endpoint = `/v3/company/${companyId}/${resource}/${paymentId}`;
                              responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                              responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                          }
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'send') {
                          const paymentId = this.getNodeParameter('paymentId', i);
                          const qs = {
                              sendTo: this.getNodeParameter('email', i),
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}/${paymentId}/send`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'update') {
                          const { ref, syncToken } = await GenericFunctions_1.getRefAndSyncToken.call(this, i, companyId, resource, 'CustomerRef');
                          let body = {
                              Id: this.getNodeParameter('paymentId', i),
                              SyncToken: syncToken,
                              sparse: true,
                              CustomerRef: {
                                  name: ref.name,
                                  value: ref.value,
                              },
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'void') {
                          const qs = {
                              Id: this.getNodeParameter('paymentId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                              operation: 'void',
                          };
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, qs, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
                  else if (resource === 'purchase') {
                      if (operation === 'get') {
                          const purchaseId = this.getNodeParameter('purchaseId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${purchaseId}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                  }
                  else if (resource === 'transaction') {
                      if (operation === 'getReport') {
                          const { columns, memo, term, customer, vendor, ...rest } = this.getNodeParameter('filters', i);
                          let qs = { ...rest };
                          if (columns === null || columns === void 0 ? void 0 : columns.length) {
                              qs.columns = columns.join(',');
                          }
                          if (memo === null || memo === void 0 ? void 0 : memo.length) {
                              qs.memo = memo.join(',');
                          }
                          if (term === null || term === void 0 ? void 0 : term.length) {
                              qs.term = term.join(',');
                          }
                          if (customer === null || customer === void 0 ? void 0 : customer.length) {
                              qs.customer = customer.join(',');
                          }
                          if (vendor === null || vendor === void 0 ? void 0 : vendor.length) {
                              qs.vendor = vendor.join(',');
                          }
                          qs = (0, GenericFunctions_1.adjustTransactionDates)(qs);
                          const endpoint = `/v3/company/${companyId}/reports/TransactionList`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, qs, {});
                          const simplifyResponse = this.getNodeParameter('simple', i, true);
                          if (!Object.keys(responseData === null || responseData === void 0 ? void 0 : responseData.Rows).length) {
                              responseData = [];
                          }
                          if (simplifyResponse && !Array.isArray(responseData)) {
                              responseData = (0, GenericFunctions_1.simplifyTransactionReport)(responseData);
                          }
                      }
                  }
                  else if (resource === 'vendor') {
                      if (operation === 'create') {
                          let body = {
                              DisplayName: this.getNodeParameter('displayName', i),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          body = GenericFunctions_1.populateFields.call(this, body, additionalFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'get') {
                          const vendorId = this.getNodeParameter('vendorId', i);
                          const endpoint = `/v3/company/${companyId}/${resource}/${vendorId}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                      else if (operation === 'getAll') {
                          const endpoint = `/v3/company/${companyId}/query`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, resource);
                      }
                      else if (operation === 'update') {
                          let body = {
                              Id: this.getNodeParameter('vendorId', i),
                              SyncToken: await GenericFunctions_1.getSyncToken.call(this, i, companyId, resource),
                              sparse: true,
                          };
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          body = GenericFunctions_1.populateFields.call(this, body, updateFields, resource);
                          const endpoint = `/v3/company/${companyId}/${resource}`;
                          responseData = await GenericFunctions_1.quickBooksApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData[(0, change_case_1.capitalCase)(resource)];
                      }
                  }
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      const download = this.getNodeParameter('download', 0, false);
                      if (['invoice', 'estimate', 'payment'].includes(resource) &&
                          ['get'].includes(operation) &&
                          download) {
                          if (!responseData) {
                              items[i].json = { error: error.message };
                              responseData = items;
                          }
                          else {
                              responseData[i].json = { error: error.message };
                          }
                      }
                      else {
                          const executionErrorData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
                          returnData.push(...executionErrorData);
                      }
                      continue;
                  }
                  throw error;
              }
              const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
              returnData.push(...executionData);
          }
          const download = this.getNodeParameter('download', 0, false);
          if (['invoice', 'estimate', 'payment'].includes(resource) &&
              ['get'].includes(operation) &&
              download) {
              return [responseData];
          }
          else {
              return [returnData];
          }
      }
  }
  exports.QuickBooks = QuickBooks;
  //# sourceMappingURL=QuickBooks.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickBooksOAuth2Api = void 0;
  class QuickBooksOAuth2Api {
      constructor() {
          this.name = 'quickBooksOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'QuickBooks Online OAuth2 API';
          this.documentationUrl = 'quickbooks';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://appcenter.intuit.com/connect/oauth2',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: 'com.intuit.quickbooks.accounting',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'header',
              },
              {
                  displayName: 'Environment',
                  name: 'environment',
                  type: 'options',
                  default: 'production',
                  options: [
                      {
                          name: 'Production',
                          value: 'production',
                      },
                      {
                          name: 'Sandbox',
                          value: 'sandbox',
                      },
                  ],
              },
          ];
      }
  }
  exports.QuickBooksOAuth2Api = QuickBooksOAuth2Api;
  //# sourceMappingURL=QuickBooksOAuth2Api.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.QuickBooksOAuth2Api = void 0;
  class QuickBooksOAuth2Api {
      constructor() {
          this.name = 'quickBooksOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'QuickBooks Online OAuth2 API';
          this.documentationUrl = 'quickbooks';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://appcenter.intuit.com/connect/oauth2',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: 'com.intuit.quickbooks.accounting',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'header',
              },
              {
                  displayName: 'Environment',
                  name: 'environment',
                  type: 'options',
                  default: 'production',
                  options: [
                      {
                          name: 'Production',
                          value: 'production',
                      },
                      {
                          name: 'Sandbox',
                          value: 'sandbox',
                      },
                  ],
              },
          ];
      }
  }
  exports.QuickBooksOAuth2Api = QuickBooksOAuth2Api;
  //# sourceMappingURL=QuickBooksOAuth2Api.credentials.js.map

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

  # QuickBooks Online node

  Use the QuickBooks node to automate work in QuickBooks, and integrate QuickBooks with other applications. n8n has built-in support for a wide range of QuickBooks features, including creating, updating, deleting, and getting bills, customers, employees, estimates, and invoices. 

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

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

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

  ## Operations

  * Bill
      * Create
      * Delete
      * Get
      * Get All
      * Update
  * Customer
      * Create
      * Get
      * Get All
      * Update
  * Employee
      * Create
      * Get
      * Get All
      * Update
  * Estimate
      * Create
      * Delete
      * Get
      * Get All
      * Send
      * Update
  * Invoice
      * Create
      * Delete
      * Get
      * Get All
      * Send
      * Update
      * Void
  * Item
      * Get
      * Get All
  * Payment
      * Create
      * Delete
      * Get
      * Get All
      * Send
      * Update
      * Void
  * Purchase
      * Get
      * Get All
  * Transaction
      * Get Report
  * Vendor
      * Create
      * Get
      * Get All
      * Update

  ## Templates and examples

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

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

example_workflow:
  {"name":"QuickBooks Online Example Workflow","nodes":[{"parameters":{"resource":"bill","dynamic_property":null},"id":"2hh0zeitu9q7s8nc6wdbip","name":"QuickBooks Online","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"customer","options":[{"name":"Bill","value":"bill"},{"name":"Customer","value":"customer"},{"name":"Employee","value":"employee"},{"name":"Estimate","value":"estimate"},{"name":"Invoice","value":"invoice"},{"name":"Item","value":"item"},{"name":"Payment","value":"payment"},{"name":"Purchase","value":"purchase"},{"name":"Transaction","value":"transaction"},{"name":"Vendor","value":"vendor"}]},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.billOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.billFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.customerOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.customerFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.employeeOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.employeeFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.estimateOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.estimateFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.invoiceOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.invoiceFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.itemOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.itemFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.paymentOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.paymentFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.purchaseOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.purchaseFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.transactionOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.transactionFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.vendorOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.vendorFields"}]


node_type: n8n-nodes-base.Raindrop
name: Raindrop
display_name: Raindrop
description: Consume the Raindrop API
category: transform
icon: file:raindrop.svg
code_hash: 2ffff5f78e6186206cef24c5dd2e380afdbdc2f5402ccc15b45f49cb45ac263e
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Raindrop
documentation_title: Raindrop node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"raindrop","description":"Templates for raindrop"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"bookmark","dynamic_property":null}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
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.Raindrop = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
  const omit_1 = __importDefault(require("lodash/omit"));
  const GenericFunctions_1 = require("./GenericFunctions");
  const descriptions_1 = require("./descriptions");
  class Raindrop {
      constructor() {
          this.description = {
              displayName: 'Raindrop',
              name: 'raindrop',
              icon: 'file:raindrop.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the Raindrop API',
              defaults: {
                  name: 'Raindrop',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'raindropOAuth2Api',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Bookmark',
                              value: 'bookmark',
                          },
                          {
                              name: 'Collection',
                              value: 'collection',
                          },
                          {
                              name: 'Tag',
                              value: 'tag',
                          },
                          {
                              name: 'User',
                              value: 'user',
                          },
                      ],
                      default: 'collection',
                  },
                  ...descriptions_1.bookmarkOperations,
                  ...descriptions_1.bookmarkFields,
                  ...descriptions_1.collectionOperations,
                  ...descriptions_1.collectionFields,
                  ...descriptions_1.tagOperations,
                  ...descriptions_1.tagFields,
                  ...descriptions_1.userOperations,
                  ...descriptions_1.userFields,
              ],
          };
          this.methods = {
              loadOptions: {
                  async getCollections() {
                      const responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', '/collections', {}, {});
                      return responseData.items.map((item) => ({
                          name: item.title,
                          value: item._id,
                      }));
                  },
              },
          };
      }
      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 === 'bookmark') {
                      if (operation === 'create') {
                          const body = {
                              link: this.getNodeParameter('link', i),
                              collection: {
                                  $id: this.getNodeParameter('collectionId', i),
                              },
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          if (!(0, isEmpty_1.default)(additionalFields)) {
                              Object.assign(body, additionalFields);
                          }
                          if (additionalFields.pleaseParse === true) {
                              body.pleaseParse = {};
                              delete additionalFields.pleaseParse;
                          }
                          if (additionalFields.tags) {
                              body.tags = additionalFields.tags.split(',').map((tag) => tag.trim());
                          }
                          const endpoint = '/raindrop';
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'POST', endpoint, {}, body);
                          responseData = responseData.item;
                      }
                      else if (operation === 'delete') {
                          const bookmarkId = this.getNodeParameter('bookmarkId', i);
                          const endpoint = `/raindrop/${bookmarkId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'DELETE', endpoint, {}, {});
                      }
                      else if (operation === 'get') {
                          const bookmarkId = this.getNodeParameter('bookmarkId', i);
                          const endpoint = `/raindrop/${bookmarkId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.item;
                      }
                      else if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const endpoint = `/raindrops/${collectionId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.items;
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', 0);
                              responseData = responseData.slice(0, limit);
                          }
                      }
                      else if (operation === 'update') {
                          const bookmarkId = this.getNodeParameter('bookmarkId', i);
                          const body = {};
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          Object.assign(body, updateFields);
                          if (updateFields.collectionId) {
                              body.collection = {
                                  $id: updateFields.collectionId,
                              };
                              delete updateFields.collectionId;
                          }
                          if (updateFields.pleaseParse === true) {
                              body.pleaseParse = {};
                              delete updateFields.pleaseParse;
                          }
                          if (updateFields.tags) {
                              body.tags = updateFields.tags.split(',').map((tag) => tag.trim());
                          }
                          const endpoint = `/raindrop/${bookmarkId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'PUT', endpoint, {}, body);
                          responseData = responseData.item;
                      }
                  }
                  else if (resource === 'collection') {
                      if (operation === 'create') {
                          const body = {
                              title: this.getNodeParameter('title', i),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          if (!(0, isEmpty_1.default)(additionalFields)) {
                              Object.assign(body, additionalFields);
                          }
                          if (additionalFields.cover) {
                              body.cover = [body.cover];
                          }
                          if (additionalFields.parentId) {
                              body['parent.$id'] = parseInt(additionalFields.parentId, 10);
                              delete additionalFields.parentId;
                          }
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'POST', '/collection', {}, body);
                          responseData = responseData.item;
                      }
                      else if (operation === 'delete') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const endpoint = `/collection/${collectionId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'DELETE', endpoint, {}, {});
                      }
                      else if (operation === 'get') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const endpoint = `/collection/${collectionId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.item;
                      }
                      else if (operation === 'getAll') {
                          const returnAll = this.getNodeParameter('returnAll', 0);
                          const endpoint = this.getNodeParameter('type', i) === 'parent'
                              ? '/collections'
                              : '/collections/childrens';
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.items;
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', 0);
                              responseData = responseData.slice(0, limit);
                          }
                      }
                      else if (operation === 'update') {
                          const collectionId = this.getNodeParameter('collectionId', i);
                          const body = {};
                          const updateFields = this.getNodeParameter('updateFields', i);
                          if ((0, isEmpty_1.default)(updateFields)) {
                              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Please enter at least one field to update for the ${resource}.`, { itemIndex: i });
                          }
                          if (updateFields.parentId) {
                              body['parent.$id'] = parseInt(updateFields.parentId, 10);
                              delete updateFields.parentId;
                          }
                          Object.assign(body, (0, omit_1.default)(updateFields, 'binaryPropertyName'));
                          const endpoint = `/collection/${collectionId}`;
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'PUT', endpoint, {}, body);
                          responseData = responseData.item;
                          if (updateFields.cover) {
                              const binaryPropertyName = updateFields.cover;
                              const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
                              const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
                              const formData = {
                                  cover: {
                                      value: dataBuffer,
                                      options: {
                                          filename: binaryData.fileName,
                                          contentType: binaryData.mimeType,
                                      },
                                  },
                              };
                              const requestEndpoint = `/collection/${collectionId}/cover`;
                              responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'PUT', requestEndpoint, {}, {}, { 'Content-Type': 'multipart/form-data', formData });
                              responseData = responseData.item;
                          }
                      }
                  }
                  else if (resource === 'user') {
                      if (operation === 'get') {
                          const self = this.getNodeParameter('self', i);
                          let endpoint = '/user';
                          if (self === false) {
                              const userId = this.getNodeParameter('userId', i);
                              endpoint += `/${userId}`;
                          }
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.user;
                      }
                  }
                  else if (resource === 'tag') {
                      if (operation === 'delete') {
                          let endpoint = '/tags';
                          const body = {
                              tags: this.getNodeParameter('tags', i).split(','),
                          };
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          if (additionalFields.collectionId) {
                              endpoint += `/${additionalFields.collectionId}`;
                          }
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'DELETE', endpoint, {}, body);
                      }
                      else if (operation === 'getAll') {
                          let endpoint = '/tags';
                          const returnAll = this.getNodeParameter('returnAll', i);
                          const filter = this.getNodeParameter('filters', i);
                          if (filter.collectionId) {
                              endpoint += `/${filter.collectionId}`;
                          }
                          responseData = await GenericFunctions_1.raindropApiRequest.call(this, 'GET', endpoint, {}, {});
                          responseData = responseData.items;
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', 0);
                              responseData = responseData.slice(0, limit);
                          }
                      }
                  }
                  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.Raindrop = Raindrop;
  //# sourceMappingURL=Raindrop.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RaindropOAuth2Api = void 0;
  class RaindropOAuth2Api {
      constructor() {
          this.name = 'raindropOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Raindrop OAuth2 API';
          this.documentationUrl = 'raindrop';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://raindrop.io/oauth/authorize',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://api.raindrop.io/v1/oauth/access_token',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'body',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: '',
              },
          ];
      }
  }
  exports.RaindropOAuth2Api = RaindropOAuth2Api;
  //# sourceMappingURL=RaindropOAuth2Api.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RaindropOAuth2Api = void 0;
  class RaindropOAuth2Api {
      constructor() {
          this.name = 'raindropOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Raindrop OAuth2 API';
          this.documentationUrl = 'raindrop';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://raindrop.io/oauth/authorize',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://api.raindrop.io/v1/oauth/access_token',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: '',
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'body',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: '',
              },
          ];
      }
  }
  exports.RaindropOAuth2Api = RaindropOAuth2Api;
  //# sourceMappingURL=RaindropOAuth2Api.credentials.js.map

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

  # Raindrop node

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

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

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

  ## Operations

  * Bookmark
      * Create
      * Delete
      * Get
      * Get All
      * Update
  * Collection
      * Create
      * Delete
      * Get
      * Get All
      * Update
  * Tag
      * Delete
      * Get All
  * User
      * Get

  ## Templates and examples

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

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

example_workflow:
  {"name":"Raindrop Example Workflow","nodes":[{"parameters":{"resource":"bookmark","dynamic_property":null},"id":"pq8w18090wbsoye5sh92ml","name":"Raindrop","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"collection","options":[{"name":"Bookmark","value":"bookmark"},{"name":"Collection","value":"collection"},{"name":"Tag","value":"tag"},{"name":"User","value":"user"}]},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.bookmarkOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.bookmarkFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.collectionOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.collectionFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.tagOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.tagFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.userOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...descriptions_1.userFields"}]


node_type: n8n-nodes-base.ReadBinaryFile
name: ReadBinaryFile
display_name: Read Binary File
description: Reads a binary file from disk
category: input
icon: fa:file-import
code_hash: b25d91d1c599335bb399ef8f8b87952ebc8706ed057404aa453696513fd035f2
example_parameters: {"filePath":"example-value","dataPropertyName":"Example Name"}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.ReadBinaryFile = void 0;
  class ReadBinaryFile {
      constructor() {
          this.description = {
              displayName: 'Read Binary File',
              name: 'readBinaryFile',
              icon: 'fa:file-import',
              group: ['input'],
              version: 1,
              hidden: true,
              description: 'Reads a binary file from disk',
              defaults: {
                  name: 'Read Binary File',
                  color: '#449922',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'File Path',
                      name: 'filePath',
                      type: 'string',
                      default: '',
                      required: true,
                      placeholder: '/data/example.jpg',
                      description: 'Path of the file to read',
                  },
                  {
                      displayName: 'Property Name',
                      name: 'dataPropertyName',
                      type: 'string',
                      default: 'data',
                      required: true,
                      description: 'Name of the binary property to which to write the data of the read file',
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          let item;
          for (let itemIndex = 0; itemIndex < length; itemIndex++) {
              try {
                  item = items[itemIndex];
                  const newItem = {
                      json: item.json,
                      binary: {},
                      pairedItem: {
                          item: itemIndex,
                      },
                  };
                  if (item.binary !== undefined && newItem.binary) {
                      Object.assign(newItem.binary, item.binary);
                  }
                  const filePath = this.getNodeParameter('filePath', itemIndex);
                  const stream = await this.helpers.createReadStream(filePath);
                  const dataPropertyName = this.getNodeParameter('dataPropertyName', itemIndex);
                  newItem.binary[dataPropertyName] = await this.helpers.prepareBinaryData(stream, filePath);
                  returnData.push(newItem);
              }
              catch (error) {
                  if (this.continueOnFail()) {
                      returnData.push({
                          json: {
                              error: error.message,
                          },
                          pairedItem: {
                              item: itemIndex,
                          },
                      });
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.ReadBinaryFile = ReadBinaryFile;
  //# sourceMappingURL=ReadBinaryFile.node.js.map

example_workflow:
  {"name":"Read Binary File Example Workflow","nodes":[{"parameters":{"filePath":"example-value","dataPropertyName":"Example Name"},"id":"l9fog08ryvas4lbnedf87","name":"Read Binary File","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"File Path","name":"filePath","type":"string","default":"","required":true,"description":"Path of the file to read","placeholder":"/data/example.jpg"},{"displayName":"Property Name","name":"dataPropertyName","type":"string","default":"data","required":true,"description":"Name of the binary property to which to write the data of the read file"}]


node_type: n8n-nodes-base.Pushover
name: Pushover
display_name: Pushover
description: Consume Pushover API
category: input
icon: file:pushover.svg
code_hash: 3a7a4089c5eeea56b94fe3d78b95dbf850e3eefb49b2255fd9e6a6a4de9cf4a9
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Pushover
documentation_title: Pushover node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"pushover","description":"Templates for pushover"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Pushover = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  class Pushover {
      constructor() {
          this.description = {
              displayName: 'Pushover',
              name: 'pushover',
              icon: 'file:pushover.svg',
              group: ['input'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume Pushover API',
              defaults: {
                  name: 'Pushover',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'pushoverApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Message',
                              value: 'message',
                          },
                      ],
                      default: 'message',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                          },
                      },
                      options: [
                          {
                              name: 'Push',
                              value: 'push',
                              action: 'Push a message',
                          },
                      ],
                      default: 'push',
                  },
                  {
                      displayName: 'User Key',
                      name: 'userKey',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                          },
                      },
                      default: '',
                      description: 'The user/group key (not e-mail address) of your user (or you), viewable when logged into the <a href="https://pushover.net/">dashboard</a> (often referred to as <code>USER_KEY</code> in the <a href="https://support.pushover.net/i44-example-code-and-pushover-libraries">libraries</a> and code examples)',
                  },
                  {
                      displayName: 'Message',
                      name: 'message',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                          },
                      },
                      default: '',
                      description: 'Your message',
                  },
                  {
                      displayName: 'Priority',
                      name: 'priority',
                      type: 'options',
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                          },
                      },
                      options: [
                          {
                              name: 'Lowest Priority',
                              value: -2,
                          },
                          {
                              name: 'Low Priority',
                              value: -1,
                          },
                          {
                              name: 'Normal Priority',
                              value: 0,
                          },
                          {
                              name: 'High Priority',
                              value: 1,
                          },
                          {
                              name: 'Emergency Priority',
                              value: 2,
                          },
                      ],
                      default: -2,
                      description: "Send as -2 to generate no notification/alert, -1 to always send as a quiet notification, 1 to display as high-priority and bypass the user's quiet hours, or 2 to also require confirmation from the user",
                  },
                  {
                      displayName: 'Retry (Seconds)',
                      name: 'retry',
                      type: 'number',
                      typeOptions: {
                          minValue: 0,
                      },
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                              priority: [2],
                          },
                      },
                      default: 30,
                      description: 'Specifies how often (in seconds) the Pushover servers will send the same notification to the user. This parameter must have a value of at least 30 seconds between retries.',
                  },
                  {
                      displayName: 'Expire (Seconds)',
                      name: 'expire',
                      type: 'number',
                      typeOptions: {
                          minValue: 0,
                          maxValue: 10800,
                      },
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                              priority: [2],
                          },
                      },
                      default: 30,
                      description: 'Specifies how many seconds your notification will continue to be retried for (every retry seconds)',
                  },
                  {
                      displayName: 'Additional Fields',
                      name: 'additionalFields',
                      type: 'collection',
                      placeholder: 'Add Field',
                      displayOptions: {
                          show: {
                              resource: ['message'],
                              operation: ['push'],
                          },
                      },
                      default: {},
                      options: [
                          {
                              displayName: 'Attachment',
                              name: 'attachmentsUi',
                              placeholder: 'Add Attachments',
                              type: 'fixedCollection',
                              typeOptions: {
                                  multipleValues: false,
                              },
                              options: [
                                  {
                                      name: 'attachmentsValues',
                                      displayName: 'Attachment Property',
                                      values: [
                                          {
                                              displayName: 'Binary Property',
                                              name: 'binaryPropertyName',
                                              type: 'string',
                                              default: '',
                                              placeholder: 'data',
                                              description: 'Name of the binary properties which contain data which should be added to email as attachment',
                                          },
                                      ],
                                  },
                              ],
                              default: {},
                          },
                          {
                              displayName: 'Device',
                              name: 'device',
                              type: 'string',
                              default: '',
                              description: "Your user's device name to send the message directly to that device, rather than all of the user's devices (multiple devices may be separated by a comma)",
                          },
                          {
                              displayName: 'HTML Formatting',
                              name: 'html',
                              type: 'boolean',
                              default: false,
                              description: 'Whether to enable messages formatting with HTML tags',
                          },
                          {
                              displayName: 'Sound Name or ID',
                              name: 'sound',
                              type: 'options',
                              typeOptions: {
                                  loadOptionsMethod: 'getSounds',
                              },
                              default: '',
                              description: 'The name of one of the sounds supported by device clients to override the user\'s default sound choice. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code-examples/expressions/">expression</a>.',
                          },
                          {
                              displayName: 'Timestamp',
                              name: 'timestamp',
                              type: 'dateTime',
                              default: '',
                              description: "A Unix timestamp of your message's date and time to display to the user, rather than the time your message is received by our API",
                          },
                          {
                              displayName: 'Title',
                              name: 'title',
                              type: 'string',
                              default: '',
                              description: "Your message's title, otherwise your app's name is used",
                          },
                          {
                              displayName: 'Timestamp',
                              name: 'timestamp',
                              type: 'dateTime',
                              default: '',
                              description: "A Unix timestamp of your message's date and time to display to the user, rather than the time your message is received by our API",
                          },
                          {
                              displayName: 'URL',
                              name: 'url',
                              type: 'string',
                              default: '',
                              description: 'A supplementary URL to show with your message',
                          },
                          {
                              displayName: 'URL Title',
                              name: 'url_title',
                              type: 'string',
                              default: '',
                              description: 'A title for your supplementary URL, otherwise just the URL is shown',
                          },
                      ],
                  },
              ],
          };
          this.methods = {
              loadOptions: {
                  async getSounds() {
                      const { sounds } = await GenericFunctions_1.pushoverApiRequest.call(this, 'GET', '/sounds.json', {});
                      const returnData = [];
                      for (const key of Object.keys(sounds)) {
                          returnData.push({
                              name: sounds[key],
                              value: key,
                          });
                      }
                      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++) {
              try {
                  if (resource === 'message') {
                      if (operation === 'push') {
                          const userKey = this.getNodeParameter('userKey', i);
                          const message = this.getNodeParameter('message', i);
                          const priority = this.getNodeParameter('priority', i);
                          const additionalFields = this.getNodeParameter('additionalFields', i);
                          if (additionalFields.html !== undefined) {
                              additionalFields.html = additionalFields.html ? '1' : '';
                          }
                          const body = {
                              user: userKey,
                              message,
                              priority,
                          };
                          if (priority === 2) {
                              body.retry = this.getNodeParameter('retry', i);
                              body.expire = this.getNodeParameter('expire', i);
                          }
                          Object.assign(body, additionalFields);
                          if (body.attachmentsUi) {
                              const attachment = body.attachmentsUi
                                  .attachmentsValues;
                              if (attachment) {
                                  const binaryPropertyName = attachment.binaryPropertyName;
                                  const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
                                  const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
                                  body.attachment = {
                                      value: dataBuffer,
                                      options: {
                                          filename: binaryData.fileName,
                                      },
                                  };
                                  delete body.attachmentsUi;
                              }
                          }
                          responseData = await GenericFunctions_1.pushoverApiRequest.call(this, 'POST', '/messages.json', body);
                          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.Pushover = Pushover;
  //# sourceMappingURL=Pushover.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushoverApi = void 0;
  class PushoverApi {
      constructor() {
          this.name = 'pushoverApi';
          this.displayName = 'Pushover API';
          this.documentationUrl = 'pushover';
          this.properties = [
              {
                  displayName: 'API Key',
                  name: 'apiKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
          this.test = {
              request: {
                  baseURL: 'https://api.pushover.net/1',
                  url: '=/licenses.json?token={{$credentials?.apiKey}}',
                  method: 'GET',
              },
          };
      }
      async authenticate(credentials, requestOptions) {
          if (requestOptions.method === 'GET' && requestOptions.qs) {
              Object.assign(requestOptions.qs, { token: credentials.apiKey });
          }
          else if (requestOptions.body) {
              Object.assign(requestOptions.body, { token: credentials.apiKey });
          }
          return requestOptions;
      }
  }
  exports.PushoverApi = PushoverApi;
  //# sourceMappingURL=PushoverApi.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.PushoverApi = void 0;
  class PushoverApi {
      constructor() {
          this.name = 'pushoverApi';
          this.displayName = 'Pushover API';
          this.documentationUrl = 'pushover';
          this.properties = [
              {
                  displayName: 'API Key',
                  name: 'apiKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
          ];
          this.test = {
              request: {
                  baseURL: 'https://api.pushover.net/1',
                  url: '=/licenses.json?token={{$credentials?.apiKey}}',
                  method: 'GET',
              },
          };
      }
      async authenticate(credentials, requestOptions) {
          if (requestOptions.method === 'GET' && requestOptions.qs) {
              Object.assign(requestOptions.qs, { token: credentials.apiKey });
          }
          else if (requestOptions.body) {
              Object.assign(requestOptions.body, { token: credentials.apiKey });
          }
          return requestOptions;
      }
  }
  exports.PushoverApi = PushoverApi;
  //# sourceMappingURL=PushoverApi.credentials.js.map

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

  # Pushover node

  Use the Pushover node to automate work in Pushover, and integrate Pushover with other applications. n8n supports sending push notifications with Pushover.

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

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

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

  ## Operations

  * Message
      * Push

  ## Templates and examples

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

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

example_workflow:
  {"name":"Pushover Example Workflow","nodes":[{"parameters":{"resource":"message","operation":"push","userKey":"example-value","message":"example-value","retry":30,"expire":30,"additionalFields":{}},"id":"ogadqcyliyhyypu0xvn3lg","name":"Pushover","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"resource":"message","operation":"push","userKey":"example-value","message":"example-value","retry":30,"expire":30,"additionalFields":{}}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"message","options":[{"name":"Message","value":"message"}]},{"displayName":"Operation","name":"operation","type":"options","default":"push","options":[{"name":"Push","value":"push"}]},{"displayName":"User Key","name":"userKey","type":"string","default":"","required":true,"description":"The user/group key (not e-mail address) of your user (or you), viewable when logged into the <a href="},{"displayName":"Message","name":"message","type":"string","default":"","required":true,"description":"Your message"},{"displayName":"Priority","name":"priority","type":"options","default":-2,"description":"Send as -2 to generate no notification/alert, -1 to always send as a quiet notification, 1 to display as high-priority and bypass the user","options":[{"name":"Lowest Priority"},{"name":"Low Priority"},{"name":"Normal Priority"},{"name":"High Priority"},{"name":"Emergency Priority"}]},{"displayName":"Retry (Seconds)","name":"retry","type":"number","default":30,"required":true,"description":"Specifies how often (in seconds) the Pushover servers will send the same notification to the user. This parameter must have a value of at least 30 seconds between retries."},{"displayName":"Expire (Seconds)","name":"expire","type":"number","default":30,"required":true,"description":"Specifies how many seconds your notification will continue to be retried for (every retry seconds)"},{"displayName":"Additional Fields","name":"additionalFields","type":"collection","default":"{","description":"Name of the binary properties which contain data which should be added to email as attachment","placeholder":"Add Field"}]


node_type: n8n-nodes-base.RabbitMQ
name: RabbitMQ
display_name: RabbitMQ
description: Sends messages to a RabbitMQ topic
category: transform
icon: file:rabbitmq.png
code_hash: 1dda2f41631a54acedfd4cc856f7f2f752f0ea13171eb2040ae37520390a0f5d
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.RabbitMQ
documentation_title: RabbitMQ node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"rabbitmq","description":"Templates for rabbitmq"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
extracted_at: 2025-06-12 08:59:07
updated_at: 2025-06-12 08:59:07
source_code:
  "use strict";
  var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      var desc = Object.getOwnPropertyDescriptor(m, k);
      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
        desc = { enumerable: true, get: function() { return m[k]; } };
      }
      Object.defineProperty(o, k2, desc);
  }) : (function(o, m, k, k2) {
      if (k2 === undefined) k2 = k;
      o[k2] = m[k];
  }));
  var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
      Object.defineProperty(o, "default", { enumerable: true, value: v });
  }) : function(o, v) {
      o["default"] = v;
  });
  var __importStar = (this && this.__importStar) || function (mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
      __setModuleDefault(result, mod);
      return result;
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RabbitMQ = void 0;
  const amqplib = __importStar(require("amqplib"));
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const utilities_1 = require("../../utils/utilities");
  class RabbitMQ {
      constructor() {
          this.description = {
              displayName: 'RabbitMQ',
              name: 'rabbitmq',
              icon: 'file:rabbitmq.png',
              group: ['transform'],
              version: [1, 1.1],
              description: 'Sends messages to a RabbitMQ topic',
              defaults: {
                  name: 'RabbitMQ',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'rabbitmq',
                      required: true,
                      testedBy: 'rabbitmqConnectionTest',
                  },
              ],
              properties: [
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'hidden',
                      noDataExpression: true,
                      default: 'sendMessage',
                      displayOptions: {
                          show: {
                              '@version': [1],
                          },
                      },
                      options: [
                          {
                              name: 'Send a Message to RabbitMQ',
                              value: 'sendMessage',
                              action: 'Send a Message to RabbitMQ',
                          },
                          {
                              name: 'Delete From Queue',
                              value: 'deleteMessage',
                              action: 'Delete From Queue',
                          },
                      ],
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      default: 'sendMessage',
                      displayOptions: {
                          show: {
                              '@version': [1.1],
                          },
                      },
                      options: [
                          {
                              name: 'Send a Message to RabbitMQ',
                              value: 'sendMessage',
                              action: 'Send a Message to RabbitMQ',
                          },
                          {
                              name: 'Delete From Queue',
                              value: 'deleteMessage',
                              action: 'Delete From Queue',
                          },
                      ],
                  },
                  {
                      displayName: 'Will delete an item from the queue triggered earlier in the workflow by a RabbitMQ Trigger node',
                      name: 'deleteMessage',
                      type: 'notice',
                      default: '',
                      displayOptions: {
                          show: {
                              operation: ['deleteMessage'],
                          },
                      },
                  },
                  {
                      displayName: 'Mode',
                      name: 'mode',
                      type: 'options',
                      displayOptions: {
                          hide: {
                              operation: ['deleteMessage'],
                          },
                      },
                      options: [
                          {
                              name: 'Queue',
                              value: 'queue',
                              description: 'Publish data to queue',
                          },
                          {
                              name: 'Exchange',
                              value: 'exchange',
                              description: 'Publish data to exchange',
                          },
                      ],
                      default: 'queue',
                      description: 'To where data should be moved',
                  },
                  {
                      displayName: 'Queue / Topic',
                      name: 'queue',
                      type: 'string',
                      displayOptions: {
                          show: {
                              mode: ['queue'],
                          },
                          hide: {
                              operation: ['deleteMessage'],
                          },
                      },
                      default: '',
                      placeholder: 'queue-name',
                      description: 'Name of the queue to publish to',
                  },
                  {
                      displayName: 'Exchange',
                      name: 'exchange',
                      type: 'string',
                      displayOptions: {
                          show: {
                              mode: ['exchange'],
                          },
                      },
                      default: '',
                      placeholder: 'exchange-name',
                      description: 'Name of the exchange to publish to',
                  },
                  {
                      displayName: 'Type',
                      name: 'exchangeType',
                      type: 'options',
                      displayOptions: {
                          show: {
                              mode: ['exchange'],
                          },
                      },
                      options: [
                          {
                              name: 'Direct',
                              value: 'direct',
                              description: 'Direct exchange type',
                          },
                          {
                              name: 'Topic',
                              value: 'topic',
                              description: 'Topic exchange type',
                          },
                          {
                              name: 'Headers',
                              value: 'headers',
                              description: 'Headers exchange type',
                          },
                          {
                              name: 'Fanout',
                              value: 'fanout',
                              description: 'Fanout exchange type',
                          },
                      ],
                      default: 'fanout',
                      description: 'Type of exchange',
                  },
                  {
                      displayName: 'Routing Key',
                      name: 'routingKey',
                      type: 'string',
                      displayOptions: {
                          show: {
                              mode: ['exchange'],
                          },
                      },
                      default: '',
                      placeholder: 'routing-key',
                      description: 'The routing key for the message',
                  },
                  {
                      displayName: 'Send Input Data',
                      name: 'sendInputData',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['sendMessage'],
                          },
                      },
                      default: true,
                      description: 'Whether to send the the data the node receives as JSON',
                  },
                  {
                      displayName: 'Message',
                      name: 'message',
                      type: 'string',
                      displayOptions: {
                          show: {
                              sendInputData: [false],
                          },
                      },
                      default: '',
                      description: 'The message to be sent',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      default: {},
                      displayOptions: {
                          show: {
                              operation: ['sendMessage'],
                          },
                      },
                      placeholder: 'Add Option',
                      options: [
                          {
                              displayName: 'Alternate Exchange',
                              name: 'alternateExchange',
                              type: 'string',
                              displayOptions: {
                                  show: {
                                      '/mode': ['exchange'],
                                  },
                              },
                              default: '',
                              description: 'An exchange to send messages to if this exchange can’t route them to any queues',
                          },
                          {
                              displayName: 'Arguments',
                              name: 'arguments',
                              placeholder: 'Add Argument',
                              description: 'Arguments to add',
                              type: 'fixedCollection',
                              typeOptions: {
                                  multipleValues: true,
                              },
                              default: {},
                              options: [
                                  {
                                      name: 'argument',
                                      displayName: 'Argument',
                                      values: [
                                          {
                                              displayName: 'Key',
                                              name: 'key',
                                              type: 'string',
                                              default: '',
                                          },
                                          {
                                              displayName: 'Value',
                                              name: 'value',
                                              type: 'string',
                                              default: '',
                                          },
                                      ],
                                  },
                              ],
                          },
                          {
                              displayName: 'Auto Delete Queue',
                              name: 'autoDelete',
                              type: 'boolean',
                              default: false,
                              description: 'Whether the queue will be deleted when the number of consumers drops to zero',
                          },
                          {
                              displayName: 'Durable',
                              name: 'durable',
                              type: 'boolean',
                              default: true,
                              description: 'Whether the queue will survive broker restarts',
                          },
                          {
                              displayName: 'Exclusive',
                              name: 'exclusive',
                              type: 'boolean',
                              displayOptions: {
                                  show: {
                                      '/mode': ['queue'],
                                  },
                              },
                              default: false,
                              description: 'Whether to scope the queue to the connection',
                          },
                          {
                              displayName: 'Headers',
                              name: 'headers',
                              placeholder: 'Add Header',
                              description: 'Headers to add',
                              type: 'fixedCollection',
                              typeOptions: {
                                  multipleValues: true,
                              },
                              default: {},
                              options: [
                                  {
                                      name: 'header',
                                      displayName: 'Header',
                                      values: [
                                          {
                                              displayName: 'Key',
                                              name: 'key',
                                              type: 'string',
                                              default: '',
                                          },
                                          {
                                              displayName: 'Value',
                                              name: 'value',
                                              type: 'string',
                                              default: '',
                                          },
                                      ],
                                  },
                              ],
                          },
                      ],
                  },
              ],
          };
          this.methods = {
              credentialTest: {
                  async rabbitmqConnectionTest(credential) {
                      const credentials = credential.data;
                      try {
                          const credentialKeys = ['hostname', 'port', 'username', 'password', 'vhost'];
                          const credentialData = {};
                          credentialKeys.forEach((key) => {
                              credentialData[key] = credentials[key] === '' ? undefined : credentials[key];
                          });
                          const optsData = {};
                          if (credentials.ssl === true) {
                              credentialData.protocol = 'amqps';
                              optsData.ca =
                                  credentials.ca === ''
                                      ? undefined
                                      : [Buffer.from((0, utilities_1.formatPrivateKey)(credentials.ca))];
                              if (credentials.passwordless === true) {
                                  optsData.cert =
                                      credentials.cert === ''
                                          ? undefined
                                          : Buffer.from((0, utilities_1.formatPrivateKey)(credentials.cert));
                                  optsData.key =
                                      credentials.key === ''
                                          ? undefined
                                          : Buffer.from((0, utilities_1.formatPrivateKey)(credentials.key));
                                  optsData.passphrase =
                                      credentials.passphrase === '' ? undefined : credentials.passphrase;
                                  optsData.credentials = amqplib.credentials.external();
                              }
                          }
                          const connection = await amqplib.connect(credentialData, optsData);
                          await connection.close();
                      }
                      catch (error) {
                          return {
                              status: 'Error',
                              message: error.message,
                          };
                      }
                      return {
                          status: 'OK',
                          message: 'Connection successful!',
                      };
                  },
              },
          };
      }
      async execute() {
          let channel, options;
          try {
              const items = this.getInputData();
              const operation = this.getNodeParameter('operation', 0);
              if (operation === 'deleteMessage') {
                  this.sendResponse(items[0].json);
                  return [items];
              }
              const mode = this.getNodeParameter('mode', 0) || 'queue';
              const returnItems = [];
              if (mode === 'queue') {
                  const queue = this.getNodeParameter('queue', 0);
                  options = this.getNodeParameter('options', 0, {});
                  channel = await GenericFunctions_1.rabbitmqConnectQueue.call(this, queue, options);
                  const sendInputData = this.getNodeParameter('sendInputData', 0);
                  let message;
                  const queuePromises = [];
                  for (let i = 0; i < items.length; i++) {
                      if (sendInputData) {
                          message = JSON.stringify(items[i].json);
                      }
                      else {
                          message = this.getNodeParameter('message', i);
                      }
                      let headers = {};
                      if (options.headers &&
                          options.headers.header.length) {
                          const itemOptions = this.getNodeParameter('options', i, {});
                          const additionalHeaders = {};
                          itemOptions.headers.header.forEach((header) => {
                              additionalHeaders[header.key] = header.value;
                          });
                          headers = additionalHeaders;
                      }
                      queuePromises.push(channel.sendToQueue(queue, Buffer.from(message), { headers }));
                  }
                  const promisesResponses = await Promise.allSettled(queuePromises);
                  promisesResponses.forEach((response) => {
                      if (response.status !== 'fulfilled') {
                          if (!this.continueOnFail()) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), response);
                          }
                          else {
                              returnItems.push({
                                  json: {
                                      error: response.reason,
                                  },
                              });
                              return;
                          }
                      }
                      returnItems.push({
                          json: {
                              success: response.value,
                          },
                      });
                  });
                  await channel.close();
                  await channel.connection.close();
              }
              else if (mode === 'exchange') {
                  const exchange = this.getNodeParameter('exchange', 0);
                  const type = this.getNodeParameter('exchangeType', 0);
                  const routingKey = this.getNodeParameter('routingKey', 0);
                  options = this.getNodeParameter('options', 0, {});
                  channel = await GenericFunctions_1.rabbitmqConnectExchange.call(this, exchange, type, options);
                  const sendInputData = this.getNodeParameter('sendInputData', 0);
                  let message;
                  const exchangePromises = [];
                  for (let i = 0; i < items.length; i++) {
                      if (sendInputData) {
                          message = JSON.stringify(items[i].json);
                      }
                      else {
                          message = this.getNodeParameter('message', i);
                      }
                      let headers = {};
                      if (options.headers &&
                          options.headers.header.length) {
                          const itemOptions = this.getNodeParameter('options', i, {});
                          const additionalHeaders = {};
                          itemOptions.headers.header.forEach((header) => {
                              additionalHeaders[header.key] = header.value;
                          });
                          headers = additionalHeaders;
                      }
                      exchangePromises.push(channel.publish(exchange, routingKey, Buffer.from(message), { headers }));
                  }
                  const promisesResponses = await Promise.allSettled(exchangePromises);
                  promisesResponses.forEach((response) => {
                      if (response.status !== 'fulfilled') {
                          if (!this.continueOnFail()) {
                              throw new n8n_workflow_1.NodeApiError(this.getNode(), response);
                          }
                          else {
                              returnItems.push({
                                  json: {
                                      error: response.reason,
                                  },
                              });
                              return;
                          }
                      }
                      returnItems.push({
                          json: {
                              success: response.value,
                          },
                      });
                  });
                  await channel.close();
                  await channel.connection.close();
              }
              else {
                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${mode}" is not known!`);
              }
              return [returnItems];
          }
          catch (error) {
              if (channel) {
                  await channel.close();
                  await channel.connection.close();
              }
              throw error;
          }
      }
  }
  exports.RabbitMQ = RabbitMQ;
  //# sourceMappingURL=RabbitMQ.node.js.map

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

  # RabbitMQ node

  Use the RabbitMQ node to automate work in RabbitMQ, and integrate RabbitMQ with other applications. n8n has built-in support for a wide range of RabbitMQ features, including accepting, and forwarding messages. 

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

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

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

  ## Operations

  * Delete From Queue
  * Send a Message to RabbitMQ

  ## Templates and examples

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

example_workflow:
  {"name":"RabbitMQ Example Workflow","nodes":[{"parameters":{"operation":"sendMessage","deleteMessage":null,"mode":"queue","queue":"example-value","exchange":"example-value","exchangeType":"direct","routingKey":"example-value","sendInputData":true,"message":"example-value","options":{}},"id":"rjmzf96md0h6yuiogwzw2q","name":"RabbitMQ","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"operation":"sendMessage","deleteMessage":null,"mode":"queue","queue":"example-value","exchange":"example-value","exchangeType":"direct","routingKey":"example-value","sendInputData":true,"message":"example-value","options":{}}

properties_schema:
  [{"displayName":"Operation","name":"operation","type":"hidden","default":"sendMessage"},{"displayName":"Operation","name":"operation","type":"options","default":"sendMessage","options":[{"name":"Send a Message to RabbitMQ","value":"sendMessage"},{"name":"Delete From Queue","value":"deleteMessage"}]},{"displayName":"Will delete an item from the queue triggered earlier in the workflow by a RabbitMQ Trigger node","name":"deleteMessage","type":"notice","default":""},{"displayName":"Mode","name":"mode","type":"options","default":"queue","description":"Publish data to queue","options":[{"name":"Queue","value":"queue","description":"Publish data to queue"},{"name":"Exchange","value":"exchange","description":"Publish data to exchange"}]},{"displayName":"Queue / Topic","name":"queue","type":"string","default":"","description":"Name of the queue to publish to","placeholder":"queue-name"},{"displayName":"Exchange","name":"exchange","type":"string","default":"","description":"Name of the exchange to publish to","placeholder":"exchange-name"},{"displayName":"Type","name":"exchangeType","type":"options","default":"fanout","description":"Direct exchange type","options":[{"name":"Direct","value":"direct","description":"Direct exchange type"},{"name":"Topic","value":"topic","description":"Topic exchange type"},{"name":"Headers","value":"headers","description":"Headers exchange type"},{"name":"Fanout","value":"fanout","description":"Fanout exchange type"}]},{"displayName":"Routing Key","name":"routingKey","type":"string","default":"","description":"The routing key for the message","placeholder":"routing-key"},{"displayName":"Send Input Data","name":"sendInputData","type":"boolean","default":true,"description":"Whether to send the the data the node receives as JSON"},{"displayName":"Message","name":"message","type":"string","default":"","description":"The message to be sent"},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"An exchange to send messages to if this exchange can’t route them to any queues","placeholder":"Add Option"}]


node_type: n8n-nodes-base.ReadPDF
name: ReadPDF
display_name: Read PDF
description: Reads a PDF and extracts its content
category: input
icon: fa:file-pdf
code_hash: 09ec3debb56dca4fe21573be43e2e40abcadf51eb42bf7219407cd46d1fc9767
example_parameters: {"binaryPropertyName":"Example Name","encrypted":false,"password":"example-value"}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.ReadPDF = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const pdfjs_dist_1 = require("pdfjs-dist");
  const parseText = (textContent) => {
      let lastY = undefined;
      const text = [];
      for (const item of textContent.items) {
          if ('str' in item) {
              if (lastY == item.transform[5] || !lastY) {
                  text.push(item.str);
              }
              else {
                  text.push(`\n${item.str}`);
              }
              lastY = item.transform[5];
          }
      }
      return text.join('');
  };
  class ReadPDF {
      constructor() {
          this.description = {
              displayName: 'Read PDF',
              name: 'readPDF',
              icon: 'fa:file-pdf',
              group: ['input'],
              version: 1,
              description: 'Reads a PDF and extracts its content',
              defaults: {
                  name: 'Read PDF',
                  color: '#003355',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'Binary Property',
                      name: 'binaryPropertyName',
                      type: 'string',
                      default: 'data',
                      required: true,
                      description: 'Name of the binary property from which to read the PDF file',
                  },
                  {
                      displayName: 'Encrypted',
                      name: 'encrypted',
                      type: 'boolean',
                      default: false,
                      required: true,
                  },
                  {
                      displayName: 'Password',
                      name: 'password',
                      type: 'string',
                      typeOptions: { password: true },
                      default: '',
                      description: 'Password to decrypt the PDF file with',
                      displayOptions: {
                          show: {
                              encrypted: [true],
                          },
                      },
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          const length = items.length;
          for (let itemIndex = 0; itemIndex < length; itemIndex++) {
              try {
                  const binaryPropertyName = this.getNodeParameter('binaryPropertyName', itemIndex);
                  const binaryData = this.helpers.assertBinaryData(itemIndex, binaryPropertyName);
                  const params = {};
                  if (this.getNodeParameter('encrypted', itemIndex) === true) {
                      params.password = this.getNodeParameter('password', itemIndex);
                  }
                  if (binaryData.id) {
                      const binaryPath = this.helpers.getBinaryPath(binaryData.id);
                      params.url = new URL(`file://${binaryPath}`);
                  }
                  else {
                      params.data = Buffer.from(binaryData.data, n8n_workflow_1.BINARY_ENCODING).buffer;
                  }
                  const document = await (0, pdfjs_dist_1.getDocument)(params).promise;
                  const { info, metadata } = await document
                      .getMetadata()
                      .catch(() => ({ info: null, metadata: null }));
                  const pages = [];
                  for (let i = 1; i <= document.numPages; i++) {
                      const page = await document.getPage(i);
                      const text = await page.getTextContent().then(parseText);
                      pages.push(text);
                  }
                  returnData.push({
                      binary: items[itemIndex].binary,
                      json: {
                          numpages: document.numPages,
                          numrender: document.numPages,
                          info,
                          metadata: metadata === null || metadata === void 0 ? void 0 : metadata.getAll(),
                          text: pages.join('\n\n'),
                          version: pdfjs_dist_1.version,
                      },
                  });
              }
              catch (error) {
                  console.log(error);
                  if (this.continueOnFail()) {
                      returnData.push({
                          json: {
                              error: error.message,
                          },
                          pairedItem: {
                              item: itemIndex,
                          },
                      });
                      continue;
                  }
                  throw error;
              }
          }
          return [returnData];
      }
  }
  exports.ReadPDF = ReadPDF;
  //# sourceMappingURL=ReadPDF.node.js.map

example_workflow:
  {"name":"Read PDF Example Workflow","nodes":[{"parameters":{"binaryPropertyName":"Example Name","encrypted":false,"password":"example-value"},"id":"96c1lktna0wtenu2tjdf","name":"Read PDF","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Binary Property","name":"binaryPropertyName","type":"string","default":"data","required":true,"description":"Name of the binary property from which to read the PDF file"},{"displayName":"Encrypted","name":"encrypted","type":"boolean","default":false,"required":true},{"displayName":"Password","name":"password","type":"string","default":"","description":"Password to decrypt the PDF file with"}]


node_type: n8n-nodes-base.Redis
name: Redis
display_name: Redis
description: Get, send and update data in Redis
category: input
icon: file:redis.svg
code_hash: facd578480f0b4acbbb4acf818dd36df1b1e4881ba29a0ed7eb649e08c5205d7
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Redis
documentation_title: Redis node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"redis","description":"Templates for redis"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
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.Redis = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const set_1 = __importDefault(require("lodash/set"));
  const redis_1 = __importDefault(require("redis"));
  const util_1 = __importDefault(require("util"));
  class Redis {
      constructor() {
          this.description = {
              displayName: 'Redis',
              name: 'redis',
              icon: 'file:redis.svg',
              group: ['input'],
              version: 1,
              description: 'Get, send and update data in Redis',
              defaults: {
                  name: 'Redis',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'redis',
                      required: true,
                      testedBy: 'redisConnectionTest',
                  },
              ],
              properties: [
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Delete',
                              value: 'delete',
                              description: 'Delete a key from Redis',
                              action: 'Delete a key from Redis',
                          },
                          {
                              name: 'Get',
                              value: 'get',
                              description: 'Get the value of a key from Redis',
                              action: 'Get the value of a key from Redis',
                          },
                          {
                              name: 'Increment',
                              value: 'incr',
                              description: 'Atomically increments a key by 1. Creates the key if it does not exist.',
                              action: 'Atomically increment a key by 1. Creates the key if it does not exist.',
                          },
                          {
                              name: 'Info',
                              value: 'info',
                              description: 'Returns generic information about the Redis instance',
                              action: 'Return generic information about the Redis instance',
                          },
                          {
                              name: 'Keys',
                              value: 'keys',
                              description: 'Returns all the keys matching a pattern',
                              action: 'Return all keys matching a pattern',
                          },
                          {
                              name: 'Pop',
                              value: 'pop',
                              description: 'Pop data from a redis list',
                              action: 'Pop data from a redis list',
                          },
                          {
                              name: 'Publish',
                              value: 'publish',
                              description: 'Publish message to redis channel',
                              action: 'Publish message to redis channel',
                          },
                          {
                              name: 'Push',
                              value: 'push',
                              description: 'Push data to a redis list',
                              action: 'Push data to a redis list',
                          },
                          {
                              name: 'Set',
                              value: 'set',
                              description: 'Set the value of a key in redis',
                              action: 'Set the value of a key in redis',
                          },
                      ],
                      default: 'info',
                  },
                  {
                      displayName: 'Name',
                      name: 'propertyName',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['get'],
                          },
                      },
                      default: 'propertyName',
                      required: true,
                      description: 'Name of the property to write received data to. Supports dot-notation. Example: "data.person[0].name".',
                  },
                  {
                      displayName: 'Key',
                      name: 'key',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['delete'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the key to delete from Redis',
                  },
                  {
                      displayName: 'Key',
                      name: 'key',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['get'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the key to get from Redis',
                  },
                  {
                      displayName: 'Key Type',
                      name: 'keyType',
                      type: 'options',
                      displayOptions: {
                          show: {
                              operation: ['get'],
                          },
                      },
                      options: [
                          {
                              name: 'Automatic',
                              value: 'automatic',
                              description: 'Requests the type before requesting the data (slower)',
                          },
                          {
                              name: 'Hash',
                              value: 'hash',
                              description: "Data in key is of type 'hash'",
                          },
                          {
                              name: 'List',
                              value: 'list',
                              description: "Data in key is of type 'lists'",
                          },
                          {
                              name: 'Sets',
                              value: 'sets',
                              description: "Data in key is of type 'sets'",
                          },
                          {
                              name: 'String',
                              value: 'string',
                              description: "Data in key is of type 'string'",
                          },
                      ],
                      default: 'automatic',
                      description: 'The type of the key to get',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      displayOptions: {
                          show: {
                              operation: ['get'],
                          },
                      },
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Dot Notation',
                              name: 'dotNotation',
                              type: 'boolean',
                              default: true,
                              description: '<p>By default, dot-notation is used in property names. This means that "a.b" will set the property "b" underneath "a" so { "a": { "b": value} }.<p></p>If that is not intended this can be deactivated, it will then set { "a.b": value } instead.</p>.',
                          },
                      ],
                  },
                  {
                      displayName: 'Key',
                      name: 'key',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['incr'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the key to increment',
                  },
                  {
                      displayName: 'Expire',
                      name: 'expire',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['incr'],
                          },
                      },
                      default: false,
                      description: 'Whether to set a timeout on key',
                  },
                  {
                      displayName: 'TTL',
                      name: 'ttl',
                      type: 'number',
                      typeOptions: {
                          minValue: 1,
                      },
                      displayOptions: {
                          show: {
                              operation: ['incr'],
                              expire: [true],
                          },
                      },
                      default: 60,
                      description: 'Number of seconds before key expiration',
                  },
                  {
                      displayName: 'Key Pattern',
                      name: 'keyPattern',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['keys'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'The key pattern for the keys to return',
                  },
                  {
                      displayName: 'Get Values',
                      name: 'getValues',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['keys'],
                          },
                      },
                      default: true,
                      description: 'Whether to get the value of matching keys',
                  },
                  {
                      displayName: 'Key',
                      name: 'key',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['set'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the key to set in Redis',
                  },
                  {
                      displayName: 'Value',
                      name: 'value',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['set'],
                          },
                      },
                      default: '',
                      description: 'The value to write in Redis',
                  },
                  {
                      displayName: 'Key Type',
                      name: 'keyType',
                      type: 'options',
                      displayOptions: {
                          show: {
                              operation: ['set'],
                          },
                      },
                      options: [
                          {
                              name: 'Automatic',
                              value: 'automatic',
                              description: 'Tries to figure out the type automatically depending on the data',
                          },
                          {
                              name: 'Hash',
                              value: 'hash',
                              description: "Data in key is of type 'hash'",
                          },
                          {
                              name: 'List',
                              value: 'list',
                              description: "Data in key is of type 'lists'",
                          },
                          {
                              name: 'Sets',
                              value: 'sets',
                              description: "Data in key is of type 'sets'",
                          },
                          {
                              name: 'String',
                              value: 'string',
                              description: "Data in key is of type 'string'",
                          },
                      ],
                      default: 'automatic',
                      description: 'The type of the key to set',
                  },
                  {
                      displayName: 'Value Is JSON',
                      name: 'valueIsJSON',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              keyType: ['hash'],
                          },
                      },
                      default: true,
                      description: 'Whether the value is JSON or key value pairs',
                  },
                  {
                      displayName: 'Expire',
                      name: 'expire',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['set'],
                          },
                      },
                      default: false,
                      description: 'Whether to set a timeout on key',
                  },
                  {
                      displayName: 'TTL',
                      name: 'ttl',
                      type: 'number',
                      typeOptions: {
                          minValue: 1,
                      },
                      displayOptions: {
                          show: {
                              operation: ['set'],
                              expire: [true],
                          },
                      },
                      default: 60,
                      description: 'Number of seconds before key expiration',
                  },
                  {
                      displayName: 'Channel',
                      name: 'channel',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['publish'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Channel name',
                  },
                  {
                      displayName: 'Data',
                      name: 'messageData',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['publish'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Data to publish',
                  },
                  {
                      displayName: 'List',
                      name: 'list',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['push', 'pop'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Name of the list in Redis',
                  },
                  {
                      displayName: 'Data',
                      name: 'messageData',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['push'],
                          },
                      },
                      default: '',
                      required: true,
                      description: 'Data to push',
                  },
                  {
                      displayName: 'Tail',
                      name: 'tail',
                      type: 'boolean',
                      displayOptions: {
                          show: {
                              operation: ['push', 'pop'],
                          },
                      },
                      default: false,
                      description: 'Whether to push or pop data from the end of the list',
                  },
                  {
                      displayName: 'Name',
                      name: 'propertyName',
                      type: 'string',
                      displayOptions: {
                          show: {
                              operation: ['pop'],
                          },
                      },
                      default: 'propertyName',
                      description: 'Optional name of the property to write received data to. Supports dot-notation. Example: "data.person[0].name".',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      displayOptions: {
                          show: {
                              operation: ['pop'],
                          },
                      },
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Dot Notation',
                              name: 'dotNotation',
                              type: 'boolean',
                              default: true,
                              description: '<p>By default, dot-notation is used in property names. This means that "a.b" will set the property "b" underneath "a" so { "a": { "b": value} }.<p></p>If that is not intended this can be deactivated, it will then set { "a.b": value } instead.</p>.',
                          },
                      ],
                  },
              ],
          };
          this.methods = {
              credentialTest: {
                  async redisConnectionTest(credential) {
                      const credentials = credential.data;
                      const redisOptions = {
                          host: credentials.host,
                          port: credentials.port,
                          db: credentials.database,
                      };
                      if (credentials.password) {
                          redisOptions.password = credentials.password;
                      }
                      try {
                          const client = redis_1.default.createClient(redisOptions);
                          await new Promise((resolve, reject) => {
                              client.on('connect', async () => {
                                  client.ping('ping', (error, pong) => {
                                      if (error)
                                          reject(error);
                                      resolve(pong);
                                      client.quit();
                                  });
                              });
                              client.on('error', async (err) => {
                                  client.quit();
                                  reject(err);
                              });
                          });
                      }
                      catch (error) {
                          return {
                              status: 'Error',
                              message: error.message,
                          };
                      }
                      return {
                          status: 'OK',
                          message: 'Connection successful!',
                      };
                  },
              },
          };
      }
      async execute() {
          function getParsedValue(value) {
              if (value.match(/^[\d\.]+$/) === null) {
                  return value;
              }
              else {
                  return parseFloat(value);
              }
          }
          function convertInfoToObject(stringData) {
              const returnData = {};
              let key, value;
              for (const line of stringData.split('\n')) {
                  if (['#', ''].includes(line.charAt(0))) {
                      continue;
                  }
                  [key, value] = line.split(':');
                  if (key === undefined || value === undefined) {
                      continue;
                  }
                  value = value.trim();
                  if (value.includes('=')) {
                      returnData[key] = {};
                      let key2, value2;
                      for (const keyValuePair of value.split(',')) {
                          [key2, value2] = keyValuePair.split('=');
                          returnData[key][key2] = getParsedValue(value2);
                      }
                  }
                  else {
                      returnData[key] = getParsedValue(value);
                  }
              }
              return returnData;
          }
          async function getValue(client, keyName, type) {
              if (type === undefined || type === 'automatic') {
                  const clientType = util_1.default.promisify(client.type).bind(client);
                  type = await clientType(keyName);
              }
              if (type === 'string') {
                  const clientGet = util_1.default.promisify(client.get).bind(client);
                  return clientGet(keyName);
              }
              else if (type === 'hash') {
                  const clientHGetAll = util_1.default.promisify(client.hgetall).bind(client);
                  return clientHGetAll(keyName);
              }
              else if (type === 'list') {
                  const clientLRange = util_1.default.promisify(client.lrange).bind(client);
                  return clientLRange(keyName, 0, -1);
              }
              else if (type === 'sets') {
                  const clientSMembers = util_1.default.promisify(client.smembers).bind(client);
                  return clientSMembers(keyName);
              }
          }
          const setValue = async (client, keyName, value, expire, ttl, type, valueIsJSON) => {
              if (type === undefined || type === 'automatic') {
                  if (typeof value === 'string') {
                      type = 'string';
                  }
                  else if (Array.isArray(value)) {
                      type = 'list';
                  }
                  else if (typeof value === 'object') {
                      type = 'hash';
                  }
                  else {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Could not identify the type to set. Please set it manually!');
                  }
              }
              if (type === 'string') {
                  const clientSet = util_1.default.promisify(client.set).bind(client);
                  await clientSet(keyName, value.toString());
              }
              else if (type === 'hash') {
                  const clientHset = util_1.default.promisify(client.hset).bind(client);
                  if (valueIsJSON) {
                      let values;
                      if (typeof value === 'string') {
                          try {
                              values = JSON.parse(value);
                          }
                          catch {
                              values = value;
                          }
                      }
                      else {
                          values = value;
                      }
                      for (const key of Object.keys(values)) {
                          await clientHset(keyName, key, values[key].toString());
                      }
                  }
                  else {
                      const values = value.toString().split(' ');
                      await clientHset(keyName, values);
                  }
              }
              else if (type === 'list') {
                  const clientLset = util_1.default.promisify(client.lset).bind(client);
                  for (let index = 0; index < value.length; index++) {
                      await clientLset(keyName, index, value[index].toString());
                  }
              }
              else if (type === 'sets') {
                  const clientSadd = util_1.default.promisify(client.sadd).bind(client);
                  await clientSadd(keyName, value);
              }
              if (expire) {
                  const clientExpire = util_1.default.promisify(client.expire).bind(client);
                  await clientExpire(keyName, ttl);
              }
              return;
          };
          return new Promise(async (resolve, reject) => {
              const credentials = await this.getCredentials('redis');
              const redisOptions = {
                  host: credentials.host,
                  port: credentials.port,
                  db: credentials.database,
              };
              if (credentials.password) {
                  redisOptions.password = credentials.password;
              }
              const client = redis_1.default.createClient(redisOptions);
              const operation = this.getNodeParameter('operation', 0);
              client.on('error', (err) => {
                  client.quit();
                  reject(err);
              });
              client.on('ready', async (_err) => {
                  client.select(credentials.database);
                  try {
                      if (operation === 'info') {
                          const clientInfo = util_1.default.promisify(client.info).bind(client);
                          const result = await clientInfo();
                          resolve([[{ json: convertInfoToObject(result) }]]);
                          client.quit();
                      }
                      else if (['delete', 'get', 'keys', 'set', 'incr', 'publish', 'push', 'pop'].includes(operation)) {
                          const items = this.getInputData();
                          const returnItems = [];
                          let item;
                          for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
                              item = { json: {} };
                              if (operation === 'delete') {
                                  const keyDelete = this.getNodeParameter('key', itemIndex);
                                  const clientDel = util_1.default.promisify(client.del).bind(client);
                                  await clientDel(keyDelete);
                                  returnItems.push(items[itemIndex]);
                              }
                              else if (operation === 'get') {
                                  const propertyName = this.getNodeParameter('propertyName', itemIndex);
                                  const keyGet = this.getNodeParameter('key', itemIndex);
                                  const keyType = this.getNodeParameter('keyType', itemIndex);
                                  const value = (await getValue(client, keyGet, keyType)) || null;
                                  const options = this.getNodeParameter('options', itemIndex, {});
                                  if (options.dotNotation === false) {
                                      item.json[propertyName] = value;
                                  }
                                  else {
                                      (0, set_1.default)(item.json, propertyName, value);
                                  }
                                  returnItems.push(item);
                              }
                              else if (operation === 'keys') {
                                  const keyPattern = this.getNodeParameter('keyPattern', itemIndex);
                                  const getValues = this.getNodeParameter('getValues', itemIndex, true);
                                  const clientKeys = util_1.default.promisify(client.keys).bind(client);
                                  const keys = await clientKeys(keyPattern);
                                  if (!getValues) {
                                      returnItems.push({ json: { keys } });
                                      continue;
                                  }
                                  const promises = {};
                                  for (const keyName of keys) {
                                      promises[keyName] = await getValue(client, keyName);
                                  }
                                  for (const keyName of keys) {
                                      item.json[keyName] = await promises[keyName];
                                  }
                                  returnItems.push(item);
                              }
                              else if (operation === 'set') {
                                  const keySet = this.getNodeParameter('key', itemIndex);
                                  const value = this.getNodeParameter('value', itemIndex);
                                  const keyType = this.getNodeParameter('keyType', itemIndex);
                                  const valueIsJSON = this.getNodeParameter('valueIsJSON', itemIndex, true);
                                  const expire = this.getNodeParameter('expire', itemIndex, false);
                                  const ttl = this.getNodeParameter('ttl', itemIndex, -1);
                                  await setValue(client, keySet, value, expire, ttl, keyType, valueIsJSON);
                                  returnItems.push(items[itemIndex]);
                              }
                              else if (operation === 'incr') {
                                  const keyIncr = this.getNodeParameter('key', itemIndex);
                                  const expire = this.getNodeParameter('expire', itemIndex, false);
                                  const ttl = this.getNodeParameter('ttl', itemIndex, -1);
                                  const clientIncr = util_1.default.promisify(client.incr).bind(client);
                                  const incrementVal = await clientIncr(keyIncr);
                                  if (expire && ttl > 0) {
                                      const clientExpire = util_1.default.promisify(client.expire).bind(client);
                                      await clientExpire(keyIncr, ttl);
                                  }
                                  returnItems.push({ json: { [keyIncr]: incrementVal } });
                              }
                              else if (operation === 'publish') {
                                  const channel = this.getNodeParameter('channel', itemIndex);
                                  const messageData = this.getNodeParameter('messageData', itemIndex);
                                  const clientPublish = util_1.default.promisify(client.publish).bind(client);
                                  await clientPublish(channel, messageData);
                                  returnItems.push(items[itemIndex]);
                              }
                              else if (operation === 'push') {
                                  const redisList = this.getNodeParameter('list', itemIndex);
                                  const messageData = this.getNodeParameter('messageData', itemIndex);
                                  const tail = this.getNodeParameter('tail', itemIndex, false);
                                  const action = tail ? client.RPUSH : client.LPUSH;
                                  const clientPush = util_1.default.promisify(action).bind(client);
                                  await clientPush(redisList, messageData);
                                  returnItems.push(items[itemIndex]);
                              }
                              else if (operation === 'pop') {
                                  const redisList = this.getNodeParameter('list', itemIndex);
                                  const tail = this.getNodeParameter('tail', itemIndex, false);
                                  const propertyName = this.getNodeParameter('propertyName', itemIndex, 'propertyName');
                                  const action = tail ? client.rpop : client.lpop;
                                  const clientPop = util_1.default.promisify(action).bind(client);
                                  const value = await clientPop(redisList);
                                  let outputValue;
                                  try {
                                      outputValue = JSON.parse(value);
                                  }
                                  catch {
                                      outputValue = value;
                                  }
                                  const options = this.getNodeParameter('options', itemIndex, {});
                                  if (options.dotNotation === false) {
                                      item.json[propertyName] = outputValue;
                                  }
                                  else {
                                      (0, set_1.default)(item.json, propertyName, outputValue);
                                  }
                                  returnItems.push(item);
                              }
                          }
                          client.quit();
                          resolve([returnItems]);
                      }
                  }
                  catch (error) {
                      reject(error);
                  }
              });
          });
      }
  }
  exports.Redis = Redis;
  //# sourceMappingURL=Redis.node.js.map

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

  # Redis node

  Use the Redis node to automate work in Redis, and integrate Redis with other applications. n8n has built-in support for a wide range of Redis features, including deleting keys, getting key values, setting key value, and publishing messages to the Redis channel.  

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

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

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

  ## Operations

  * Delete a key from Redis.
  * Get the value of a key from Redis.
  * Returns generic information about the Redis instance.
  * Atomically increments a key by 1. Creates the key if it doesn't exist.
  * Returns all the keys matching a pattern.
  * Set the value of a key in Redis.
  * Publish message to Redis channel.

  ## Templates and examples

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

example_workflow:
  {"name":"Redis Example Workflow","nodes":[{"parameters":{"operation":"delete","propertyName":"Example Name","key":"example-value","keyType":"automatic","options":{},"expire":false,"ttl":60,"keyPattern":"example-value","getValues":true,"value":"example-value","valueIsJSON":true,"channel":"example-value","messageData":"example-value","list":"example-value","tail":false},"id":"98yp3w4y44pby4tjy0j2bo","name":"Redis","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"operation":"delete","propertyName":"Example Name","key":"example-value","keyType":"automatic","options":{},"expire":false,"ttl":60,"keyPattern":"example-value","getValues":true,"value":"example-value","valueIsJSON":true,"channel":"example-value","messageData":"example-value","list":"example-value","tail":false}

properties_schema:
  [{"displayName":"Operation","name":"operation","type":"options","default":"info","description":"Delete a key from Redis","options":[{"name":"Delete","value":"delete","description":"Delete a key from Redis"},{"name":"Get","value":"get","description":"Get the value of a key from Redis"},{"name":"Increment","value":"incr","description":"Atomically increments a key by 1. Creates the key if it does not exist."},{"name":"Info","value":"info","description":"Returns generic information about the Redis instance"},{"name":"Keys","value":"keys","description":"Returns all the keys matching a pattern"},{"name":"Pop","value":"pop","description":"Pop data from a redis list"},{"name":"Publish","value":"publish","description":"Publish message to redis channel"},{"name":"Push","value":"push","description":"Push data to a redis list"},{"name":"Set","value":"set","description":"Set the value of a key in redis"}]},{"displayName":"Name","name":"propertyName","type":"string","default":"propertyName","required":true,"description":"Name of the property to write received data to. Supports dot-notation. Example: "},{"displayName":"Key","name":"key","type":"string","default":"","required":true,"description":"Name of the key to delete from Redis"},{"displayName":"Key","name":"key","type":"string","default":"","required":true,"description":"Name of the key to get from Redis"},{"displayName":"Key Type","name":"keyType","type":"options","default":"automatic","description":"Requests the type before requesting the data (slower)","options":[{"name":"Automatic","value":"automatic","description":"Requests the type before requesting the data (slower)"},{"name":"Hash","value":"hash","description":"Data in key is of type "},{"name":"List","value":"list","description":"Data in key is of type "},{"name":"Sets","value":"sets","description":"Data in key is of type "},{"name":"String","value":"string","description":"Data in key is of type "}]},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"<p>By default, dot-notation is used in property names. This means that ","placeholder":"Add Option"},{"displayName":"Key","name":"key","type":"string","default":"","required":true,"description":"Name of the key to increment"},{"displayName":"Expire","name":"expire","type":"boolean","default":false,"description":"Whether to set a timeout on key"},{"displayName":"TTL","name":"ttl","type":"number","default":60,"description":"Number of seconds before key expiration"},{"displayName":"Key Pattern","name":"keyPattern","type":"string","default":"","required":true,"description":"The key pattern for the keys to return"},{"displayName":"Get Values","name":"getValues","type":"boolean","default":true,"description":"Whether to get the value of matching keys"},{"displayName":"Key","name":"key","type":"string","default":"","required":true,"description":"Name of the key to set in Redis"},{"displayName":"Value","name":"value","type":"string","default":"","description":"The value to write in Redis"},{"displayName":"Key Type","name":"keyType","type":"options","default":"automatic","description":"Tries to figure out the type automatically depending on the data","options":[{"name":"Automatic","value":"automatic","description":"Tries to figure out the type automatically depending on the data"},{"name":"Hash","value":"hash","description":"Data in key is of type "},{"name":"List","value":"list","description":"Data in key is of type "},{"name":"Sets","value":"sets","description":"Data in key is of type "},{"name":"String","value":"string","description":"Data in key is of type "}]},{"displayName":"Value Is JSON","name":"valueIsJSON","type":"boolean","default":true,"description":"Whether the value is JSON or key value pairs"},{"displayName":"Expire","name":"expire","type":"boolean","default":false,"description":"Whether to set a timeout on key"},{"displayName":"TTL","name":"ttl","type":"number","default":60,"description":"Number of seconds before key expiration"},{"displayName":"Channel","name":"channel","type":"string","default":"","required":true,"description":"Channel name"},{"displayName":"Data","name":"messageData","type":"string","default":"","required":true,"description":"Data to publish"},{"displayName":"List","name":"list","type":"string","default":"","required":true,"description":"Name of the list in Redis"},{"displayName":"Data","name":"messageData","type":"string","default":"","required":true,"description":"Data to push"},{"displayName":"Tail","name":"tail","type":"boolean","default":false,"description":"Whether to push or pop data from the end of the list"},{"displayName":"Name","name":"propertyName","type":"string","default":"propertyName","description":"Optional name of the property to write received data to. Supports dot-notation. Example: "},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"<p>By default, dot-notation is used in property names. This means that ","placeholder":"Add Option"}]


node_type: n8n-nodes-base.ReadBinaryFiles
name: ReadBinaryFiles
display_name: Read Binary Files
description: Reads binary files from disk
category: input
icon: fa:file-import
code_hash: b4e758feeb596d9a366840a789ede02f9592fdf23b6da29d0e7fe3a49053ac85
example_parameters: {"fileSelector":"example-value","dataPropertyName":"Example Name"}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
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.ReadBinaryFiles = void 0;
  const fast_glob_1 = __importDefault(require("fast-glob"));
  const utilities_1 = require("../../utils/utilities");
  class ReadBinaryFiles {
      constructor() {
          this.description = {
              displayName: 'Read Binary Files',
              name: 'readBinaryFiles',
              icon: 'fa:file-import',
              group: ['input'],
              version: 1,
              description: 'Reads binary files from disk',
              defaults: {
                  name: 'Read Binary Files',
                  color: '#44AA44',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'File Selector',
                      name: 'fileSelector',
                      type: 'string',
                      default: '',
                      required: true,
                      placeholder: '*.jpg',
                      description: 'Pattern for files to read',
                  },
                  {
                      displayName: 'Property Name',
                      name: 'dataPropertyName',
                      type: 'string',
                      default: 'data',
                      required: true,
                      description: 'Name of the binary property to which to write the data of the read files',
                  },
              ],
          };
      }
      async execute() {
          const fileSelector = this.getNodeParameter('fileSelector', 0);
          const dataPropertyName = this.getNodeParameter('dataPropertyName', 0);
          const pairedItem = (0, utilities_1.generatePairedItemData)(this.getInputData().length);
          const files = await (0, fast_glob_1.default)(fileSelector);
          const items = [];
          for (const filePath of files) {
              const stream = await this.helpers.createReadStream(filePath);
              items.push({
                  binary: {
                      [dataPropertyName]: await this.helpers.prepareBinaryData(stream, filePath),
                  },
                  json: {},
                  pairedItem,
              });
          }
          return [items];
      }
  }
  exports.ReadBinaryFiles = ReadBinaryFiles;
  //# sourceMappingURL=ReadBinaryFiles.node.js.map

example_workflow:
  {"name":"Read Binary Files Example Workflow","nodes":[{"parameters":{"fileSelector":"example-value","dataPropertyName":"Example Name"},"id":"qksnb3ewuunkcb6xmdd48a","name":"Read Binary Files","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"File Selector","name":"fileSelector","type":"string","default":"","required":true,"description":"Pattern for files to read","placeholder":"*.jpg"},{"displayName":"Property Name","name":"dataPropertyName","type":"string","default":"data","required":true,"description":"Name of the binary property to which to write the data of the read files"}]


node_type: n8n-nodes-base.RespondToWebhook
name: RespondToWebhook
display_name: Respond to Webhook
description: Returns data for Webhook
category: transform
icon: file:webhook.svg
code_hash: 95d3ea6eec3f2182949cb94764aaafedbf727bc3b52e721ca5e1f7f81734501b
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.RespondToWebhook
documentation_title: Respond to Webhook
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"respond-to-webhook","description":"Templates for respond-to-webhook"}]
related_resources: []
required_scopes: []
parameter_schemas: []
version_info: {"breakingChanges":[],"currentVersion":"1.22.0","deprecated":true,"deprecationNotice":"in 1.22.0"}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RespondToWebhook = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  class RespondToWebhook {
      constructor() {
          this.description = {
              displayName: 'Respond to Webhook',
              icon: 'file:webhook.svg',
              name: 'respondToWebhook',
              group: ['transform'],
              version: 1,
              description: 'Returns data for Webhook',
              defaults: {
                  name: 'Respond to Webhook',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [],
              properties: [
                  {
                      displayName: 'Respond With',
                      name: 'respondWith',
                      type: 'options',
                      options: [
                          {
                              name: 'Binary',
                              value: 'binary',
                          },
                          {
                              name: 'First Incoming Item',
                              value: 'firstIncomingItem',
                          },
                          {
                              name: 'JSON',
                              value: 'json',
                          },
                          {
                              name: 'No Data',
                              value: 'noData',
                          },
                          {
                              name: 'Text',
                              value: 'text',
                          },
                      ],
                      default: 'firstIncomingItem',
                      description: 'The data that should be returned',
                  },
                  {
                      displayName: 'When using expressions, note that this node will only run for the first item in the input data.',
                      name: 'webhookNotice',
                      type: 'notice',
                      displayOptions: {
                          show: {
                              respondWith: ['json', 'text'],
                          },
                      },
                      default: '',
                  },
                  {
                      displayName: 'Response Body',
                      name: 'responseBody',
                      type: 'json',
                      displayOptions: {
                          show: {
                              respondWith: ['json'],
                          },
                      },
                      default: '',
                      placeholder: '{ "key": "value" }',
                      description: 'The HTTP Response JSON data',
                  },
                  {
                      displayName: 'Response Body',
                      name: 'responseBody',
                      type: 'string',
                      displayOptions: {
                          show: {
                              respondWith: ['text'],
                          },
                      },
                      default: '',
                      placeholder: 'e.g. Workflow started',
                      description: 'The HTTP Response text data',
                  },
                  {
                      displayName: 'Response Data Source',
                      name: 'responseDataSource',
                      type: 'options',
                      displayOptions: {
                          show: {
                              respondWith: ['binary'],
                          },
                      },
                      options: [
                          {
                              name: 'Choose Automatically From Input',
                              value: 'automatically',
                              description: 'Use if input data will contain a single piece of binary data',
                          },
                          {
                              name: 'Specify Myself',
                              value: 'set',
                              description: 'Enter the name of the input field the binary data will be in',
                          },
                      ],
                      default: 'automatically',
                  },
                  {
                      displayName: 'Input Field Name',
                      name: 'inputFieldName',
                      type: 'string',
                      required: true,
                      default: 'data',
                      displayOptions: {
                          show: {
                              respondWith: ['binary'],
                              responseDataSource: ['set'],
                          },
                      },
                      description: 'The name of the node input field with the binary data',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Response Code',
                              name: 'responseCode',
                              type: 'number',
                              typeOptions: {
                                  minValue: 100,
                                  maxValue: 599,
                              },
                              default: 200,
                              description: 'The HTTP Response code to return. Defaults to 200.',
                          },
                          {
                              displayName: 'Response Headers',
                              name: 'responseHeaders',
                              placeholder: 'Add Response Header',
                              description: 'Add headers to the webhook response',
                              type: 'fixedCollection',
                              typeOptions: {
                                  multipleValues: true,
                              },
                              default: {},
                              options: [
                                  {
                                      name: 'entries',
                                      displayName: 'Entries',
                                      values: [
                                          {
                                              displayName: 'Name',
                                              name: 'name',
                                              type: 'string',
                                              default: '',
                                              description: 'Name of the header',
                                          },
                                          {
                                              displayName: 'Value',
                                              name: 'value',
                                              type: 'string',
                                              default: '',
                                              description: 'Value of the header',
                                          },
                                      ],
                                  },
                              ],
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          var _a, _b, _c;
          const items = this.getInputData();
          const respondWith = this.getNodeParameter('respondWith', 0);
          const options = this.getNodeParameter('options', 0, {});
          const headers = {};
          if (options.responseHeaders) {
              for (const header of options.responseHeaders.entries) {
                  if (typeof header.name !== 'string') {
                      header.name = (_a = header.name) === null || _a === void 0 ? void 0 : _a.toString();
                  }
                  headers[(_b = header.name) === null || _b === void 0 ? void 0 : _b.toLowerCase()] = (_c = header.value) === null || _c === void 0 ? void 0 : _c.toString();
              }
          }
          let responseBody;
          if (respondWith === 'json') {
              const responseBodyParameter = this.getNodeParameter('responseBody', 0);
              if (responseBodyParameter) {
                  if (typeof responseBodyParameter === 'object') {
                      responseBody = responseBodyParameter;
                  }
                  else {
                      responseBody = (0, n8n_workflow_1.jsonParse)(responseBodyParameter, {
                          errorMessage: "Invalid JSON in 'Response Body' field",
                      });
                  }
              }
          }
          else if (respondWith === 'firstIncomingItem') {
              responseBody = items[0].json;
          }
          else if (respondWith === 'text') {
              responseBody = this.getNodeParameter('responseBody', 0);
          }
          else if (respondWith === 'binary') {
              const item = items[0];
              if (item.binary === undefined) {
                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on the first item!');
              }
              let responseBinaryPropertyName;
              const responseDataSource = this.getNodeParameter('responseDataSource', 0);
              if (responseDataSource === 'set') {
                  responseBinaryPropertyName = this.getNodeParameter('inputFieldName', 0);
              }
              else {
                  const binaryKeys = Object.keys(item.binary);
                  if (binaryKeys.length === 0) {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'No binary data exists on the first item!');
                  }
                  responseBinaryPropertyName = binaryKeys[0];
              }
              const binaryData = this.helpers.assertBinaryData(0, responseBinaryPropertyName);
              if (binaryData.id) {
                  responseBody = { binaryData };
              }
              else {
                  responseBody = Buffer.from(binaryData.data, n8n_workflow_1.BINARY_ENCODING);
                  headers['content-length'] = responseBody.length;
              }
              if (!headers['content-type']) {
                  headers['content-type'] = binaryData.mimeType;
              }
          }
          else if (respondWith !== 'noData') {
              throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The Response Data option "${respondWith}" is not supported!`);
          }
          const response = {
              body: responseBody,
              headers,
              statusCode: options.responseCode || 200,
          };
          this.sendResponse(response);
          return [items];
      }
  }
  exports.RespondToWebhook = RespondToWebhook;
  //# sourceMappingURL=RespondToWebhook.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 File**: 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**.
  - **JWT Token**: Respond with a JSON Web Token (JWT).
  - **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) 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.

  ## Output the response sent to the webhook

  By default, the Respond to Webhook node has a single output branch that contains the node's input data.

  You can optionally enable a second output branch containing the response sent to the webhook. To enable this secondary output, open the Respond to Webhook node on the canvas and select the **Settings** tab. Activate the **Enable Response Output Branch** option.

  The node will now have two outputs:

  * **Input Data**: The original output, passing on the node's input.
  * **Response**: The response object sent to the webhook.

  ## 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)**.

workflow_examples:
  [{"name":"dynamic_credentials_using_expressions","workflow":{"name":"Dynamic credentials using expressions","nodes":[{"parameters":{"path":"da4071f2-7550-4dae-aa48-8bced4291643","formTitle":"Test dynamic credentials","formDescription":"This form is for testing an n8n workflow that demonstrates setting credentials with expressions.","formFields":{"values":[{"fieldLabel":"Enter your NASA API key","requiredField":true}]},"responseMode":"responseNode"},"id":"cc6f2b1e-0ed0-4d22-8a44-d7223ba283b4","name":"n8n Form Trigger","type":"n8n-nodes-base.formTrigger","typeVersion":2,"position":[560,520],"webhookId":"da4071f2-7550-4dae-aa48-8bced4291643"},{"parameters":{"additionalFields":{}},"id":"ef336bae-3d4f-419c-ab5c-b9f0de89f170","name":"NASA","type":"n8n-nodes-base.nasa","typeVersion":1,"position":[900,520],"credentials":{"nasaApi":{"id":"QDDBOZOD6k3ijL5t","name":"NASA account"}}},{"parameters":{"respondWith":"redirect","redirectURL":"={{ $json.url }}","options":{}},"id":"143bcdb6-aca0-4dd8-9204-9777271cd230","name":"Respond to Webhook","type":"n8n-nodes-base.respondToWebhook","typeVersion":1,"position":[1220,520]},{"parameters":{"content":"This workflow shows how to set credentials dynamically using expressions.\n\n\nFirst, set up your NASA credential: \n\n1. Create a new NASA credential.\n1. Hover over **API Key**.\n1. Toggle **Expression** on.\n1. In the **API Key** field, enter `{{ $json[\"Enter your NASA API key\"] }}`.\n\n\nThen, test the workflow:\n\n1. Get an [API key from NASA](https://api.nasa.gov/)\n2. Select **Execute workflow**\n3. Enter your key using the form.\n4. The workflow runs and sends you to the NASA picture of the day.\n\n\nFor more information on expressions, refer to [n8n documentation | Expressions](https://docs.n8n.io/code/expressions/).","height":564,"width":322,"color":4},"id":"0a0dee23-fa16-4f09-b5e0-856f47fb53d0","name":"Sticky Note","type":"n8n-nodes-base.stickyNote","typeVersion":1,"position":[120,140]},{"parameters":{"content":"User submits an API key using the form","height":319},"id":"dd766e32-334d-4e46-9daa-7800b134a3a5","name":"Sticky Note1","type":"n8n-nodes-base.stickyNote","typeVersion":1,"position":[500,380]},{"parameters":{"content":"The workflow passes the key to the NASA node. You can reference the value using the expression `$json[\"Enter your NASA API key\"]`. This is also available to the node credential. ","height":319,"color":5},"id":"3d8f02e6-e029-41dc-89ad-0f5cffe09348","name":"Sticky Note2","type":"n8n-nodes-base.stickyNote","typeVersion":1,"position":[820,380]},{"parameters":{"content":"The Respond to Webhook node controls the form response (in this example, redirecting the user to an image)","height":319},"id":"096eb6ab-c276-4687-9dc0-50e16a8f709a","name":"Sticky Note3","type":"n8n-nodes-base.stickyNote","typeVersion":1,"position":[1140,380]}],"pinData":{},"connections":{"n8n Form Trigger":{"main":[[{"node":"NASA","type":"main","index":0}]]},"NASA":{"main":[[{"node":"Respond to Webhook","type":"main","index":0}]]}}},"nodeConfigurations":[{"nodeType":"n8n-nodes-base.respondToWebhook","version":1,"parameters":{"respondWith":"redirect","redirectURL":"={{ $json.url }}","options":{}},"position":[1220,520]}],"connections":{"n8n Form Trigger":{"main":[[{"node":"NASA","type":"main","index":0}]]},"NASA":{"main":[[{"node":"Respond to Webhook","type":"main","index":0}]]}},"source":"docs/_workflows/credentials/dynamic_credentials_using_expressions.json"}]

troubleshooting_info:
  [{"issue":"How to use Respond to Webhook","solution":"To use the Respond to Webhook node:"},{"issue":"Node parameters","solution":"Configure the node behavior using these parameters."},{"issue":"Respond With","solution":"Choose what data to send in the webhook response."},{"issue":"Node options","solution":"Select **Add Option** to view and set the options."},{"issue":"Workflow behavior","solution":"When using the Respond to Webhook node, workflows behave as follows:"},{"issue":"Output the response sent to the webhook","solution":"By default, the Respond to Webhook node has a single output branch that contains the node's input data."},{"issue":"Return more than one data item (deprecated)","solution":"/// note | Deprecated in 1.22.0\nn8n 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.\n///"}]

node_connections:
  [{"fromNode":"n8n Form Trigger","toNode":"NASA","connectionType":"main"},{"fromNode":"NASA","toNode":"Respond to Webhook","connectionType":"main"}]

example_workflow:
  {"name":"Respond to Webhook Example Workflow","nodes":[{"parameters":{"respondWith":"binary","webhookNotice":null,"responseBody":"example-value","responseDataSource":"automatically","inputFieldName":"Example Name","options":{}},"id":"9i0dm3jaq6d80fe6qfne2m","name":"Respond to Webhook","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"respondWith":"binary","webhookNotice":null,"responseBody":"example-value","responseDataSource":"automatically","inputFieldName":"Example Name","options":{}}

properties_schema:
  [{"displayName":"Respond With","name":"respondWith","type":"options","default":"firstIncomingItem","description":"The data that should be returned","options":[{"name":"Binary","value":"binary"},{"name":"First Incoming Item","value":"firstIncomingItem"},{"name":"JSON","value":"json"},{"name":"No Data","value":"noData"},{"name":"Text","value":"text"}]},{"displayName":"When using expressions, note that this node will only run for the first item in the input data.","name":"webhookNotice","type":"notice","default":""},{"displayName":"Response Body","name":"responseBody","type":"json","default":"","description":"The HTTP Response JSON data","placeholder":"{ "},{"displayName":"Response Body","name":"responseBody","type":"string","default":"","description":"The HTTP Response text data","placeholder":"e.g. Workflow started"},{"displayName":"Response Data Source","name":"responseDataSource","type":"options","default":"automatically","description":"Use if input data will contain a single piece of binary data","options":[{"name":"Choose Automatically From Input","value":"automatically","description":"Use if input data will contain a single piece of binary data"},{"name":"Specify Myself","value":"set","description":"Enter the name of the input field the binary data will be in"}]},{"displayName":"Input Field Name","name":"inputFieldName","type":"string","default":"data","required":true,"description":"The name of the node input field with the binary data"},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"The HTTP Response code to return. Defaults to 200.","placeholder":"Add Option"}]


node_type: n8n-nodes-base.Rocketchat
name: Rocketchat
display_name: RocketChat
description: Consume RocketChat API
category: output
icon: file:rocketchat.svg
code_hash: df9e3192d2c8442bd08a2c62870bb8d2e83a38680502727e204def8a46a2d453
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Rocketchat
documentation_title: Rocket.Chat node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"rocketchat","description":"Templates for rocketchat"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Rocketchat = void 0;
  const GenericFunctions_1 = require("./GenericFunctions");
  class Rocketchat {
      constructor() {
          this.description = {
              displayName: 'RocketChat',
              name: 'rocketchat',
              icon: 'file:rocketchat.svg',
              group: ['output'],
              version: 1,
              subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
              description: 'Consume RocketChat API',
              defaults: {
                  name: 'RocketChat',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'rocketchatApi',
                      required: true,
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Chat',
                              value: 'chat',
                          },
                      ],
                      default: 'chat',
                  },
                  {
                      displayName: 'Operation',
                      name: 'operation',
                      type: 'options',
                      noDataExpression: true,
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                          },
                      },
                      options: [
                          {
                              name: 'Post Message',
                              value: 'postMessage',
                              description: 'Post a message to a channel or a direct message',
                              action: 'Post a message',
                          },
                      ],
                      default: 'postMessage',
                  },
                  {
                      displayName: 'Channel',
                      name: 'channel',
                      type: 'string',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                          },
                      },
                      default: '',
                      description: 'The channel name with the prefix in front of it',
                  },
                  {
                      displayName: 'Text',
                      name: 'text',
                      type: 'string',
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                          },
                      },
                      default: '',
                      description: 'The text of the message to send, is optional because of attachments',
                  },
                  {
                      displayName: 'JSON Parameters',
                      name: 'jsonParameters',
                      type: 'boolean',
                      default: false,
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                          },
                      },
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                          },
                      },
                      options: [
                          {
                              displayName: 'Alias',
                              name: 'alias',
                              type: 'string',
                              default: '',
                              description: 'This will cause the message’s name to appear as the given alias, but your username will still display',
                          },
                          {
                              displayName: 'Avatar',
                              name: 'avatar',
                              type: 'string',
                              default: '',
                              description: 'If provided, this will make the avatar use the provided image URL',
                          },
                          {
                              displayName: 'Emoji',
                              name: 'emoji',
                              type: 'string',
                              default: '',
                              description: 'This will cause the message’s name to appear as the given alias, but your username will still display',
                          },
                      ],
                  },
                  {
                      displayName: 'Attachments',
                      name: 'attachments',
                      type: 'collection',
                      default: {},
                      placeholder: 'Add Attachment Item',
                      typeOptions: {
                          multipleValues: true,
                          multipleValueButtonText: 'Add Attachment',
                      },
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                              jsonParameters: [false],
                          },
                      },
                      options: [
                          {
                              displayName: 'Color',
                              name: 'color',
                              type: 'color',
                              default: '#ff0000',
                              description: 'The color you want the order on the left side to be, any value background-css supports',
                          },
                          {
                              displayName: 'Text',
                              name: 'text',
                              type: 'string',
                              default: '',
                              description: 'The text to display for this attachment, it is different than the message’s text',
                          },
                          {
                              displayName: 'Timestamp',
                              name: 'ts',
                              type: 'dateTime',
                              default: '',
                              description: 'Displays the time next to the text portion',
                          },
                          {
                              displayName: 'Thumb URL',
                              name: 'thumbUrl',
                              type: 'string',
                              default: '',
                              description: 'An image that displays to the left of the text, looks better when this is relatively small',
                          },
                          {
                              displayName: 'Message Link',
                              name: 'messageLink',
                              type: 'string',
                              default: '',
                              description: 'Only applicable if the timestamp is provided, as it makes the time clickable to this link',
                          },
                          {
                              displayName: 'Collapsed',
                              name: 'collapsed',
                              type: 'boolean',
                              default: false,
                              description: 'Causes the image, audio, and video sections to be hiding when collapsed is true',
                          },
                          {
                              displayName: 'Author Name',
                              name: 'authorName',
                              type: 'string',
                              default: '',
                              description: 'Name of the author',
                          },
                          {
                              displayName: 'Author Link',
                              name: 'authorLink',
                              type: 'string',
                              default: '',
                              description: 'Providing this makes the author name clickable and points to this link',
                          },
                          {
                              displayName: 'Author Icon',
                              name: 'authorIcon',
                              type: 'string',
                              default: '',
                              placeholder: 'https://site.com/img.png',
                              description: 'Displays a tiny icon to the left of the Author’s name',
                          },
                          {
                              displayName: 'Title',
                              name: 'title',
                              type: 'string',
                              default: '',
                              description: 'Title to display for this attachment, displays under the author',
                          },
                          {
                              displayName: 'Title Link',
                              name: 'titleLink',
                              type: 'string',
                              default: '',
                              description: 'Providing this makes the title clickable, pointing to this link',
                          },
                          {
                              displayName: 'Title Link Download',
                              name: 'titleLinkDownload',
                              type: 'boolean',
                              default: false,
                              description: 'When this is true, a download icon appears and clicking this saves the link to file',
                          },
                          {
                              displayName: 'Image URL',
                              name: 'imageUrl',
                              type: 'string',
                              default: '',
                              description: 'The image to display, will be “big” and easy to see',
                          },
                          {
                              displayName: 'Audio URL',
                              name: 'audioUrl',
                              type: 'string',
                              default: '',
                              placeholder: 'https://site.com/aud.mp3',
                              description: 'Audio file to play, only supports what html audio does',
                          },
                          {
                              displayName: 'Video URL',
                              name: 'videoUrl',
                              type: 'string',
                              default: '',
                              placeholder: 'https://site.com/vid.mp4',
                              description: 'Video file to play, only supports what html video does',
                          },
                          {
                              displayName: 'Fields',
                              name: 'fields',
                              type: 'fixedCollection',
                              placeholder: 'Add Field Item',
                              typeOptions: {
                                  multipleValues: true,
                              },
                              default: {},
                              options: [
                                  {
                                      name: 'fieldsValues',
                                      displayName: 'Fields',
                                      values: [
                                          {
                                              displayName: 'Short',
                                              name: 'short',
                                              type: 'boolean',
                                              default: false,
                                              description: 'Whether this field should be a short field',
                                          },
                                          {
                                              displayName: 'Title',
                                              name: 'title',
                                              type: 'string',
                                              default: '',
                                              description: 'The title of this field',
                                          },
                                          {
                                              displayName: 'Value',
                                              name: 'value',
                                              type: 'string',
                                              default: '',
                                              description: 'The value of this field, displayed underneath the title value',
                                          },
                                      ],
                                  },
                              ],
                          },
                      ],
                  },
                  {
                      displayName: 'Attachments',
                      name: 'attachmentsJson',
                      type: 'json',
                      typeOptions: {
                          alwaysOpenEditWindow: true,
                      },
                      displayOptions: {
                          show: {
                              resource: ['chat'],
                              operation: ['postMessage'],
                              jsonParameters: [true],
                          },
                      },
                      default: '',
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const length = items.length;
          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 === 'chat') {
                      if (operation === 'postMessage') {
                          const channel = this.getNodeParameter('channel', i);
                          const text = this.getNodeParameter('text', i);
                          const options = this.getNodeParameter('options', i);
                          const jsonActive = this.getNodeParameter('jsonParameters', i);
                          const body = {
                              channel,
                              text,
                          };
                          if (options.alias) {
                              body.alias = options.alias;
                          }
                          if (options.avatar) {
                              body.avatar = options.avatar;
                          }
                          if (options.emoji) {
                              body.emoji = options.emoji;
                          }
                          if (!jsonActive) {
                              const optionsAttachments = this.getNodeParameter('attachments', i);
                              if (optionsAttachments.length > 0) {
                                  const attachments = [];
                                  for (let index = 0; index < optionsAttachments.length; index++) {
                                      const attachment = {};
                                      for (const option of Object.keys(optionsAttachments[index])) {
                                          if (option === 'color') {
                                              attachment.color = optionsAttachments[index][option];
                                          }
                                          else if (option === 'text') {
                                              attachment.text = optionsAttachments[index][option];
                                          }
                                          else if (option === 'ts') {
                                              attachment.ts = optionsAttachments[index][option];
                                          }
                                          else if (option === 'messageLinks') {
                                              attachment.message_link = optionsAttachments[index][option];
                                          }
                                          else if (option === 'thumbUrl') {
                                              attachment.thumb_url = optionsAttachments[index][option];
                                          }
                                          else if (option === 'collapsed') {
                                              attachment.collapsed = optionsAttachments[index][option];
                                          }
                                          else if (option === 'authorName') {
                                              attachment.author_name = optionsAttachments[index][option];
                                          }
                                          else if (option === 'authorLink') {
                                              attachment.author_link = optionsAttachments[index][option];
                                          }
                                          else if (option === 'authorIcon') {
                                              attachment.author_icon = optionsAttachments[index][option];
                                          }
                                          else if (option === 'title') {
                                              attachment.title = optionsAttachments[index][option];
                                          }
                                          else if (option === 'titleLink') {
                                              attachment.title_link = optionsAttachments[index][option];
                                          }
                                          else if (option === 'titleLinkDownload') {
                                              attachment.title_link_download = optionsAttachments[index][option];
                                          }
                                          else if (option === 'imageUrl') {
                                              attachment.image_url = optionsAttachments[index][option];
                                          }
                                          else if (option === 'audioUrl') {
                                              attachment.audio_url = optionsAttachments[index][option];
                                          }
                                          else if (option === 'videoUrl') {
                                              attachment.video_url = optionsAttachments[index][option];
                                          }
                                          else if (option === 'fields') {
                                              const fieldsValues = optionsAttachments[index][option]
                                                  .fieldsValues;
                                              if (fieldsValues.length > 0) {
                                                  const fields = [];
                                                  for (let j = 0; j < fieldsValues.length; j++) {
                                                      const field = {};
                                                      for (const key of Object.keys(fieldsValues[j])) {
                                                          if (key === 'short') {
                                                              field.short = fieldsValues[j][key];
                                                          }
                                                          else if (key === 'title') {
                                                              field.title = fieldsValues[j][key];
                                                          }
                                                          else if (key === 'value') {
                                                              field.value = fieldsValues[j][key];
                                                          }
                                                      }
                                                      fields.push(field);
                                                      attachment.fields = fields;
                                                  }
                                              }
                                          }
                                      }
                                      attachments.push(attachment);
                                  }
                                  body.attachments = attachments;
                              }
                          }
                          else {
                              body.attachments = (0, GenericFunctions_1.validateJSON)(this.getNodeParameter('attachmentsJson', i));
                          }
                          responseData = await GenericFunctions_1.rocketchatApiRequest.call(this, '/chat', 'POST', 'postMessage', body);
                      }
                  }
                  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.Rocketchat = Rocketchat;
  //# sourceMappingURL=Rocketchat.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RocketchatApi = void 0;
  class RocketchatApi {
      constructor() {
          this.name = 'rocketchatApi';
          this.displayName = 'Rocket API';
          this.documentationUrl = 'rocketchat';
          this.properties = [
              {
                  displayName: 'User ID',
                  name: 'userId',
                  type: 'string',
                  default: '',
              },
              {
                  displayName: 'Auth Key',
                  name: 'authKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
              {
                  displayName: 'Domain',
                  name: 'domain',
                  type: 'string',
                  default: '',
                  placeholder: 'https://n8n.rocket.chat',
              },
          ];
          this.authenticate = {
              type: 'generic',
              properties: {
                  headers: {
                      'X-Auth-Token': '={{$credentials.authKey}}',
                      'X-User-Id': '={{$credentials.userId}}',
                  },
              },
          };
          this.test = {
              request: {
                  baseURL: '={{$credentials.domain}}',
                  url: '/api/v1/webdav.getMyAccounts',
              },
          };
      }
  }
  exports.RocketchatApi = RocketchatApi;
  //# sourceMappingURL=RocketchatApi.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RocketchatApi = void 0;
  class RocketchatApi {
      constructor() {
          this.name = 'rocketchatApi';
          this.displayName = 'Rocket API';
          this.documentationUrl = 'rocketchat';
          this.properties = [
              {
                  displayName: 'User ID',
                  name: 'userId',
                  type: 'string',
                  default: '',
              },
              {
                  displayName: 'Auth Key',
                  name: 'authKey',
                  type: 'string',
                  typeOptions: { password: true },
                  default: '',
              },
              {
                  displayName: 'Domain',
                  name: 'domain',
                  type: 'string',
                  default: '',
                  placeholder: 'https://n8n.rocket.chat',
              },
          ];
          this.authenticate = {
              type: 'generic',
              properties: {
                  headers: {
                      'X-Auth-Token': '={{$credentials.authKey}}',
                      'X-User-Id': '={{$credentials.userId}}',
                  },
              },
          };
          this.test = {
              request: {
                  baseURL: '={{$credentials.domain}}',
                  url: '/api/v1/webdav.getMyAccounts',
              },
          };
      }
  }
  exports.RocketchatApi = RocketchatApi;
  //# sourceMappingURL=RocketchatApi.credentials.js.map

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

  # Rocket.Chat node

  Use the Rocket.Chat node to automate work in Rocket.Chat, and integrate Rocket.Chat with other applications. n8n supports posting messages to channels, and sending direct messages, with Rocket.Chat. 

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

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

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

  ## Operations

  * Chat
      * Post a message to a channel or a direct message

  ## Templates and examples

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

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

example_workflow:
  {"name":"RocketChat Example Workflow","nodes":[{"parameters":{"resource":"chat","operation":"postMessage","channel":"example-value","text":"example-value","jsonParameters":false,"options":{},"attachments":{},"attachmentsJson":null},"id":"psjbwrc0hseqx9yczx7qxq","name":"RocketChat","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

example_parameters:
  {"resource":"chat","operation":"postMessage","channel":"example-value","text":"example-value","jsonParameters":false,"options":{},"attachments":{},"attachmentsJson":null}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"chat","options":[{"name":"Chat","value":"chat"}]},{"displayName":"Operation","name":"operation","type":"options","default":"postMessage","description":"Post a message to a channel or a direct message","options":[{"name":"Post Message","value":"postMessage","description":"Post a message to a channel or a direct message"}]},{"displayName":"Channel","name":"channel","type":"string","default":"","required":true,"description":"The channel name with the prefix in front of it"},{"displayName":"Text","name":"text","type":"string","default":"","description":"The text of the message to send, is optional because of attachments"},{"displayName":"JSON Parameters","name":"jsonParameters","type":"boolean","default":false},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"This will cause the message’s name to appear as the given alias, but your username will still display","placeholder":"Add Option"},{"displayName":"Attachments","name":"attachments","type":"collection","default":"{","description":"The color you want the order on the left side to be, any value background-css supports","placeholder":"Add Attachment Item"},{"displayName":"Attachments","name":"attachmentsJson","type":"json","default":""}]


node_type: n8n-nodes-base.Reddit
name: Reddit
display_name: Reddit
description: Consume the Reddit API
category: transform
icon: file:reddit.svg
code_hash: 14ac2bd275d17b8cf9b5ac74cb57392dbf4f15c37e180153e8f3be4a55aedd77
documentation_url: https://docs.n8n.io/integrations/builtin/app-nodes/n8n-nodes-base.Reddit
documentation_title: Reddit node documentation
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"reddit","description":"Templates for reddit"}]
related_resources: []
required_scopes: []
parameter_schemas: []
troubleshooting_info: []
example_parameters: {"resource":"post","dynamic_property":null}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
source_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.Reddit = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const GenericFunctions_1 = require("./GenericFunctions");
  const PostCommentDescription_1 = require("./PostCommentDescription");
  const PostDescription_1 = require("./PostDescription");
  const ProfileDescription_1 = require("./ProfileDescription");
  const SubredditDescription_1 = require("./SubredditDescription");
  const UserDescription_1 = require("./UserDescription");
  class Reddit {
      constructor() {
          this.description = {
              displayName: 'Reddit',
              name: 'reddit',
              icon: 'file:reddit.svg',
              group: ['transform'],
              version: 1,
              subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
              description: 'Consume the Reddit API',
              defaults: {
                  name: 'Reddit',
              },
              inputs: ['main'],
              outputs: ['main'],
              credentials: [
                  {
                      name: 'redditOAuth2Api',
                      required: true,
                      displayOptions: {
                          show: {
                              resource: ['postComment', 'post', 'profile'],
                          },
                      },
                  },
              ],
              properties: [
                  {
                      displayName: 'Resource',
                      name: 'resource',
                      type: 'options',
                      noDataExpression: true,
                      options: [
                          {
                              name: 'Post',
                              value: 'post',
                          },
                          {
                              name: 'Post Comment',
                              value: 'postComment',
                          },
                          {
                              name: 'Profile',
                              value: 'profile',
                          },
                          {
                              name: 'Subreddit',
                              value: 'subreddit',
                          },
                          {
                              name: 'User',
                              value: 'user',
                          },
                      ],
                      default: 'post',
                  },
                  ...PostCommentDescription_1.postCommentOperations,
                  ...PostCommentDescription_1.postCommentFields,
                  ...ProfileDescription_1.profileOperations,
                  ...ProfileDescription_1.profileFields,
                  ...SubredditDescription_1.subredditOperations,
                  ...SubredditDescription_1.subredditFields,
                  ...PostDescription_1.postOperations,
                  ...PostDescription_1.postFields,
                  ...UserDescription_1.userOperations,
                  ...UserDescription_1.userFields,
              ],
          };
      }
      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 === 'post') {
                      if (operation === 'create') {
                          const qs = {
                              title: this.getNodeParameter('title', i),
                              sr: this.getNodeParameter('subreddit', i),
                              kind: this.getNodeParameter('kind', i),
                          };
                          qs.kind === 'self'
                              ? (qs.text = this.getNodeParameter('text', i))
                              : (qs.url = this.getNodeParameter('url', i));
                          if (qs.url) {
                              qs.resubmit = this.getNodeParameter('resubmit', i);
                          }
                          responseData = await GenericFunctions_1.redditApiRequest.call(this, 'POST', 'api/submit', qs);
                          responseData = responseData.json.data;
                      }
                      else if (operation === 'delete') {
                          const postTypePrefix = 't3_';
                          const qs = {
                              id: postTypePrefix + this.getNodeParameter('postId', i),
                          };
                          await GenericFunctions_1.redditApiRequest.call(this, 'POST', 'api/del', qs);
                          responseData = { success: true };
                      }
                      else if (operation === 'get') {
                          const subreddit = this.getNodeParameter('subreddit', i);
                          const postId = this.getNodeParameter('postId', i);
                          const endpoint = `r/${subreddit}/comments/${postId}.json`;
                          responseData = await GenericFunctions_1.redditApiRequest.call(this, 'GET', endpoint, {});
                          responseData = responseData[0].data.children[0].data;
                      }
                      else if (operation === 'getAll') {
                          const subreddit = this.getNodeParameter('subreddit', i);
                          let endpoint = `r/${subreddit}.json`;
                          const { category } = this.getNodeParameter('filters', i);
                          if (category) {
                              endpoint = `r/${subreddit}/${category}.json`;
                          }
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint);
                      }
                      else if (operation === 'search') {
                          const location = this.getNodeParameter('location', i);
                          const qs = {
                              q: this.getNodeParameter('keyword', i),
                              restrict_sr: location === 'subreddit',
                          };
                          const { sort } = this.getNodeParameter('additionalFields', i);
                          if (sort) {
                              qs.sort = sort;
                          }
                          let endpoint = '';
                          if (location === 'allReddit') {
                              endpoint = 'search.json';
                          }
                          else {
                              const subreddit = this.getNodeParameter('subreddit', i);
                              endpoint = `r/${subreddit}/search.json`;
                          }
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint, qs);
                          const returnAll = this.getNodeParameter('returnAll', 0);
                          if (!returnAll) {
                              const limit = this.getNodeParameter('limit', 0);
                              responseData = responseData.splice(0, limit);
                          }
                      }
                  }
                  else if (resource === 'postComment') {
                      if (operation === 'create') {
                          const postTypePrefix = 't3_';
                          const qs = {
                              text: this.getNodeParameter('commentText', i),
                              thing_id: postTypePrefix + this.getNodeParameter('postId', i),
                          };
                          responseData = await GenericFunctions_1.redditApiRequest.call(this, 'POST', 'api/comment', qs);
                          responseData = responseData.json.data.things[0].data;
                      }
                      else if (operation === 'getAll') {
                          const subreddit = this.getNodeParameter('subreddit', i);
                          const postId = this.getNodeParameter('postId', i);
                          const endpoint = `r/${subreddit}/comments/${postId}.json`;
                          responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint);
                      }
                      else if (operation === 'delete') {
                          const commentTypePrefix = 't1_';
                          const qs = {
                              id: commentTypePrefix + this.getNodeParameter('commentId', i),
                          };
                          await GenericFunctions_1.redditApiRequest.call(this, 'POST', 'api/del', qs);
                          responseData = { success: true };
                      }
                      else if (operation === 'reply') {
                          const commentTypePrefix = 't1_';
                          const qs = {
                              text: this.getNodeParameter('replyText', i),
                              thing_id: commentTypePrefix + this.getNodeParameter('commentId', i),
                          };
                          responseData = await GenericFunctions_1.redditApiRequest.call(this, 'POST', 'api/comment', qs);
                          responseData = responseData.json.data.things[0].data;
                      }
                  }
                  else if (resource === 'profile') {
                      if (operation === 'get') {
                          const endpoints = {
                              identity: 'me',
                              blockedUsers: 'me/blocked',
                              friends: 'me/friends',
                              karma: 'me/karma',
                              prefs: 'me/prefs',
                              trophies: 'me/trophies',
                          };
                          const details = this.getNodeParameter('details', i);
                          const endpoint = `api/v1/${endpoints[details]}`;
                          let username;
                          if (details === 'saved') {
                              ({ name: username } = await GenericFunctions_1.redditApiRequest.call(this, 'GET', 'api/v1/me', {}));
                          }
                          responseData =
                              details === 'saved'
                                  ? await GenericFunctions_1.handleListing.call(this, i, `user/${username}/saved.json`)
                                  : await GenericFunctions_1.redditApiRequest.call(this, 'GET', endpoint, {});
                          if (details === 'identity') {
                              responseData = responseData.features;
                          }
                          else if (details === 'friends') {
                              responseData = responseData.data.children;
                              if (!responseData.length) {
                                  throw new n8n_workflow_1.NodeApiError(this.getNode(), responseData);
                              }
                          }
                          else if (details === 'karma') {
                              responseData = responseData.data;
                              if (!responseData.length) {
                                  throw new n8n_workflow_1.NodeApiError(this.getNode(), responseData);
                              }
                          }
                          else if (details === 'trophies') {
                              responseData = responseData.data.trophies.map((trophy) => trophy.data);
                          }
                      }
                  }
                  else if (resource === 'subreddit') {
                      if (operation === 'get') {
                          const subreddit = this.getNodeParameter('subreddit', i);
                          const content = this.getNodeParameter('content', i);
                          const endpoint = `r/${subreddit}/about/${content}.json`;
                          responseData = await GenericFunctions_1.redditApiRequest.call(this, 'GET', endpoint, {});
                          if (content === 'rules') {
                              responseData = responseData.rules;
                          }
                          else if (content === 'about') {
                              responseData = responseData.data;
                          }
                      }
                      else if (operation === 'getAll') {
                          const filters = this.getNodeParameter('filters', i);
                          if (filters.trending) {
                              const returnAll = this.getNodeParameter('returnAll', 0);
                              const endpoint = 'api/trending_subreddits.json';
                              responseData = await GenericFunctions_1.redditApiRequest.call(this, 'GET', endpoint, {});
                              responseData = responseData.subreddit_names.map((name) => ({ name }));
                              if (!returnAll) {
                                  const limit = this.getNodeParameter('limit', 0);
                                  responseData = responseData.splice(0, limit);
                              }
                          }
                          else if (filters.keyword) {
                              const qs = {};
                              qs.query = filters.keyword;
                              const endpoint = 'api/search_subreddits.json';
                              responseData = await GenericFunctions_1.redditApiRequest.call(this, 'POST', endpoint, qs);
                              const returnAll = this.getNodeParameter('returnAll', 0);
                              if (!returnAll) {
                                  const limit = this.getNodeParameter('limit', 0);
                                  responseData = responseData.subreddits.splice(0, limit);
                              }
                          }
                          else {
                              const endpoint = 'r/subreddits.json';
                              responseData = await GenericFunctions_1.handleListing.call(this, i, endpoint);
                          }
                      }
                  }
                  else if (resource === 'user') {
                      if (operation === 'get') {
                          const username = this.getNodeParameter('username', i);
                          const details = this.getNodeParameter('details', i);
                          const endpoint = `user/${username}/${details}.json`;
                          responseData =
                              details === 'about'
                                  ? await GenericFunctions_1.redditApiRequest.call(this, 'GET', endpoint, {})
                                  : await GenericFunctions_1.handleListing.call(this, i, endpoint);
                          if (details === 'about') {
                              responseData = responseData.data;
                          }
                      }
                  }
                  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.Reddit = Reddit;
  //# sourceMappingURL=Reddit.node.js.map

credential_code:
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RedditOAuth2Api = void 0;
  const scopes = ['identity', 'edit', 'history', 'mysubreddits', 'read', 'save', 'submit'];
  class RedditOAuth2Api {
      constructor() {
          this.name = 'redditOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Reddit OAuth2 API';
          this.documentationUrl = 'reddit';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'response_type=code',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'grant_type=authorization_code',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'duration=permanent',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://www.reddit.com/api/v1/authorize',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://www.reddit.com/api/v1/access_token',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: scopes.join(' '),
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'header',
              },
          ];
      }
  }
  exports.RedditOAuth2Api = RedditOAuth2Api;
  //# sourceMappingURL=RedditOAuth2Api.credentials.js.map

  // --- Next Credential File ---

  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  exports.RedditOAuth2Api = void 0;
  const scopes = ['identity', 'edit', 'history', 'mysubreddits', 'read', 'save', 'submit'];
  class RedditOAuth2Api {
      constructor() {
          this.name = 'redditOAuth2Api';
          this.extends = ['oAuth2Api'];
          this.displayName = 'Reddit OAuth2 API';
          this.documentationUrl = 'reddit';
          this.properties = [
              {
                  displayName: 'Grant Type',
                  name: 'grantType',
                  type: 'hidden',
                  default: 'authorizationCode',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'response_type=code',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'grant_type=authorization_code',
              },
              {
                  displayName: 'Auth URI Query Parameters',
                  name: 'authQueryParameters',
                  type: 'hidden',
                  default: 'duration=permanent',
              },
              {
                  displayName: 'Authorization URL',
                  name: 'authUrl',
                  type: 'hidden',
                  default: 'https://www.reddit.com/api/v1/authorize',
              },
              {
                  displayName: 'Access Token URL',
                  name: 'accessTokenUrl',
                  type: 'hidden',
                  default: 'https://www.reddit.com/api/v1/access_token',
              },
              {
                  displayName: 'Scope',
                  name: 'scope',
                  type: 'hidden',
                  default: scopes.join(' '),
              },
              {
                  displayName: 'Authentication',
                  name: 'authentication',
                  type: 'hidden',
                  default: 'header',
              },
          ];
      }
  }
  exports.RedditOAuth2Api = RedditOAuth2Api;
  //# sourceMappingURL=RedditOAuth2Api.credentials.js.map

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

  # Reddit node

  Use the Reddit node to automate work in Reddit, and integrate Reddit with other applications. n8n has built-in support for a wide range of Reddit features, including getting profiles, and users, retrieving post comments and subreddit, as well as submitting, getting, and deleting posts. 

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

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

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

  ## Operations

  * Post
      * Submit a post to a subreddit
      * Delete a post from a subreddit
      * Get a post from a subreddit
      * Get all posts from a subreddit
      * Search posts in a subreddit or in all of Reddit.
  * Post Comment
      * Create a top-level comment in a post
      * Retrieve all comments in a post
      * Remove a comment from a post
      * Write a reply to a comment in a post
  * Profile
      * Get
  * Subreddit
      * Retrieve background information about a subreddit.
      * Retrieve information about subreddits from all of Reddit.
  * User
      * Get

  ## Templates and examples

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

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

example_workflow:
  {"name":"Reddit Example Workflow","nodes":[{"parameters":{"resource":"post","dynamic_property":null},"id":"pudfi3eknhht9mb9wrbg3g","name":"Reddit","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Resource","name":"resource","type":"options","default":"post","options":[{"name":"Post","value":"post"},{"name":"Post Comment","value":"postComment"},{"name":"Profile","value":"profile"},{"name":"Subreddit","value":"subreddit"},{"name":"User","value":"user"}]},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...PostCommentDescription_1.postCommentOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...PostCommentDescription_1.postCommentFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...ProfileDescription_1.profileOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...ProfileDescription_1.profileFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...SubredditDescription_1.subredditOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...SubredditDescription_1.subredditFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...PostDescription_1.postOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...PostDescription_1.postFields"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...UserDescription_1.userOperations"},{"name":"dynamic_property","type":"unknown","displayName":"Dynamic Property","_source":"...UserDescription_1.userFields"}]


node_type: n8n-nodes-base.RenameKeys
name: RenameKeys
display_name: Rename Keys
description: Renames keys
category: transform
icon: fa:edit
code_hash: 0708fae996ab278764a6b7528a635e8ce4b932769bffade386bf72d7d3ebeadd
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.RenameKeys
documentation_title: Rename Keys
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"rename-keys","description":"Templates for rename-keys"}]
related_resources: []
required_scopes: []
parameter_schemas: []
example_parameters: {"keys":{},"additionalOptions":{}}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
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.RenameKeys = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const get_1 = __importDefault(require("lodash/get"));
  const set_1 = __importDefault(require("lodash/set"));
  const unset_1 = __importDefault(require("lodash/unset"));
  class RenameKeys {
      constructor() {
          this.description = {
              displayName: 'Rename Keys',
              name: 'renameKeys',
              icon: 'fa:edit',
              group: ['transform'],
              version: 1,
              description: 'Renames keys',
              defaults: {
                  name: 'Rename Keys',
                  color: '#772244',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'Keys',
                      name: 'keys',
                      placeholder: 'Add new key',
                      description: 'Adds a key which should be renamed',
                      type: 'fixedCollection',
                      typeOptions: {
                          multipleValues: true,
                          sortable: true,
                      },
                      default: {},
                      options: [
                          {
                              displayName: 'Key',
                              name: 'key',
                              values: [
                                  {
                                      displayName: 'Current Key Name',
                                      name: 'currentKey',
                                      type: 'string',
                                      default: '',
                                      placeholder: 'currentKey',
                                      requiresDataPath: 'single',
                                      description: 'The current name of the key. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.currentKey".',
                                  },
                                  {
                                      displayName: 'New Key Name',
                                      name: 'newKey',
                                      type: 'string',
                                      default: '',
                                      placeholder: 'newKey',
                                      description: 'The name the key should be renamed to. It is also possible to define deep keys by using dot-notation like for example: "level1.level2.newKey".',
                                  },
                              ],
                          },
                      ],
                  },
                  {
                      displayName: 'Additional Options',
                      name: 'additionalOptions',
                      type: 'collection',
                      default: {},
                      placeholder: 'Add Option',
                      options: [
                          {
                              displayName: 'Regex',
                              name: 'regexReplacement',
                              placeholder: 'Add new regular expression',
                              description: 'Adds a regular expressiond',
                              type: 'fixedCollection',
                              typeOptions: {
                                  multipleValues: true,
                                  sortable: true,
                              },
                              default: {},
                              options: [
                                  {
                                      displayName: 'Replacement',
                                      name: 'replacements',
                                      values: [
                                          {
                                              displayName: 'Be aware that by using regular expression previously renamed keys can be affected',
                                              name: 'regExNotice',
                                              type: 'notice',
                                              default: '',
                                          },
                                          {
                                              displayName: 'Regular Expression',
                                              name: 'searchRegex',
                                              type: 'string',
                                              default: '',
                                              placeholder: 'e.g. [N-n]ame',
                                              description: 'Regex to match the key name',
                                              hint: 'Learn more and test RegEx <a href="https://regex101.com/">here</a>',
                                          },
                                          {
                                              displayName: 'Replace With',
                                              name: 'replaceRegex',
                                              type: 'string',
                                              default: '',
                                              placeholder: 'replacedName',
                                              description: "The name the key/s should be renamed to. It's possible to use regex captures e.g. $1, $2, ...",
                                          },
                                          {
                                              displayName: 'Options',
                                              name: 'options',
                                              type: 'collection',
                                              default: {},
                                              placeholder: 'Add Regex Option',
                                              options: [
                                                  {
                                                      displayName: 'Case Insensitive',
                                                      name: 'caseInsensitive',
                                                      type: 'boolean',
                                                      description: 'Whether to use case insensitive match',
                                                      default: false,
                                                  },
                                                  {
                                                      displayName: 'Max Depth',
                                                      name: 'depth',
                                                      type: 'number',
                                                      default: -1,
                                                      description: 'Maximum depth to replace keys',
                                                      hint: 'Specify number for depth level (-1 for unlimited, 0 for top level only)',
                                                  },
                                              ],
                                          },
                                      ],
                                  },
                              ],
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const items = this.getInputData();
          const returnData = [];
          let item;
          let newItem;
          let renameKeys;
          let value;
          const renameKey = (key) => {
              if (key.currentKey === '' || key.newKey === '' || key.currentKey === key.newKey) {
                  return;
              }
              value = (0, get_1.default)(item.json, key.currentKey);
              if (value === undefined) {
                  return;
              }
              (0, set_1.default)(newItem.json, key.newKey, value);
              (0, unset_1.default)(newItem.json, key.currentKey);
          };
          const regexReplaceKey = (replacement) => {
              const { searchRegex, replaceRegex, options } = replacement;
              const { depth, caseInsensitive } = options;
              const flags = caseInsensitive ? 'i' : undefined;
              const regex = new RegExp(searchRegex, flags);
              const renameObjectKeys = (obj, objDepth) => {
                  for (const key in obj) {
                      if (Array.isArray(obj)) {
                          if (objDepth !== 0) {
                              renameObjectKeys(obj[key], objDepth - 1);
                          }
                      }
                      else if (obj.hasOwnProperty(key)) {
                          if (typeof obj[key] === 'object' && objDepth !== 0) {
                              renameObjectKeys(obj[key], objDepth - 1);
                          }
                          if (key.match(regex)) {
                              const newKey = key.replace(regex, replaceRegex);
                              if (newKey !== key) {
                                  obj[newKey] = obj[key];
                                  delete obj[key];
                              }
                          }
                      }
                  }
                  return obj;
              };
              newItem.json = renameObjectKeys(newItem.json, depth);
          };
          for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
              renameKeys = this.getNodeParameter('keys.key', itemIndex, []);
              const regexReplacements = this.getNodeParameter('additionalOptions.regexReplacement.replacements', itemIndex, []);
              item = items[itemIndex];
              newItem = {
                  json: (0, n8n_workflow_1.deepCopy)(item.json),
                  pairedItem: {
                      item: itemIndex,
                  },
              };
              if (item.binary !== undefined) {
                  newItem.binary = item.binary;
              }
              renameKeys.forEach(renameKey);
              regexReplacements.forEach(regexReplaceKey);
              returnData.push(newItem);
          }
          return [returnData];
      }
  }
  exports.RenameKeys = RenameKeys;
  //# sourceMappingURL=RenameKeys.node.js.map

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

  # Rename Keys

  Use the Rename Keys node to rename the keys of a key-value pair in n8n.

  ## Node parameters

  You can rename one or multiple keys using the Rename Keys node. Select the **Add new key** button to rename a key.

  For each key, enter the:

  - **Current Key Name**: The current name of the key you want to rename.
  - **New Key Name**: The new name you want to assign to the key.

  ## Node options

  Choose whether to use a **Regex** regular expression to identify keys to rename. To use this option, you must also enter:

  * The **Regular Expression** you'd like to use.
  * **Replace With**: Enter the new name you want to assign to the key(s) that match the **Regular Expression**.
  * You can also choose these Regex-specific options:
      * **Case Insensitive**: Set whether the regular expression should match case (turned off) or be case insensitive (turned on).
      * **Max Depth**: Enter the maximum depth to replace keys, using `-1` for unlimited and `0` for top-level only.

  /// warning | Regex impacts
  Using a regular expression can affect any keys that match the expression, including keys you've already renamed.
  ///

  ## Templates and examples

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

troubleshooting_info:
  [{"issue":"Node parameters","solution":"You can rename one or multiple keys using the Rename Keys node. Select the **Add new key** button to rename a key."},{"issue":"Node options","solution":"Choose whether to use a **Regex** regular expression to identify keys to rename. To use this option, you must also enter:"}]

example_workflow:
  {"name":"Rename Keys Example Workflow","nodes":[{"parameters":{"keys":{},"additionalOptions":{}},"id":"jf9yqlbo2wbvbkgav90ssh","name":"Rename Keys","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"Keys","name":"keys","type":"fixedCollection","default":"{","description":"Adds a key which should be renamed","placeholder":"Add new key"},{"displayName":"Additional Options","name":"additionalOptions","type":"collection","default":"{","description":"Adds a regular expressiond","placeholder":"Add Option"}]


node_type: n8n-nodes-base.RssFeedRead
name: RssFeedRead
display_name: RSS Read
description: Reads data from an RSS Feed
category: input
icon: fa:rss
code_hash: 8fbc9da500347175bdd7371dfcc8ae68cb21a1fb3e39ded017aa4eff48724580
documentation_url: https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.RssFeedRead
documentation_title: RSS Read
operations: []
api_methods: []
documentation_examples: []
templates: [{"name":"rss-read","description":"Templates for rss-read"}]
required_scopes: []
parameter_schemas: []
example_parameters: {"url":"https://example.com","options":{}}
package_name: n8n-nodes-base
version: 1.0
extracted_at: 2025-06-12 08:59:09
updated_at: 2025-06-12 08:59:09
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.RssFeedRead = void 0;
  const n8n_workflow_1 = require("n8n-workflow");
  const rss_parser_1 = __importDefault(require("rss-parser"));
  const url_1 = require("url");
  const utilities_1 = require("../../utils/utilities");
  function validateURL(url) {
      try {
          new url_1.URL(url);
          return true;
      }
      catch (err) {
          return false;
      }
  }
  class RssFeedRead {
      constructor() {
          this.description = {
              displayName: 'RSS Read',
              name: 'rssFeedRead',
              icon: 'fa:rss',
              group: ['input'],
              version: 1,
              description: 'Reads data from an RSS Feed',
              defaults: {
                  name: 'RSS Read',
                  color: '#b02020',
              },
              inputs: ['main'],
              outputs: ['main'],
              properties: [
                  {
                      displayName: 'URL',
                      name: 'url',
                      type: 'string',
                      default: '',
                      required: true,
                      description: 'URL of the RSS feed',
                  },
                  {
                      displayName: 'Options',
                      name: 'options',
                      type: 'collection',
                      placeholder: 'Add Option',
                      default: {},
                      options: [
                          {
                              displayName: 'Ignore SSL Issues',
                              name: 'ignoreSSL',
                              type: 'boolean',
                              default: false,
                              description: 'Whether to ignore SSL/TLS certificate issues or not',
                          },
                      ],
                  },
              ],
          };
      }
      async execute() {
          const pairedItem = (0, utilities_1.generatePairedItemData)(this.getInputData().length);
          try {
              const url = this.getNodeParameter('url', 0);
              const options = this.getNodeParameter('options', 0);
              const ignoreSSL = Boolean(options.ignoreSSL);
              if (!url) {
                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The parameter "URL" has to be set!');
              }
              if (!validateURL(url)) {
                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'The provided "URL" is not valid!');
              }
              const parser = new rss_parser_1.default({
                  requestOptions: {
                      rejectUnauthorized: !ignoreSSL,
                  },
              });
              let feed;
              try {
                  feed = await parser.parseURL(url);
              }
              catch (error) {
                  if (error.code === 'ECONNREFUSED') {
                      throw new n8n_workflow_1.NodeOperationError(this.getNode(), `It was not possible to connect to the URL. Please make sure the URL "${url}" it is valid!`);
                  }
                  throw new n8n_workflow_1.NodeOperationError(this.getNode(), error);
              }
              const returnData = [];
              if (feed.items) {
                  feed.items.forEach((item) => {
                      returnData.push({
                          json: item,
                          pairedItem,
                      });
                  });
              }
              return [returnData];
          }
          catch (error) {
              if (this.continueOnFail()) {
                  return [[{ json: { error: error.message }, pairedItem }]];
              }
              throw error;
          }
      }
  }
  exports.RssFeedRead = RssFeedRead;
  //# sourceMappingURL=RssFeedRead.node.js.map

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

  # RSS Read

  Use the RSS Read node to read data from RSS feeds published on the internet.

  ## Node parameters

  - **URL**: Enter the URL for the RSS publication you want to read.

  ## Node options

  * **Ignore SSL Issues**: Choose whether n8n should ignore SSL/TLS verification (turned on) or not (turned off).

  ## Templates and examples

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

  ## Related resources

  n8n provides a trigger node for RSS Read. You can find the trigger node docs [here](/integrations/builtin/core-nodes/n8n-nodes-base.rssfeedreadtrigger.md).

related_resources:
  [{"title":"here","url":"/integrations/builtin/core-nodes/n8n-nodes-base.rssfeedreadtrigger.md","type":"documentation"}]

workflow_examples:
  [{"name":"rss-feed-example","workflow":{"nodes":[{"parameters":{},"type":"n8n-nodes-base.manualTrigger","typeVersion":1,"position":[0,0],"id":"e6e1cfe6-eff1-48bd-b21c-6ba83d4244d9","name":"When clicking ‘Execute workflow’"},{"parameters":{"jsCode":"return [\n\t{\n\t\tjson: {\n\t\t\turl: 'https://medium.com/feed/n8n-io',\n\t\t}\n\t},\n\t{\n\t\tjson: {\n\t\t\turl: 'https://dev.to/feed/n8n',\n\t\t}\n\t}\n];"},"type":"n8n-nodes-base.code","typeVersion":2,"position":[220,0],"id":"137f1128-45b6-4bc4-a9fb-8660baa652a9","name":"Code"},{"parameters":{"options":{}},"type":"n8n-nodes-base.splitInBatches","typeVersion":3,"position":[440,0],"id":"3449a953-49c2-4a36-ba3d-cbc0573f3f6c","name":"Loop Over Items"},{"parameters":{"url":"={{ $json.url }}","options":{}},"type":"n8n-nodes-base.rssFeedRead","typeVersion":1.1,"position":[660,100],"id":"cc2e59d7-0a9b-4640-8052-d8f7f8d8c9fe","name":"RSS Read"}],"connections":{"When clicking ‘Execute workflow’":{"main":[[{"node":"Code","type":"main","index":0}]]},"Code":{"main":[[{"node":"Loop Over Items","type":"main","index":0}]]},"Loop Over Items":{"main":[[],[{"node":"RSS Read","type":"main","index":0}]]},"RSS Read":{"main":[[{"node":"Loop Over Items","type":"main","index":0}]]}},"pinData":{},"meta":{"instanceId":"cb484ba7b742928a2048bf8829668bed5b5ad9787579adea888f05980292a4a7"}},"nodeConfigurations":[{"nodeType":"n8n-nodes-base.rssFeedRead","version":1.1,"parameters":{"url":"={{ $json.url }}","options":{}},"position":[660,100]}],"connections":{"When clicking ‘Execute workflow’":{"main":[[{"node":"Code","type":"main","index":0}]]},"Code":{"main":[[{"node":"Loop Over Items","type":"main","index":0}]]},"Loop Over Items":{"main":[[],[{"node":"RSS Read","type":"main","index":0}]]},"RSS Read":{"main":[[{"node":"Loop Over Items","type":"main","index":0}]]}},"source":"docs/_workflows/integrations/builtin/core-nodes/n8n-nodes-base.splitinbatches/rss-feed-example.json","description":"Workflow example from docs/_workflows/integrations/builtin/core-nodes/n8n-nodes-base.splitinbatches/rss-feed-example.json"}]

troubleshooting_info:
  [{"issue":"Node parameters","solution":"- **URL**: Enter the URL for the RSS publication you want to read."},{"issue":"Node options","solution":"* **Ignore SSL Issues**: Choose whether n8n should ignore SSL/TLS verification (turned on) or not (turned off)."}]

node_connections:
  [{"fromNode":"When clicking ‘Execute workflow’","toNode":"Code","connectionType":"main"},{"fromNode":"Code","toNode":"Loop Over Items","connectionType":"main"},{"fromNode":"Loop Over Items","toNode":"RSS Read","connectionType":"main"},{"fromNode":"RSS Read","toNode":"Loop Over Items","connectionType":"main"}]

example_workflow:
  {"name":"RSS Read Example Workflow","nodes":[{"parameters":{"url":"https://example.com","options":{}},"id":"blyyyr86knl2o78569cxpw","name":"RSS Read","type":"n8n-nodes-base.exampleNode","typeVersion":1,"position":[250,300]}],"connections":{},"active":false,"settings":{},"tags":["example","generated"]}

properties_schema:
  [{"displayName":"URL","name":"url","type":"string","default":"","required":true,"description":"URL of the RSS feed"},{"displayName":"Options","name":"options","type":"collection","default":"{","description":"Whether to ignore SSL/TLS certificate issues or not","placeholder":"Add Option"}]


