@seranking/n8n-nodes-seranking 1.3.9 → 1.4.0

package/dist/nodes/SeRanking/dataApi/descriptions/AiSearchDescription.js

@@ -90,31 +90,11 @@ exports.aiSearchFields = [
             },
         },
         options: [
-            {
-                name: 'AI Overview',
-                value: 'ai-overview',
-                description: 'Google AI Overview results',
-            },
-            {
-                name: 'ChatGPT',
-                value: 'chatgpt',
-                description: 'OpenAI ChatGPT results',
-            },
-            {
-                name: 'Perplexity',
-                value: 'perplexity',
-                description: 'Perplexity AI results',
-            },
-            {
-                name: 'Gemini',
-                value: 'gemini',
-                description: 'Google Gemini results',
-            },
-            {
-                name: 'AI Mode',
-                value: 'ai-mode',
-                description: 'AI Mode results',
-            },
+            { name: 'AI Overview', value: 'ai-overview', description: 'Google AI Overview results' },
+            { name: 'ChatGPT', value: 'chatgpt', description: 'OpenAI ChatGPT results' },
+            { name: 'Perplexity', value: 'perplexity', description: 'Perplexity AI results' },
+            { name: 'Gemini', value: 'gemini', description: 'Google Gemini results' },
+            { name: 'AI Mode', value: 'ai-mode', description: 'AI Mode results' },
         ],
         default: 'chatgpt',
         description: 'The LLM engine to query',
@@ -144,24 +124,35 @@ exports.aiSearchFields = [
             },
         },
         options: [
-            {
-                name: 'Base Domain',
-                value: 'base_domain',
-                description: 'Aggregate by registrable domain, includes all subdomains',
-            },
-            {
-                name: 'Domain',
-                value: 'domain',
-                description: 'Exact host only, no subdomain aggregation',
+            { name: 'Base Domain', value: 'base_domain', description: 'Aggregate by registrable domain, includes all subdomains' },
+            { name: 'Domain', value: 'domain', description: 'Exact host only, no subdomain aggregation' },
+            { name: 'URL', value: 'url', description: 'Exact URL including path and query' },
+        ],
+        default: 'base_domain',
+        description: 'Scope of analysis - base_domain is recommended for most use cases',
+    },
+    {
+        displayName: 'Additional Fields',
+        name: 'additionalFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                resource: ['aiSearch'],
+                operation: ['getOverview'],
             },
+        },
+        options: [
             {
-                name: 'URL',
-                value: 'url',
-                description: 'Exact URL including path and query',
+                displayName: 'Brand',
+                name: 'brand',
+                type: 'string',
+                default: '',
+                placeholder: 'SE Ranking',
+                description: 'Brand name to filter the brand presence analysis',
             },
         ],
