@seranking/n8n-nodes-seranking 1.3.8 → 1.4.0

package/README.md

@@ -574,7 +574,7 @@ For detailed API specifications, visit [SE Ranking API Documentation](https://se
 - ✅ **NEW: Get Domain Pages** - Page-level keyword and traffic analysis with intent breakdown
 - ✅ **NEW: Get Domain Subdomains** - Subdomain traffic and keyword metrics
 - ✅ **Total: 62 operations across 6 resources**
-- ✅ Advanced filtering for pages/subdomains (traffic %, keywords count, traffic sum)
+- ✅ Advanced filtering for pages/subdomains (traffic %, keywords count, traffic sum,)
 - ✅ Search intent breakdown (Informational, Navigational, Transactional, Commercial, Local)
 
 ### v1.3.0 
@@ -659,7 +659,7 @@ For detailed API specifications, visit [SE Ranking API Documentation](https://se
 
 ✅ **SERP Tracking** - Keyword ranking and SERP features analysis
 
-✅ **Advanced Filtering** - Volume, position, CPC, difficulty, traffic, search intent, SERP features, keyword word count, and include/exclude keyword pattern filters
+✅ **Advanced Filtering** - Volume, position, CPC, difficulty, traffic, search intent, SERP features, keyword word count, and include/exclude keyword pattern filters, and the new SERP Feature Link filter (filter[serp_features_2]) — which lets you filter keywords where your domain is specifically linked within a SERP feature (e.g. AI Overviews, Reviews), distinct from the existing serpFeatures filter which only checks for feature presence on the SERP.
 
 ---
 

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/descriptions/DomainAnalysisDescription.js

@@ -943,6 +943,41 @@ exports.domainAnalysisFields = [
                 default: [],
                 description: 'Filter keywords by search intent',
             },
+            {
+                displayName: 'Include Keywords Containing',
+                name: 'multiKeywordIncluded',
+                type: 'string',
+                default: '',
+                placeholder: 'best, top, review',
+                description: 'Comma-separated words that must appear in results',
+            },
+            {
+                displayName: 'Exclude Keywords Containing',
+                name: 'multiKeywordExcluded',
+                type: 'string',
+                default: '',
+                placeholder: 'free, cheap',
+                description: 'Comma-separated words that must NOT appear in results',
+            },
+            {
+                displayName: 'SERP Feature Link Mode',
+                name: 'serpFeatures2Mode',
+                type: 'options',
+                options: [
+                    { name: 'With Link', value: 'with_link' },
+                    { name: 'Without Link', value: 'without_link' },
+                ],
+                default: 'with_link',
+                description: 'Filter by whether the analyzed domain is linked inside a SERP feature. Must be used together with SERP Feature Link Value.',
+            },
+            {
+                displayName: 'SERP Feature Link Value',
+                name: 'serpFeatures2Value',
+                type: 'string',
+                default: '',
+                placeholder: 'sge,reviews',
+                description: 'Comma-separated SERP feature codes to check domain linkage for. Must be used together with SERP Feature Link Mode.',
+            },
         ],
     },
     {

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/dist/nodes/SeRanking/dataApi/operations/DomainAnalysisOperations.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DomainAnalysisOperations = DomainAnalysisOperations;
 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 DomainAnalysisOperations(index) {
     const operation = this.getNodeParameter('operation', index);
     let endpoint = '';
@@ -238,6 +245,22 @@ async function DomainAnalysisOperations(index) {
             if (additionalFields.intents && additionalFields.intents.length > 0) {
                 params['filter[intents]'] = additionalFields.intents.join(',');
             }
+            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));
+            }
+            if (additionalFields.serpFeatures2Mode && additionalFields.serpFeatures2Value) {
+                params['filter[serp_features_2][mode]'] = additionalFields.serpFeatures2Mode;
+                additionalFields.serpFeatures2Value
+                    .split(',')
+                    .map((v) => v.trim())
+                    .filter(Boolean)
+                    .forEach((val, i) => {
+                    params[`filter[serp_features_2][value][${i}]`] = val;
+                });
+            }
             break;
         }
         case 'getKeywordsComparison': {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@seranking/n8n-nodes-seranking",
-    "version": "1.3.8",
+    "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",