n8n-nodes-veridion 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Veridion
+
+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,148 @@
+# n8n-nodes-veridion
+
+An [n8n](https://n8n.io) community node for the Veridion company data APIs. It currently includes three operations inside a single `Veridion` node:
+
+- `Enrich Company`
+- `Company Search`
+- `Supplier Search`
+
+---
+
+## What it does
+
+- **Enrich Company** matches a known company and returns the enriched Veridion company profile.
+- **Company Search** discovers companies using location, industry, NAICS, keyword, and company-size filters.
+- **Supplier Search** discovers suppliers using grouped product keyword logic plus optional supplier and company-level filters.
+
+---
+
+## Installation
+
+### Community Nodes UI (n8n ≥ 0.187)
+
+1. Open your n8n instance → **Settings → Community Nodes**.
+2. Click **Install a community node**.
+3. Enter `n8n-nodes-veridion` and confirm.
+
+### Manual (self-hosted)
+
+```bash
+cd ~/.n8n/custom   # or your n8n custom-extensions path
+npm install n8n-nodes-veridion
+```
+
+Restart n8n after installation.
+
+---
+
+## Credentials
+
+Create a **Veridion API** credential in n8n and paste your Veridion API key into the **API Key** field. The key is sent via the `x-api-key` request header.
+
+---
+
+## Enrich Company
+
+### Required
+
+| Parameter | Description | API field |
+|---|---|---|
+| Legal Name | Official registered name | `legal_names` (array) |
+| Commercial Name | Trading / brand name | `commercial_names` (array) |
+
+### Optional
+
+| Parameter | Description | API field |
+|---|---|---|
+| Website | Company website domain or URL | `website` |
+| Address | Free-text address | `address_txt` |
+| Phone Number | Company phone number | `phone_number` |
+| Registry ID | Company registry or tax ID | `registry_id` |
+| Minimum Confidence Score | Match threshold 0–1 (default `0.6`) | `min_confidence_score` query param |
+
+Empty optional fields are stripped from the request body before sending.
+
+---
+
+## Search Operations
+
+### Company Search
+
+- Shared filters: country, region, city, postcode, industries, NAICS, employee count, revenue, year founded, page size, pagination token
+- Company-only filters: keywords, exclude keywords, keyword strictness
+- Industry values are loaded live from `GET /industries/v0`
+
+### Supplier Search
+
+- Shared filters: country, region, city, postcode, industries, NAICS, employee count, revenue, year founded, page size, pagination token
+- Supplier-only filters:
+  - `Product Keywords Group 1`
+  - `Product Keywords Group 2`
+  - `Product Keywords Group 3`
+  - `Product Exclude Keywords`
+  - `Supplier Types`
+  - `Proximity Address`
+  - `Proximity Radius`
+  - `Proximity Unit`
+- Supplier keyword groups follow the Make-style logic:
+  - OR within a group
+  - AND across groups
+
+## Output structure
+
+### Successful match (`HTTP 200`)
+
+The full Veridion company JSON object is passed through as the node output. Example top-level keys:
+
+```json
+{
+  "legal_name": "Acme Corporation",
+  "website_domain": "acme.com",
+  "main_country_code": "US",
+  "employee_count": 520,
+  "revenue_range": "10M-50M",
+  "industries": ["Manufacturing", "Industrial Machinery"],
+  ...
+}
+```
+
+### No match (`HTTP 202`)
+
+```json
+{
+  "matched": false,
+  "reason": "No match found above the requested confidence threshold"
+}
+```
+
+### Errors
+
+`400` responses surface the API's error message as a descriptive `NodeApiError`. All other non-2xx statuses also throw a `NodeApiError` with the HTTP status code attached.
+
+---
+
+## Edge cases
+
+- If neither **Legal Name** nor **Commercial Name** is filled in, the node throws a descriptive error **before** making any API call.
+- `legal_names` and `commercial_names` are always sent as arrays (Veridion API requirement), even though the node accepts a single string.
+- Optional fields with empty string values are stripped from the request body.
+- Search responses can be returned either as one item per company or as a single full-response item, depending on `Output Mode`.
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/veridion/n8n-nodes-veridion.git
+cd n8n-nodes-veridion
+npm install
+npm run build   # compile TypeScript → dist/
+npm run dev     # watch mode
+npm run lint    # ESLint check
+```
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

package/dist/credentials/VeridionApi.credentials.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeridionApi = void 0;
+class VeridionApi {
+    constructor() {
+        this.name = 'veridionApi';
+        this.displayName = 'Veridion API';
+        this.documentationUrl = 'https://developer.veridion.com/docs/getting-started';
+        this.icon = 'file:../nodes/Veridion/veridion.svg';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'The API key from your Veridion account (x-api-key header)',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    'x-api-key': '={{$credentials.apiKey}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://data.veridion.com',
+                url: '/match/v5/companies',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                // Minimal valid body to validate the key — expect 200 or 202, not 401/403
+                body: JSON.stringify({ legal_names: ['Acme Corporation'] }),
+            },
+        };
+    }
+}
+exports.VeridionApi = VeridionApi;

package/dist/nodes/Veridion/Veridion.node.js

@@ -0,0 +1,846 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Veridion = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+// ─── Node definition ────────────────────────────────────────────────────────
+class Veridion {
+    constructor() {
+        this.description = {
+            displayName: 'Veridion',
+            name: 'veridion',
+            icon: 'file:veridion.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Match and enrich company data using the Veridion API',
+            defaults: {
+                name: 'Veridion',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'veridionApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                // ── Operation selector ──────────────────────────────────────────
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Enrich Company',
+                            value: 'enrichCompany',
+                            description: 'Match a company and return its enriched Veridion profile',
+                            action: 'Enrich a company',
+                        },
+                        {
+                            name: 'Company Search',
+                            value: 'searchCompanies',
+                            description: 'Discover companies by applying company-oriented search filters',
+                            action: 'Search for companies',
+                        },
+                        {
+                            name: 'Supplier Search',
+                            value: 'supplierSearch',
+                            description: 'Discover suppliers by product, service, and supplier-specific filters',
+                            action: 'Search for suppliers',
+                        },
+                    ],
+                    default: 'enrichCompany',
+                },
+                // ── Company name (at least one required) ────────────────────────
+                {
+                    displayName: 'Legal Name',
+                    name: 'legalName',
+                    type: 'string',
+                    default: '',
+                    description: 'Official registered name of the company.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                {
+                    displayName: 'Commercial Name',
+                    name: 'commercialName',
+                    type: 'string',
+                    default: '',
+                    description: 'Trading or brand name of the company.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                // ── Locating signals ────────────────────────────────────────────
+                {
+                    displayName: 'Website',
+                    name: 'website',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'acme.com',
+                    description: 'Company website domain or URL.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                {
+                    displayName: 'Address',
+                    name: 'addressTxt',
+                    type: 'string',
+                    default: '',
+                    placeholder: '123 Main St, Cluj-Napoca, Romania',
+                    description: 'Free-text address used as a locating signal.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                {
+                    displayName: 'Phone Number',
+                    name: 'phoneNumber',
+                    type: 'string',
+                    default: '',
+                    placeholder: '+40 123 456 789',
+                    description: 'Company phone number including country code.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                // ── Registry ID path (combination B: registry_id + address_txt) ─
+                {
+                    displayName: 'Registry ID',
+                    name: 'registryId',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'RO12345678',
+                    description: 'Company registry or tax ID.',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                // ── Matching tuning ────────────────────────────────────────────
+                {
+                    displayName: 'Minimum Confidence Score',
+                    name: 'minConfidenceScore',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberStepSize: 0.05,
+                        numberPrecision: 2,
+                    },
+                    default: 0.6,
+                    description: 'Only return a match if its confidence score meets this threshold (0-1).',
+                    displayOptions: { show: { operation: ['enrichCompany'] } },
+                },
+                // ── Search Operations ──────────────────────────────────────────
+                {
+                    displayName: 'Keywords',
+                    name: 'searchKeywords',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'fleet management, telematics, logistics',
+                    description: 'Comma-separated keywords to match on company content.',
+                    displayOptions: { show: { operation: ['searchCompanies'] } },
+                },
+                {
+                    displayName: 'Exclude Keywords',
+                    name: 'searchKeywordsExclude',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'consulting, agency',
+                    description: 'Comma-separated keywords to exclude.',
+                    displayOptions: { show: { operation: ['searchCompanies'] } },
+                },
+                {
+                    displayName: 'Keywords Strictness',
+                    name: 'searchKeywordsStrictness',
+                    type: 'options',
+                    options: [
+                        { name: '1 - Business Tags Only', value: 1 },
+                        { name: '2 - Tags + Meta', value: 2 },
+                        { name: '3 - Broad', value: 3 },
+                    ],
+                    default: 3,
+                    description: 'How broadly to search keyword matches.',
+                    displayOptions: { show: { operation: ['searchCompanies'] } },
+                },
+                {
+                    displayName: 'Product Keywords Group 1',
+                    name: 'searchProductKeywordGroup1',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'lcd screens, lcd display, lcd panel',
+                    description: 'First product keyword group. Terms within a group are matched with OR.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Product Keywords Group 2',
+                    name: 'searchProductKeywordGroup2',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'CE certified, CE certification',
+                    description: 'Optional second keyword group. Separate groups are matched with AND.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Product Keywords Group 3',
+                    name: 'searchProductKeywordGroup3',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'OEM, private label',
+                    description: 'Optional third keyword group. Separate groups are matched with AND.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Product Exclude Keywords',
+                    name: 'searchProductExcludeKeywords',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'retail',
+                    description: 'Comma-separated keywords to exclude from product matches.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Supplier Types',
+                    name: 'searchSupplierTypes',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'Manufacturer', value: 'manufacturer' },
+                        { name: 'Distributor', value: 'distributor' },
+                        { name: 'Service Provider', value: 'service_provider' },
+                        { name: 'Software Provider', value: 'software_provider' },
+                    ],
+                    default: [],
+                    description: 'Optional supplier types for product search.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Country Code',
+                    name: 'searchCountry',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'US',
+                    description: 'ISO 3166-1 alpha-2 country code.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Region / State',
+                    name: 'searchRegion',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional region or state for the company location filter.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'City',
+                    name: 'searchCity',
+                    type: 'string',
+                    default: '',
+                    description: 'Optional city for the company location filter.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Location Strictness',
+                    name: 'searchLocationStrictness',
+                    type: 'options',
+                    options: [
+                        { name: '1 - Main Location', value: 1 },
+                        { name: '2 - Secondary Locations', value: 2 },
+                        { name: '3 - Main + Secondary', value: 3 },
+                    ],
+                    default: 3,
+                    description: 'Whether to search main locations, secondary locations, or both.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Postcode',
+                    name: 'searchPostcodes',
+                    type: 'string',
+                    default: '',
+                    placeholder: '94123, 10001',
+                    description: 'Comma-separated list of postcodes.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Postcode Strictness',
+                    name: 'searchPostcodeStrictness',
+                    type: 'options',
+                    options: [
+                        { name: '1 - Main Location', value: 1 },
+                        { name: '2 - Secondary Locations', value: 2 },
+                        { name: '3 - Main + Secondary', value: 3 },
+                    ],
+                    default: 3,
+                    description: 'Whether postcode matching should target main locations, secondary locations, or both.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Industries',
+                    name: 'searchIndustry',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getIndustries',
+                    },
+                    default: [],
+                    description: 'Select one or more Veridion industries.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'NAICS Codes',
+                    name: 'searchNaicsCodes',
+                    type: 'string',
+                    default: '',
+                    placeholder: '541512, 511210',
+                    description: 'Comma-separated NAICS codes. Prefix values are supported.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'NAICS Strictness',
+                    name: 'searchNaicsStrictness',
+                    type: 'options',
+                    options: [
+                        { name: '1 - Primary Only', value: 1 },
+                        { name: '2 - Secondary Only', value: 2 },
+                        { name: '3 - Primary + Secondary', value: 3 },
+                    ],
+                    default: 3,
+                    description: 'Whether to search primary NAICS, secondary NAICS, or both.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Employee Count (Min)',
+                    name: 'searchEmployeeCountMin',
+                    type: 'string',
+                    default: '',
+                    description: 'Minimum employee count.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Employee Count (Max)',
+                    name: 'searchEmployeeCountMax',
+                    type: 'string',
+                    default: '',
+                    description: 'Maximum employee count.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Estimated Revenue Min USD',
+                    name: 'searchRevenueMin',
+                    type: 'string',
+                    default: '',
+                    description: 'Minimum estimated annual revenue in USD.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Estimated Revenue Max USD',
+                    name: 'searchRevenueMax',
+                    type: 'string',
+                    default: '',
+                    description: 'Maximum estimated annual revenue in USD.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Year Founded Min',
+                    name: 'searchYearFoundedMin',
+                    type: 'string',
+                    default: '',
+                    description: 'Minimum founding year.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Year Founded Max',
+                    name: 'searchYearFoundedMax',
+                    type: 'string',
+                    default: '',
+                    description: 'Maximum founding year.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Proximity Address',
+                    name: 'searchProximityAddress',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'Toronto, M5B 2L7, Ontario',
+                    description: 'Reference address for proximity search.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Proximity Radius',
+                    name: 'searchProximityRadius',
+                    type: 'string',
+                    default: '',
+                    description: 'Radius for proximity search. Maximum 500 km or 300 mi.',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Proximity Unit',
+                    name: 'searchProximityUnit',
+                    type: 'options',
+                    options: [
+                        { name: 'Kilometers', value: 'km' },
+                        { name: 'Miles', value: 'mi' },
+                    ],
+                    default: 'km',
+                    displayOptions: { show: { operation: ['supplierSearch'] } },
+                },
+                {
+                    displayName: 'Page Size',
+                    name: 'pageSize',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                        maxValue: 200,
+                        numberPrecision: 0,
+                    },
+                    default: 10,
+                    description: 'Number of results per page. Maximum is 200.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Pagination Token',
+                    name: 'paginationToken',
+                    type: 'string',
+                    default: '',
+                    description: 'Opaque token from a previous response to fetch the next page.',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+                {
+                    displayName: 'Output Mode',
+                    name: 'searchOutputMode',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Company Items',
+                            value: 'companyItems',
+                            description: 'Return one n8n item per company and include search metadata on each item',
+                        },
+                        {
+                            name: 'Full Response',
+                            value: 'fullResponse',
+                            description: 'Return the raw Veridion response as a single n8n item',
+                        },
+                    ],
+                    default: 'companyItems',
+                    displayOptions: { show: { operation: ['searchCompanies', 'supplierSearch'] } },
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getIndustries() {
+                    const response = await Veridion.loadIndustries(this);
+                    return response
+                        .filter((entry) => (entry === null || entry === void 0 ? void 0 : entry.type) === 'industry' && typeof entry.name === 'string')
+                        .map((entry) => ({
+                        name: entry.name,
+                        value: entry.name,
+                    }))
+                        .sort((a, b) => a.name.localeCompare(b.name));
+                },
+            },
+        };
+    }
+    // ── Execution ──────────────────────────────────────────────────────────
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            const operation = this.getNodeParameter('operation', i);
+            if (operation === 'enrichCompany') {
+                const result = await Veridion.enrichCompany(this, i);
+                returnData.push({ json: result });
+                continue;
+            }
+            if (operation === 'searchCompanies') {
+                const results = await Veridion.searchCompanies(this, i, operation);
+                returnData.push(...results);
+                continue;
+            }
+            if (operation === 'supplierSearch') {
+                const results = await Veridion.searchCompanies(this, i, operation);
+                returnData.push(...results);
+            }
+        }
+        return [returnData];
+    }
+    // ── enrichCompany helper ───────────────────────────────────────────────
+    static async enrichCompany(ctx, itemIndex) {
+        // ── 1. Collect and trim all parameters ────────────────────────────
+        const legalName = ctx.getNodeParameter('legalName', itemIndex, '').trim();
+        const commercialName = ctx.getNodeParameter('commercialName', itemIndex, '').trim();
+        const website = ctx.getNodeParameter('website', itemIndex, '').trim();
+        const addressTxt = ctx.getNodeParameter('addressTxt', itemIndex, '').trim();
+        const phoneNumber = ctx.getNodeParameter('phoneNumber', itemIndex, '').trim();
+        const registryId = ctx.getNodeParameter('registryId', itemIndex, '').trim();
+        const minConfidenceScore = ctx.getNodeParameter('minConfidenceScore', itemIndex, 0.6);
+        const hasName = !!(legalName || commercialName);
+        const hasSignal = !!(website || addressTxt || phoneNumber || registryId);
+        // ── 2. Validate input combinations before calling the API ──────────
+        if (!hasName) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Provide at least one of Legal Name or Commercial Name.', { itemIndex });
+        }
+        if (!hasSignal) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'A company name alone is not enough. Please also provide at least one of: Address, Website, Registry ID, or Phone Number.', { itemIndex });
+        }
+        // ── 3. Build request body — omit empty fields ──────────────────────
+        const identifiers = {};
+        if (legalName)
+            identifiers.legal_names = [legalName];
+        if (commercialName)
+            identifiers.commercial_names = [commercialName];
+        if (website)
+            identifiers.website = website;
+        if (addressTxt)
+            identifiers.address_txt = addressTxt;
+        if (phoneNumber)
+            identifiers.phone_number = phoneNumber;
+        if (registryId)
+            identifiers.registry_id = registryId;
+        const body = { identifiers };
+        // ── 4. Call the API and handle response ────────────────────────────
+        return Veridion.callWithFullResponse(ctx, body, minConfidenceScore, itemIndex);
+    }
+    static async searchCompanies(ctx, itemIndex, operation) {
+        var _a, _b, _c, _d, _e, _f;
+        const pageSize = ctx.getNodeParameter('pageSize', itemIndex, 10);
+        const paginationToken = ctx.getNodeParameter('paginationToken', itemIndex, '').trim();
+        const outputMode = ctx.getNodeParameter('searchOutputMode', itemIndex, 'companyItems');
+        const country = ctx.getNodeParameter('searchCountry', itemIndex, '').trim();
+        const region = ctx.getNodeParameter('searchRegion', itemIndex, '').trim();
+        const city = ctx.getNodeParameter('searchCity', itemIndex, '').trim();
+        const locationStrictness = ctx.getNodeParameter('searchLocationStrictness', itemIndex, 3);
+        const postcodes = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchPostcodes', itemIndex, ''));
+        const postcodeStrictness = ctx.getNodeParameter('searchPostcodeStrictness', itemIndex, 3);
+        const naicsCodes = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchNaicsCodes', itemIndex, ''));
+        const naicsStrictness = ctx.getNodeParameter('searchNaicsStrictness', itemIndex, 3);
+        const industries = Veridion.getStringListParameter(ctx.getNodeParameter('searchIndustry', itemIndex, []));
+        const keywords = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchKeywords', itemIndex, ''));
+        const excludeKeywords = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchKeywordsExclude', itemIndex, ''));
+        const keywordsStrictness = ctx.getNodeParameter('searchKeywordsStrictness', itemIndex, 3);
+        const employeeCountMin = Veridion.getOptionalNumberParameter(ctx, 'searchEmployeeCountMin', itemIndex);
+        const employeeCountMax = Veridion.getOptionalNumberParameter(ctx, 'searchEmployeeCountMax', itemIndex);
+        const revenueMin = Veridion.getOptionalNumberParameter(ctx, 'searchRevenueMin', itemIndex);
+        const revenueMax = Veridion.getOptionalNumberParameter(ctx, 'searchRevenueMax', itemIndex);
+        const yearFoundedMin = Veridion.getOptionalNumberParameter(ctx, 'searchYearFoundedMin', itemIndex);
+        const yearFoundedMax = Veridion.getOptionalNumberParameter(ctx, 'searchYearFoundedMax', itemIndex);
+        const proximityAddress = ctx.getNodeParameter('searchProximityAddress', itemIndex, '').trim();
+        const proximityRadius = Veridion.getOptionalNumberParameter(ctx, 'searchProximityRadius', itemIndex);
+        const proximityUnit = ctx.getNodeParameter('searchProximityUnit', itemIndex, 'km');
+        const productKeywordGroup1 = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchProductKeywordGroup1', itemIndex, ''));
+        const productKeywordGroup2 = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchProductKeywordGroup2', itemIndex, ''));
+        const productKeywordGroup3 = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchProductKeywordGroup3', itemIndex, ''));
+        const productExcludeKeywords = Veridion.parseCommaSeparated(ctx.getNodeParameter('searchProductExcludeKeywords', itemIndex, ''));
+        const supplierTypes = ctx.getNodeParameter('searchSupplierTypes', itemIndex, []);
+        if ((region || city) && !country) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Country Code is required when Region / State or City is provided.', { itemIndex });
+        }
+        if ((proximityAddress && !proximityRadius) || (!proximityAddress && proximityRadius)) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Proximity Address and Proximity Radius must be provided together.', { itemIndex });
+        }
+        const productKeywordGroups = [
+            productKeywordGroup1,
+            productKeywordGroup2,
+            productKeywordGroup3,
+        ].filter((group) => group.length > 0);
+        if (operation === 'supplierSearch' && productKeywordGroups.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Supplier Search requires at least Product Keywords Group 1, 2, or 3.', { itemIndex });
+        }
+        const filters = [];
+        if (country) {
+            const locationValue = { country };
+            if (region)
+                locationValue.region = region;
+            if (city)
+                locationValue.city = city;
+            filters.push({
+                attribute: 'company_location',
+                relation: 'in',
+                value: [locationValue],
+                strictness: locationStrictness,
+            });
+        }
+        if (postcodes.length > 0) {
+            filters.push({
+                attribute: 'company_postcode',
+                relation: postcodes.length === 1 ? 'equals' : 'in',
+                value: postcodes.length === 1 ? postcodes[0] : postcodes,
+                strictness: postcodeStrictness,
+            });
+        }
+        if (naicsCodes.length > 0) {
+            filters.push({
+                attribute: 'company_naics_code',
+                relation: naicsCodes.length === 1 ? 'equals' : 'in',
+                value: naicsCodes.length === 1 ? naicsCodes[0] : naicsCodes,
+                strictness: naicsStrictness,
+            });
+        }
+        if (industries.length > 0) {
+            filters.push({
+                attribute: 'company_industry',
+                relation: industries.length === 1 ? 'equals' : 'in',
+                value: industries.length === 1 ? industries[0] : industries,
+            });
+        }
+        if (operation === 'searchCompanies' && keywords.length > 0) {
+            const keywordValue = {
+                match: {
+                    operator: 'or',
+                    operands: keywords,
+                },
+            };
+            if (excludeKeywords.length > 0) {
+                keywordValue.exclude = {
+                    operator: 'or',
+                    operands: excludeKeywords,
+                };
+            }
+            filters.push({
+                attribute: 'company_keywords',
+                relation: 'match_expression',
+                value: keywordValue,
+                strictness: keywordsStrictness,
+            });
+        }
+        if (employeeCountMin !== null || employeeCountMax !== null) {
+            filters.push(Veridion.buildRangeFilter('company_employee_count', employeeCountMin, employeeCountMax));
+        }
+        if (revenueMin !== null || revenueMax !== null) {
+            filters.push(Veridion.buildRangeFilter('company_estimated_revenue', revenueMin, revenueMax));
+        }
+        if (yearFoundedMin !== null || yearFoundedMax !== null) {
+            filters.push(Veridion.buildRangeFilter('company_year_founded', yearFoundedMin, yearFoundedMax));
+        }
+        if (proximityAddress && proximityRadius !== null) {
+            filters.push({
+                attribute: 'company_location',
+                relation: 'within',
+                value: {
+                    address: proximityAddress,
+                    radius: proximityRadius,
+                    unit: proximityUnit,
+                },
+                strictness: locationStrictness,
+            });
+        }
+        if (productKeywordGroups.length > 0) {
+            const match = productKeywordGroups.length === 1
+                ? {
+                    operator: 'or',
+                    operands: productKeywordGroups[0],
+                }
+                : {
+                    operator: 'and',
+                    operands: productKeywordGroups.map((group) => ({
+                        operator: 'or',
+                        operands: group,
+                    })),
+                };
+            const productValue = {
+                match,
+            };
+            if (productExcludeKeywords.length > 0) {
+                productValue.exclude = {
+                    operator: 'or',
+                    operands: productExcludeKeywords,
+                };
+            }
+            const productFilter = {
+                attribute: 'company_products',
+                relation: 'match_expression',
+                value: productValue,
+            };
+            if (supplierTypes.length > 0) {
+                productFilter.supplier_types = supplierTypes;
+            }
+            filters.push(productFilter);
+        }
+        if (filters.length === 0) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), 'Provide at least one search filter before executing Search Companies.', { itemIndex });
+        }
+        const body = {
+            filters: {
+                and: filters,
+            },
+        };
+        const requestDebug = {
+            url: 'https://data.veridion.com/search/v4/companies',
+            qs: {
+                page_size: pageSize,
+                ...(paginationToken ? { pagination_token: paginationToken } : {}),
+            },
+            body,
+        };
+        const fullResponse = (await Veridion.callApi(ctx, {
+            method: 'POST',
+            url: requestDebug.url,
+            qs: requestDebug.qs,
+            body: JSON.stringify(body),
+        }, itemIndex, true));
+        if (fullResponse.statusCode === 400) {
+            const errBody = fullResponse.body;
+            const message = (_b = (_a = errBody === null || errBody === void 0 ? void 0 : errBody.message) !== null && _a !== void 0 ? _a : errBody === null || errBody === void 0 ? void 0 : errBody.error) !== null && _b !== void 0 ? _b : 'Bad request: check your search filters';
+            throw new n8n_workflow_1.NodeApiError(ctx.getNode(), { message, statusCode: fullResponse.statusCode }, { message, itemIndex, httpCode: String(fullResponse.statusCode) });
+        }
+        if (fullResponse.statusCode !== 200) {
+            const errBody = fullResponse.body;
+            const message = (_d = (_c = errBody === null || errBody === void 0 ? void 0 : errBody.message) !== null && _c !== void 0 ? _c : errBody === null || errBody === void 0 ? void 0 : errBody.error) !== null && _d !== void 0 ? _d : `Unexpected HTTP ${fullResponse.statusCode} from Veridion Search API`;
+            throw new n8n_workflow_1.NodeApiError(ctx.getNode(), { message, statusCode: fullResponse.statusCode }, { message, itemIndex, httpCode: String(fullResponse.statusCode) });
+        }
+        const response = fullResponse.body;
+        if (outputMode === 'fullResponse') {
+            return [{ json: { ...response, _veridion_request: requestDebug } }];
+        }
+        const results = Array.isArray(response.result) ? response.result : [];
+        if (results.length === 0) {
+            return [
+                {
+                    json: {
+                        count: (_e = response.count) !== null && _e !== void 0 ? _e : 0,
+                        pagination: (_f = response.pagination) !== null && _f !== void 0 ? _f : {},
+                        result: [],
+                        _veridion_request: requestDebug,
+                    },
+                },
+            ];
+        }
+        return results.map((company) => {
+            var _a, _b;
+            return ({
+                json: {
+                    ...company,
+                    _veridion_search: {
+                        count: (_a = response.count) !== null && _a !== void 0 ? _a : results.length,
+                        pagination: (_b = response.pagination) !== null && _b !== void 0 ? _b : {},
+                        request: requestDebug,
+                    },
+                },
+            });
+        });
+    }
+    static parseCommaSeparated(input) {
+        return input
+            .split(',')
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+    }
+    static async loadIndustries(ctx) {
+        const credentials = await ctx.getCredentials('veridionApi');
+        return (await ctx.helpers.httpRequest({
+            method: 'GET',
+            url: 'https://data.veridion.com/industries/v0',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': credentials.apiKey,
+            },
+        }));
+    }
+    static getStringListParameter(input) {
+        if (Array.isArray(input)) {
+            return input
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0);
+        }
+        return Veridion.parseCommaSeparated(input);
+    }
+    static getOptionalNumberParameter(ctx, name, itemIndex) {
+        const rawValue = ctx.getNodeParameter(name, itemIndex, '')
+            .toString()
+            .trim();
+        if (rawValue === '') {
+            return null;
+        }
+        const value = Number(rawValue);
+        if (!Number.isFinite(value)) {
+            throw new n8n_workflow_1.NodeOperationError(ctx.getNode(), `"${name}" must be a valid number.`, { itemIndex });
+        }
+        return value;
+    }
+    static buildRangeFilter(attribute, min, max) {
+        if (min !== null && max !== null) {
+            if (min === max) {
+                return {
+                    attribute,
+                    relation: 'equals',
+                    value: min,
+                };
+            }
+            return {
+                attribute,
+                relation: 'between',
+                value: [min, max],
+            };
+        }
+        if (min !== null) {
+            return {
+                attribute,
+                relation: 'greater_than_or_equal',
+                value: min,
+            };
+        }
+        return {
+            attribute,
+            relation: 'less_than_or_equal',
+            value: max,
+        };
+    }
+    /**
+     * Makes the API call with returnFullResponse: true so we can inspect the
+     * HTTP status code alongside the parsed body.
+     */
+    static async callWithFullResponse(ctx, body, minConfidenceScore, itemIndex) {
+        var _a, _b, _c;
+        const fullResponse = await Veridion.callApi(ctx, {
+            method: 'POST',
+            url: 'https://data.veridion.com/match/v5/companies',
+            qs: { min_confidence_score: minConfidenceScore },
+            body: JSON.stringify(body),
+        }, itemIndex, true);
+        const { statusCode, body: responseBody } = fullResponse;
+        // 200 — match found, return enriched profile
+        if (statusCode === 200) {
+            return responseBody;
+        }
+        // 202 — accepted but no match meets the confidence threshold
+        if (statusCode === 202) {
+            return {
+                matched: false,
+                reason: 'No match found above the requested confidence threshold',
+            };
+        }
+        // 400 — bad request; surface the API's error message
+        if (statusCode === 400) {
+            const errBody = responseBody;
+            const message = (_b = (_a = errBody === null || errBody === void 0 ? void 0 : errBody.message) !== null && _a !== void 0 ? _a : errBody === null || errBody === void 0 ? void 0 : errBody.error) !== null && _b !== void 0 ? _b : 'Bad request: check your input fields';
+            throw new n8n_workflow_1.NodeApiError(ctx.getNode(), { message, statusCode }, { message, itemIndex, httpCode: String(statusCode) });
+        }
+        // Any other error status
+        const genericBody = responseBody;
+        const message = (_c = genericBody === null || genericBody === void 0 ? void 0 : genericBody.message) !== null && _c !== void 0 ? _c : `Unexpected HTTP ${statusCode} from Veridion API`;
+        throw new n8n_workflow_1.NodeApiError(ctx.getNode(), { message, statusCode }, { message, itemIndex, httpCode: String(statusCode) });
+    }
+    static async callApi(ctx, options, itemIndex, returnFullResponse = false) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const credentials = await ctx.getCredentials('veridionApi');
+        try {
+            return (await ctx.helpers.httpRequest({
+                method: options.method,
+                url: options.url,
+                qs: options.qs,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': credentials.apiKey,
+                },
+                body: options.body,
+                returnFullResponse,
+                ignoreHttpStatusErrors: returnFullResponse,
+            }));
+        }
+        catch (error) {
+            const err = error;
+            const apiMessage = (_f = (_c = (_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.body) === null || _b === void 0 ? void 0 : _b.message) !== null && _c !== void 0 ? _c : (_e = (_d = err.response) === null || _d === void 0 ? void 0 : _d.body) === null || _e === void 0 ? void 0 : _e.error) !== null && _f !== void 0 ? _f : err.message;
+            const statusCode = (_j = (_h = (_g = err.response) === null || _g === void 0 ? void 0 : _g.statusCode) !== null && _h !== void 0 ? _h : err.statusCode) !== null && _j !== void 0 ? _j : (typeof err.httpCode === 'string' ? Number(err.httpCode) : err.httpCode);
+            throw new n8n_workflow_1.NodeApiError(ctx.getNode(), {
+                message: apiMessage,
+                name: err.name,
+                ...(statusCode ? { statusCode } : {}),
+            }, {
+                itemIndex,
+                message: apiMessage,
+                ...(statusCode ? { httpCode: String(statusCode) } : {}),
+            });
+        }
+    }
+}
+exports.Veridion = Veridion;

package/dist/nodes/Veridion/veridion.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 60 60" width="60" height="60">
+  <!-- Background square with Veridion brand purple -->
+  <rect width="60" height="60" rx="10" ry="10" fill="#4F46E5"/>
+  <!-- Stylised "V" letterform -->
+  <polyline
+    points="10,16 30,46 50,16"
+    fill="none"
+    stroke="#FFFFFF"
+    stroke-width="7"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
+</svg>

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "n8n-nodes-veridion",
+  "version": "0.1.1",
+  "description": "n8n community node for Veridion company enrich, company search, and supplier search",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "veridion",
+    "company-data",
+    "enrichment",
+    "b2b"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/cosmin-veridion/n8n-nodes-veridion",
+  "author": {
+    "name": "Veridion",
+    "email": "support@veridion.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cosmin-veridion/n8n-nodes-veridion.git"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/copy-icons.js",
+    "dev": "tsc -p tsconfig.build.json --watch",
+    "lint": "eslint",
+    "lintfix": "eslint --fix",
+    "prepublishOnly": "npm run build && npm run lint"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/VeridionApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Veridion/Veridion.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@n8n/node-cli": "^0.23.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "n8n-core": "2.16.1",
+    "n8n-workflow": "2.16.0",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "2.16.0"
+  },
+  "files": [
+    "dist"
+  ]
+}