n8n-nodes-glimpse 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Glimpse HQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# n8n-nodes-glimpse
+
+This is an [n8n](https://n8n.io/) community node. It lets you use [Glimpse](https://www.glimpsehq.io) in your n8n workflows.
+
+Glimpse is a competitive intelligence platform that monitors your competitors across 20+ signal types - from blog posts and pricing changes to job postings, ad campaigns, tech stack updates, and more. This node lets you pull those signals into n8n workflows and trigger automations when new competitive activity is detected.
+
+[n8n community nodes docs](https://docs.n8n.io/integrations/community-nodes/)
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+## Credentials
+
+You need a Glimpse API key to authenticate:
+
+1. Log into [Glimpse](https://app.www.glimpsehq.io)
+2. Go to **Settings > Integrations**
+3. Under **API Keys**, click **Create new key**
+4. Give it a name (e.g. "n8n") and copy the key (starts with `glmp_`)
+5. In n8n, create a new **Glimpse API** credential and paste the key
+
+> The key is only shown once at creation. Store it securely.
+
+| Field | Description |
+|-------|-------------|
+| API Key | Your `glmp_...` key from Glimpse settings |
+| Base URL | Default: `https://app.www.glimpsehq.io`. Override for staging or self-hosted. |
+
+## Operations
+
+### Glimpse node
+
+The Glimpse node supports reading competitors and signals.
+
+**Competitor**
+
+| Operation | Description |
+|-----------|-------------|
+| Get All | List all monitored competitors in your organization |
+| Get | Retrieve a single competitor by ID |
+
+**Signal**
+
+| Operation | Description |
+|-----------|-------------|
+| Get All | Fetch competitive signals with optional filters |
+
+Signal filters:
+
+- **Competitor IDs** - comma-separated UUIDs to scope results
+- **Signal Types** - filter by one or more of 23 signal types
+- **Days** - only return signals from the last N days
+- **Limit** - max results per request (up to 500)
+
+### Glimpse Trigger node
+
+The Glimpse Trigger node polls for new competitive signals and fires when new activity is detected.
+
+| Field | Description |
+|-------|-------------|
+| Competitor IDs | Optional. Comma-separated UUIDs to watch. Leave empty for all. |
+| Signal Types | Optional. Multi-select filter. Leave empty for all types. |
+
+The trigger uses n8n's built-in polling interval (default: 5 minutes). On each poll, it fetches the latest signals and only emits ones that are newer than the last poll.
+
+## Supported signal types
+
+| Signal | Description |
+|--------|-------------|
+| blog_post | New blog article published |
+| pricing_change | Pricing page updated |
+| job_posting | New job listing detected |
+| job_removed | Job listing taken down |
+| tech_added | New technology detected in stack |
+| tech_removed | Technology removed from stack |
+| tech_stack_update | General stack change |
+| news_mention | Competitor mentioned in the news |
+| newsletter | Newsletter issue sent |
+| ebook | New ebook or gated content |
+| webinar | New webinar recording |
+| webinar_upcoming | Upcoming webinar announced |
+| linkedin_ad | New LinkedIn ad detected |
+| social_post | Social media post |
+| youtube_video | New YouTube video published |
+| instagram_post | New Instagram post |
+| facebook_post | New Facebook post |
+| facebook_ad | New Facebook ad detected |
+| google_ad | New Google ad detected |
+| user_review | New user review on G2, Capterra, etc. |
+| sitemap_update | Website sitemap changed |
+| page_change | Monitored page content changed |
+| leadership_change | Leadership team update |
+
+## Example workflows
+
+**Slack alert on pricing changes**
+Glimpse Trigger (types: pricing_change) -> Slack: Send Message
+
+**Weekly competitor digest to email**
+Schedule (weekly) -> Glimpse: Get All Signals (days: 7) -> Gmail: Send Email
+
+**Log new signals to Google Sheets**
+Glimpse Trigger -> Google Sheets: Append Row
+
+**Enrich with AI summary**
+Glimpse Trigger -> OpenAI: Summarize -> Slack: Send Message
+
+## Compatibility
+
+- Minimum n8n version: **1.0.0**
+- Tested with: n8n 1.x
+
+## Resources
+
+- [n8n community nodes documentation](https://docs.n8n.io/integrations/community-nodes/)
+- [Glimpse website](https://www.glimpsehq.io)
+- [Glimpse API documentation](https://www.glimpsehq.io/docs/api)
+
+## License
+
+[MIT](LICENSE)

package/dist/credentials/GlimpseApi.credentials.d.ts

@@ -0,0 +1,8 @@
+import type { IAuthenticateGeneric, ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class GlimpseApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+}

package/dist/credentials/GlimpseApi.credentials.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlimpseApi = void 0;
+class GlimpseApi {
+    constructor() {
+        this.name = 'glimpseApi';
+        this.displayName = 'Glimpse API';
+        this.documentationUrl = 'https://www.glimpsehq.io/docs/api';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                placeholder: 'glmp_...',
+                description: 'Your Glimpse API key. Generate one in Settings > Integrations.',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'https://app.glimpsehq.io',
+                description: 'Override for self-hosted or staging environments',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer ' + '{{$credentials.apiKey}}',
+                },
+            },
+        };
+    }
+}
+exports.GlimpseApi = GlimpseApi;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { GlimpseApi } from './credentials/GlimpseApi.credentials';
+export { Glimpse } from './nodes/Glimpse/Glimpse.node';
+export { GlimpseTrigger } from './nodes/Glimpse/GlimpseTrigger.node';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlimpseTrigger = exports.Glimpse = exports.GlimpseApi = void 0;
+var GlimpseApi_credentials_1 = require("./credentials/GlimpseApi.credentials");
+Object.defineProperty(exports, "GlimpseApi", { enumerable: true, get: function () { return GlimpseApi_credentials_1.GlimpseApi; } });
+var Glimpse_node_1 = require("./nodes/Glimpse/Glimpse.node");
+Object.defineProperty(exports, "Glimpse", { enumerable: true, get: function () { return Glimpse_node_1.Glimpse; } });
+var GlimpseTrigger_node_1 = require("./nodes/Glimpse/GlimpseTrigger.node");
+Object.defineProperty(exports, "GlimpseTrigger", { enumerable: true, get: function () { return GlimpseTrigger_node_1.GlimpseTrigger; } });

package/dist/nodes/Glimpse/Glimpse.node.d.ts

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Glimpse implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Glimpse/Glimpse.node.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Glimpse = void 0;
+const SIGNAL_TYPES = [
+    'blog_post', 'pricing_change', 'job_posting', 'job_removed',
+    'tech_added', 'tech_removed', 'tech_stack_update',
+    'news_mention', 'newsletter', 'ebook', 'webinar', 'webinar_upcoming',
+    'linkedin_ad', 'social_post', 'youtube_video', 'instagram_post',
+    'facebook_post', 'facebook_ad', 'google_ad', 'user_review',
+    'sitemap_update', 'page_change', 'leadership_change',
+];
+class Glimpse {
+    constructor() {
+        this.description = {
+            displayName: 'Glimpse',
+            name: 'glimpse',
+            icon: 'file:glimpse.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Read data from the Glimpse competitive intelligence API',
+            defaults: { name: 'Glimpse' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'glimpseApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Competitor', value: 'competitor' },
+                        { name: 'Signal', value: 'signal' },
+                    ],
+                    default: 'signal',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['competitor'] } },
+                    options: [
+                        { name: 'Get All', value: 'getAll', action: 'Get all competitors' },
+                        { name: 'Get', value: 'get', action: 'Get a competitor' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Competitor ID',
+                    name: 'competitorId',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { resource: ['competitor'], operation: ['get'] } },
+                    default: '',
+                    description: 'The UUID of the competitor to retrieve',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'competitorLimit',
+                    type: 'number',
+                    displayOptions: { show: { resource: ['competitor'], operation: ['getAll'] } },
+                    default: 100,
+                    description: 'Max number of competitors to return (max 500)',
+                    typeOptions: { minValue: 1, maxValue: 500 },
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: { show: { resource: ['signal'] } },
+                    options: [
+                        { name: 'Get All', value: 'getAll', action: 'Get all signals' },
+                    ],
+                    default: 'getAll',
+                },
+                {
+                    displayName: 'Additional Filters',
+                    name: 'signalFilters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: { show: { resource: ['signal'], operation: ['getAll'] } },
+                    options: [
+                        {
+                            displayName: 'Competitor IDs',
+                            name: 'competitorIds',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma-separated competitor UUIDs to filter by',
+                        },
+                        {
+                            displayName: 'Signal Types',
+                            name: 'types',
+                            type: 'multiOptions',
+                            options: SIGNAL_TYPES.map((t) => ({ name: t.replace(/_/g, ' '), value: t })),
+                            default: [],
+                            description: 'Filter by signal types',
+                        },
+                        {
+                            displayName: 'Days',
+                            name: 'days',
+                            type: 'number',
+                            default: 7,
+                            description: 'Only return signals from the last N days',
+                            typeOptions: { minValue: 1 },
+                        },
+                        {
+                            displayName: 'Limit',
+                            name: 'limit',
+                            type: 'number',
+                            default: 50,
+                            description: 'Max signals to return (max 500)',
+                            typeOptions: { minValue: 1, maxValue: 500 },
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const credentials = await this.getCredentials('glimpseApi');
+        const baseUrl = credentials.baseUrl.replace(/\/$/, '');
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        let responseData;
+        if (resource === 'competitor') {
+            if (operation === 'get') {
+                const id = this.getNodeParameter('competitorId', 0);
+                responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'glimpseApi', {
+                    method: 'GET',
+                    url: baseUrl + '/api/v1/competitors/' + id,
+                    json: true,
+                });
+            }
+            else {
+                const limit = this.getNodeParameter('competitorLimit', 0);
+                responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'glimpseApi', {
+                    method: 'GET',
+                    url: baseUrl + '/api/v1/competitors',
+                    qs: { limit },
+                    json: true,
+                });
+            }
+        }
+        else {
+            const filters = this.getNodeParameter('signalFilters', 0, {});
+            const qs = {};
+            if (filters.competitorIds)
+                qs.competitor_ids = filters.competitorIds;
+            if (filters.types && filters.types.length)
+                qs.types = filters.types.join(',');
+            if (filters.days)
+                qs.days = String(filters.days);
+            if (filters.limit)
+                qs.limit = String(filters.limit);
+            responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'glimpseApi', {
+                method: 'GET',
+                url: baseUrl + '/api/v1/signals',
+                qs,
+                json: true,
+            });
+        }
+        const items = Array.isArray(responseData.data)
+            ? responseData.data
+            : [responseData];
+        return [this.helpers.returnJsonArray(items)];
+    }
+}
+exports.Glimpse = Glimpse;

package/dist/nodes/Glimpse/GlimpseTrigger.node.d.ts

@@ -0,0 +1,5 @@
+import type { IPollFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class GlimpseTrigger implements INodeType {
+    description: INodeTypeDescription;
+    poll(this: IPollFunctions): Promise<INodeExecutionData[][] | null>;
+}

package/dist/nodes/Glimpse/GlimpseTrigger.node.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlimpseTrigger = void 0;
+const SIGNAL_TYPES = [
+    'blog_post', 'pricing_change', 'job_posting', 'job_removed',
+    'tech_added', 'tech_removed', 'tech_stack_update',
+    'news_mention', 'newsletter', 'ebook', 'webinar', 'webinar_upcoming',
+    'linkedin_ad', 'social_post', 'youtube_video', 'instagram_post',
+    'facebook_post', 'facebook_ad', 'google_ad', 'user_review',
+    'sitemap_update', 'page_change', 'leadership_change',
+];
+class GlimpseTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Glimpse Trigger',
+            name: 'glimpseTrigger',
+            icon: 'file:glimpse.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: 'New competitive signal',
+            description: 'Triggers when new competitive intelligence signals are detected in Glimpse',
+            defaults: {
+                name: 'Glimpse Trigger',
+            },
+            polling: true,
+            inputs: [],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'glimpseApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Competitor IDs',
+                    name: 'competitorIds',
+                    type: 'string',
+                    default: '',
+                    description: 'Comma-separated competitor UUIDs. Leave empty for all competitors.',
+                },
+                {
+                    displayName: 'Signal Types',
+                    name: 'types',
+                    type: 'multiOptions',
+                    options: SIGNAL_TYPES.map((t) => ({ name: t.replace(/_/g, ' '), value: t })),
+                    default: [],
+                    description: 'Filter by signal types. Leave empty for all types.',
+                },
+            ],
+        };
+    }
+    async poll() {
+        const credentials = await this.getCredentials('glimpseApi');
+        const baseUrl = credentials.baseUrl.replace(/\/$/, '');
+        const competitorIds = this.getNodeParameter('competitorIds', '');
+        const types = this.getNodeParameter('types', []);
+        const staticData = this.getWorkflowStaticData('node');
+        const lastPollTime = staticData.lastPollTime;
+        const qs = {
+            days: '1',
+            limit: '100',
+        };
+        if (competitorIds)
+            qs.competitor_ids = competitorIds;
+        if (types.length)
+            qs.types = types.join(',');
+        const responseData = await this.helpers.httpRequestWithAuthentication.call(this, 'glimpseApi', {
+            method: 'GET',
+            url: baseUrl + '/api/v1/signals',
+            qs,
+            json: true,
+        });
+        const signals = responseData.data || [];
+        const newSignals = lastPollTime
+            ? signals.filter((s) => {
+                const signalTime = s.published_at || s.created_at;
+                return signalTime > lastPollTime;
+            })
+            : signals;
+        if (newSignals.length > 0) {
+            const mostRecent = newSignals.reduce((latest, s) => {
+                const t = s.published_at || s.created_at;
+                return t > latest ? t : latest;
+            }, '');
+            staticData.lastPollTime = mostRecent;
+        }
+        else if (!lastPollTime) {
+            staticData.lastPollTime = new Date().toISOString();
+        }
+        if (newSignals.length === 0)
+            return null;
+        return [this.helpers.returnJsonArray(newSignals)];
+    }
+}
+exports.GlimpseTrigger = GlimpseTrigger;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "n8n-nodes-glimpse",
+  "version": "0.1.0",
+  "description": "N8N community node for Glimpse - competitive intelligence signals",
+  "license": "MIT",
+  "author": {
+    "name": "Glimpse",
+    "url": "https://www.glimpsehq.io"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sven-glimpse/n8n-nodes-glimpse"
+  },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/GlimpseApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Glimpse/Glimpse.node.js",
+      "dist/nodes/Glimpse/GlimpseTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "n8n-workflow": "^1.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "^1.0.0"
+  },
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "glimpse",
+    "competitive-intelligence",
+    "signals"
+  ],
+  "files": [
+    "dist"
+  ]
+}