-        default: 'base_domain',
-        description: 'Scope of analysis - base_domain is recommended for most use cases',
     },
     {
         displayName: 'Additional Fields',
@@ -181,21 +172,9 @@ exports.aiSearchFields = [
                 name: 'sort',
                 type: 'options',
                 options: [
-                    {
-                        name: 'Volume',
-                        value: 'volume',
-                        description: 'Sort by search volume',
-                    },
-                    {
-                        name: 'Type',
-                        value: 'type',
-                        description: 'Sort by appearance type (Link, Brand, etc.)',
-                    },
-                    {
-                        name: 'Snippet Length',
-                        value: 'snippet_length',
-                        description: 'Sort by length of the LLM snippet',
-                    },
+                    { name: 'Volume', value: 'volume', description: 'Sort by search volume' },
+                    { name: 'Type', value: 'type', description: 'Sort by appearance type (Link, Brand, etc.)' },
+                    { name: 'Snippet Length', value: 'snippet_length', description: 'Sort by length of the LLM snippet' },
                 ],
                 default: 'volume',
                 description: 'Field to sort results by',
@@ -205,16 +184,8 @@ exports.aiSearchFields = [
                 name: 'sortOrder',
                 type: 'options',
                 options: [
-                    {
-                        name: 'Descending',
-                        value: 'desc',
-                        description: 'Highest to lowest',
-                    },
-                    {
-                        name: 'Ascending',
-                        value: 'asc',
-                        description: 'Lowest to highest',
-                    },
+                    { name: 'Descending', value: 'desc', description: 'Highest to lowest' },
+                    { name: 'Ascending', value: 'asc', description: 'Lowest to highest' },
                 ],
                 default: 'desc',
                 description: 'Order of sorting',
@@ -225,10 +196,7 @@ exports.aiSearchFields = [
                 type: 'number',
                 default: 100,
                 description: 'Maximum number of results to return per page (max 1000)',
-                typeOptions: {
-                    minValue: 1,
-                    maxValue: 1000,
-                },
+                typeOptions: { minValue: 1, maxValue: 1000 },
             },
             {
                 displayName: 'Offset',
@@ -236,9 +204,67 @@ exports.aiSearchFields = [
                 type: 'number',
                 default: 0,
                 description: 'Number of results to skip for pagination',
-                typeOptions: {
-                    minValue: 0,
-                },
+                typeOptions: { minValue: 0 },
+            },
+            {
+                displayName: 'Volume From',
+                name: 'volumeFrom',
+                type: 'number',
+                default: 0,
+                description: 'Minimum monthly search volume for prompts',
+            },
+            {
+                displayName: 'Volume To',
+                name: 'volumeTo',
+                type: 'number',
+                default: 0,
+                description: 'Maximum monthly search volume (0 = no limit)',
+            },
+            {
+                displayName: 'Keyword Word Count From',
+                name: 'keywordCountFrom',
+                type: 'number',
+                default: 0,
+                description: 'Minimum number of words in a prompt',
+                typeOptions: { minValue: 1 },
+            },
+            {
+                displayName: 'Keyword Word Count To',
+                name: 'keywordCountTo',
+                type: 'number',
+                default: 0,
+                description: 'Maximum number of words in a prompt (0 = no limit)',
+            },
+            {
+                displayName: 'Characters Count From',
+                name: 'charactersCountFrom',
+                type: 'number',
+                default: 0,
+                description: 'Minimum character length of a prompt',
+                typeOptions: { minValue: 1 },
+            },
+            {
+                displayName: 'Characters Count To',
+                name: 'charactersCountTo',
+                type: 'number',
+                default: 0,
+                description: 'Maximum character length of a prompt (0 = no limit)',
+            },
+            {
+                displayName: 'Include Keywords Containing',
+                name: 'multiKeywordIncluded',
+                type: 'string',
+                default: '',
+                placeholder: 'best, top, review',
+                description: 'Comma-separated words that must appear in the prompt text',
+            },
+            {
+                displayName: 'Exclude Keywords Containing',
+                name: 'multiKeywordExcluded',
+                type: 'string',
+                default: '',
+                placeholder: 'free, cheap',
+                description: 'Comma-separated words that must NOT appear in the prompt text',
             },
         ],
     },
@@ -261,7 +287,7 @@ exports.aiSearchFields = [
         displayName: 'Primary Brand',
         name: 'primaryBrand',
         type: 'string',
-        required: true,
+        required: false,
         displayOptions: {
             show: {
                 resource: ['aiSearch'],
@@ -306,7 +332,7 @@ exports.aiSearchFields = [
                         type: 'string',
                         default: '',
                         placeholder: 'Semrush',
-                        description: 'Competitor brand name',
+                        description: 'Competitor brand name (optional)',
                     },
                 ],
             },
@@ -325,16 +351,9 @@ exports.aiSearchFields = [
             },
         },
         options: [
-            {
-                name: 'Base Domain',
-                value: 'base_domain',
-                description: 'Aggregate by registrable domain',
-            },
-            {
-                name: 'Exact URL',
-                value: 'exact_url',
-                description: 'Exact URL matching',
-            },
+            { name: 'Base Domain', value: 'base_domain', description: 'Aggregate by registrable domain, includes all subdomains' },
+            { name: 'Domain', value: 'domain', description: 'Exact host only, no subdomain aggregation' },
+            { name: 'URL', value: 'url', description: 'Exact URL including path and query' },
         ],
         default: 'base_domain',
         description: 'Scope of analysis',
@@ -351,26 +370,11 @@ exports.aiSearchFields = [
             },
         },
         options: [
-            {
-                name: 'AI Overview (Google)',
-                value: 'ai-overview',
-            },
-            {
-                name: 'ChatGPT',
-                value: 'chatgpt',
-            },
-            {
-                name: 'Perplexity',
-                value: 'perplexity',
-            },
-            {
-                name: 'Gemini',
-                value: 'gemini',
-            },
-            {
-                name: 'AI Mode',
-                value: 'ai-mode',
-            },
+            { name: 'AI Overview (Google)', value: 'ai-overview' },
+            { name: 'ChatGPT', value: 'chatgpt' },
+            { name: 'Perplexity', value: 'perplexity' },
+            { name: 'Gemini', value: 'gemini' },
+            { name: 'AI Mode', value: 'ai-mode' },
         ],
         default: ['ai-overview', 'chatgpt', 'perplexity'],
         description: 'LLM engines to compare across',

package/dist/nodes/SeRanking/dataApi/operations/AiSearchOperations.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiSearchOperations = AiSearchOperations;
 const apiRequest_1 = require("../../utils/apiRequest");
 const validators_1 = require("../../utils/validators");
+function buildMultiKeywordFilter(csv) {
+    return csv
+        .split(',')
+        .map((w) => w.trim())
+        .filter(Boolean)
+        .map((word) => [{ type: 'contains', value: word }]);
+}
 async function AiSearchOperations(index) {
     const operation = this.getNodeParameter('operation', index);
     let endpoint = '';
@@ -13,11 +20,14 @@ async function AiSearchOperations(index) {
             const engine = this.getNodeParameter('engine', index);
             const source = this.getNodeParameter('source', index);
             const scope = this.getNodeParameter('scope', index, 'base_domain');
+            const additionalFields = this.getNodeParameter('additionalFields', index, {});
             endpoint = '/ai-search/overview/by-engine/time-series';
             params.target = (0, validators_1.validateDomain)(domain);
             params.engine = engine;
             params.source = (0, validators_1.validateSource)(source);
             params.scope = scope;
+            if (additionalFields.brand)
+                params.brand = additionalFields.brand;
             break;
         }
         case 'discoverBrand': {
@@ -49,6 +59,24 @@ async function AiSearchOperations(index) {
                 params.limit = additionalFields.limit;
             if (additionalFields.offset)
                 params.offset = additionalFields.offset;
+            if (additionalFields.volumeFrom)
+                params['filter[volume][from]'] = additionalFields.volumeFrom;
+            if (additionalFields.volumeTo)
+                params['filter[volume][to]'] = additionalFields.volumeTo;
+            if (additionalFields.keywordCountFrom)
+                params['filter[keyword_count][from]'] = additionalFields.keywordCountFrom;
+            if (additionalFields.keywordCountTo)
+                params['filter[keyword_count][to]'] = additionalFields.keywordCountTo;
+            if (additionalFields.charactersCountFrom)
+                params['filter[characters_count][from]'] = additionalFields.charactersCountFrom;
+            if (additionalFields.charactersCountTo)
+                params['filter[characters_count][to]'] = additionalFields.charactersCountTo;
+            if (additionalFields.multiKeywordIncluded) {
+                params['filter[multi_keyword_included]'] = JSON.stringify(buildMultiKeywordFilter(additionalFields.multiKeywordIncluded));
+            }
+            if (additionalFields.multiKeywordExcluded) {
+                params['filter[multi_keyword_excluded]'] = JSON.stringify(buildMultiKeywordFilter(additionalFields.multiKeywordExcluded));
+            }
             break;
         }
         case 'getPromptsByBrand': {
@@ -71,6 +99,24 @@ async function AiSearchOperations(index) {
                 params.limit = additionalFields.limit;
             if (additionalFields.offset)
                 params.offset = additionalFields.offset;
+            if (additionalFields.volumeFrom)
+                params['filter[volume][from]'] = additionalFields.volumeFrom;
+            if (additionalFields.volumeTo)
+                params['filter[volume][to]'] = additionalFields.volumeTo;
+            if (additionalFields.keywordCountFrom)
+                params['filter[keyword_count][from]'] = additionalFields.keywordCountFrom;
+            if (additionalFields.keywordCountTo)
+                params['filter[keyword_count][to]'] = additionalFields.keywordCountTo;
+            if (additionalFields.charactersCountFrom)
+                params['filter[characters_count][from]'] = additionalFields.charactersCountFrom;
+            if (additionalFields.charactersCountTo)
+                params['filter[characters_count][to]'] = additionalFields.charactersCountTo;
+            if (additionalFields.multiKeywordIncluded) {
+                params['filter[multi_keyword_included]'] = JSON.stringify(buildMultiKeywordFilter(additionalFields.multiKeywordIncluded));
+            }
+            if (additionalFields.multiKeywordExcluded) {
+                params['filter[multi_keyword_excluded]'] = JSON.stringify(buildMultiKeywordFilter(additionalFields.multiKeywordExcluded));
+            }
             break;
         }
         case 'getLeaderboard': {
@@ -83,30 +129,30 @@ async function AiSearchOperations(index) {
             if (!primaryTarget || primaryTarget.trim() === '') {
                 throw new Error('Primary target domain is required');
             }
-            if (!primaryBrand || primaryBrand.trim() === '') {
-                throw new Error('Primary brand name is required');
-            }
             const competitors = [];
             if (competitorsData.competitorValues && Array.isArray(competitorsData.competitorValues)) {
                 for (const comp of competitorsData.competitorValues) {
-                    if (comp.target && comp.brand) {
-                        competitors.push({
+                    if (comp.target) {
+                        const entry = {
                             target: (0, validators_1.validateDomain)(comp.target),
-                            brand: comp.brand.trim(),
-                        });
+                        };
+                        if (comp.brand)
+                            entry.brand = comp.brand.trim();
+                        competitors.push(entry);
                     }
                 }
             }
             const body = {
                 primary: {
                     target: (0, validators_1.validateDomain)(primaryTarget),
-                    brand: primaryBrand.trim(),
                 },
                 competitors,
                 scope,
                 source: (0, validators_1.validateSource)(source),
                 engines,
             };
+            if (primaryBrand)
+                body.primary.brand = primaryBrand.trim();
             return await apiRequest_1.apiRequest.call(this, 'POST', '/ai-search/overview/leaderboard', body, {}, index);
         }
         default:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@seranking/n8n-nodes-seranking",
-    "version": "1.3.9",
+    "version": "1.4.0",
     "description": "n8n connector for SE Ranking API - AI Search, Backlinks, Domain Analysis, Keyword Research, and Website Audit",
     "license": "MIT",
     "homepage": "https://github.com/seranking/n8n-nodes-seranking",