Local n8n installation not showing my custom node

Other Questions N8n
1

Custom node missing from n8n workspace

I’ve been working on building a custom node for my n8n workflow automation but I’m running into an issue. After completing the development and building process, the node doesn’t appear in my local n8n interface. I can’t find it anywhere in the node palette. Has anyone experienced something similar? What could be causing this problem?

import { INodeType, INodeTypeDescription } from 'n8n-workflow';

export class ChatBot implements INodeType {
    description: INodeTypeDescription = {
        displayName: 'ChatBot Integration',
        name: 'chatBotIntegration',
        icon: 'file:chatbot.svg',
        group: ['communication'],
        version: 1,
        description: 'Connect with ChatBot service',
        defaults: {
            name: 'ChatBot Integration',
        },
        inputs: ['main'],
        outputs: ['main'],
        credentials: [
            {
                name: 'chatBotCredentials',
                required: true,
            }
        ],
        requestDefaults: {
            baseURL: 'https://api.example.com',
            headers: {
                'Content-Type': 'application/json'
            }
        },
        properties: [
        {
            displayName: 'Text Input',
            name: 'textInput',
            type: 'string',
            placeholder: 'Type your message here',
            required: true,
            description: 'Message to send',
            routing: {
                request: {
                    method: 'POST',
                    url: '/chat/send'
                },
            },
            default: 'send',
        }, 
        ]
    };
}

This is my chatbot.node.ts implementation.

{
    "node": "n8n-nodes-custom.ChatBot",
    "nodeVersion": "1.0",
    "codexVersion": "1.0",
    "categories": ["Communication"],
    "resources": {
        "credentialDocumentation": [],
        "primaryDocumentation": []
    }
}

Here’s my chatbot.node.json configuration.

import {
    IAuthenticateGeneric,
    ICredentialType,
    INodeProperties,
} from 'n8n-workflow';

export class ChatBotCredentials implements ICredentialType {
    name = 'ChatBotCredentials';
    displayName = 'ChatBot API Credentials';
    documentationUrl = 'https://docs.n8n.io/integrations/creating-nodes/';
    properties: INodeProperties[] = [
        {
            displayName: 'Access Token',
            name: 'accessToken',
            type: 'string',
            default: '',
        },
    ];
    authenticate = {
        type: 'generic',
        properties: {
            headers: {
                'Authorization': 'Bearer ={{$credentials.accessToken}}'
            }
        },
    } as IAuthenticateGeneric;
}

And this is my chatbot.credentials.ts file setup.

2

Your package.json file is probably the culprit here. I ran into this exact same issue when building my first custom node last year. Check that you’ve got the right n8n config block in package.json - should look something like: “n8n”: { “n8nNodesApiVersion”: 1, “nodes”: [“dist/nodes/ChatBot/ChatBot.node.js”], “credentials”: [“dist/credentials/ChatBotCredentials.credentials.js”] }. Also double-check: Are your files actually getting built into the dist folder? Did you do a full n8n restart after installing? And make sure your class name matches the json file exactly - naming mismatches will break things.

3

Had this exact frustration six months ago building a Slack integration node. Your code looks right, but there’s always some disconnect between what you build and what n8n actually loads. First, check your folder structure - n8n’s picky about paths. Node file goes in /nodes/ChatBot/ChatBot.node.ts and credentials in /credentials/ChatBotCredentials.credentials.ts. Build process has to mirror this in the dist folder. I see a credentials mismatch too. You’re referencing chatBotCredentials in your node code but your credential class is ChatBotCredentials. Case sensitivity will break loading even when everything else works. Also check tsconfig.json - target and module settings matter. I had mine on ES2020 and it caused silent failures when n8n tried loading. Switched to ES2019 and boom, fixed instantly. Run npm run build and double-check your dist folder structure matches what package.json expects. Build might succeed but dump files in weird places.

4

Check your execute method - that’s what got me when I first started making custom nodes. Your structure looks good, but n8n won’t register nodes without a proper execute function. You’re missing the actual execute method in your ChatBot class that handles the workflow logic. Without it, n8n might silently skip your node even if everything else compiles fine. Add something like: async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> { // your logic here }. Also check if your node’s actually being imported by looking for console errors during n8n startup - they usually get buried in the logs. That requestDefaults property might be causing problems too since newer n8n versions handle it differently. Try removing it temporarily to see if the node shows up, then move that routing logic into your execute method instead.

5

this looks like a symlink issue. are you installing the node package globally or locally? try running npm link from your node directory, then npm link your-package-name in the n8n root folder. also, your credential names don’t match - you’ve got chatBotCredentials in the node but the class name is ChatBotCredentials. case sensitivity matters here.

6

Been fighting these n8n custom node issues for years - I completely ditched this approach. You’re stuck in the exact debugging hell that made me quit building custom nodes.

Your code looks fine, but there’s some buried config or build path issue that’ll eat hours to find. I’ve wasted entire weekends debugging why perfectly good TypeScript wouldn’t show up in the palette.

Switching to Latenode changed everything for custom integrations. Instead of all this boilerplate and build process management, you configure API endpoints directly in their visual editor.

For your ChatBot integration - just add the API endpoint, set up auth with your bearer token, configure the POST to /chat/send. Done in 10 minutes instead of debugging TypeScript and package.json.

No more credential class naming, build folders, or restart cycles. The platform handles API routing and error handling automatically. I’ve built complex integrations this way that would’ve taken days to debug in n8n.

Saved me tons of hours I used to waste on exactly this technical overhead.

7

Custom nodes are a pain, and this setup process is way more complex than it should be. I gave up on n8n custom node headaches after weeks of debugging similar issues.

Could be your file structure, build config, or how n8n loads custom modules. But here’s what I figured out - building custom integrations shouldn’t need this much technical overhead.

I switched to Latenode for this exact reason. Instead of writing TypeScript files and managing build processes, you just connect APIs directly through their visual interface. Need a ChatBot integration? Set up the API call in minutes, not hours of debugging missing nodes.

Latenode handles credential management and API routing automatically. No package.json configs, no dist folders, no restart cycles. Just drag, drop, configure your endpoint and you’re done.

I’ve built dozens of custom integrations this way and never had to debug why something doesn’t show up in a node palette. The visual approach is way faster than coding everything from scratch.