@dropinblog/n8n-nodes-dropinblog 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DropInBlog
+
+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,57 @@
+# n8n-nodes-dropinblog
+
+This is an n8n community node. It lets you use [DropInBlog](https://dropinblog.com) in your n8n workflows.
+
+DropInBlog is an SEO-friendly blog solution that embeds into any website.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/reference/license/) workflow automation platform.
+
+[Installation](#installation)
+[Operations](#operations)
+[Credentials](#credentials)
+[Compatibility](#compatibility)
+[Resources](#resources)
+
+## Installation
+
+Follow the [installation guide](https://docs.n8n.io/integrations/community-nodes/installation/) in the n8n community nodes documentation.
+
+## Operations
+
+### DropInBlog Node
+
+- **Post**
+  - **Create** - Create a new blog post with title, content, and optional fields:
+    - Status
+    - Slug
+    - Featured image URL
+    - SEO title and description
+    - Keyword
+    - Author name
+    - Category names
+  - **Get** - Retrieve a post by its numeric ID or slug
+  - **Search** - Search blog posts with optional filters:
+    - Status (Draft/Published)
+    - Limit
+
+### DropInBlog Trigger Node
+
+- **Post Published** - Triggers when a post is published in your DropInBlog
+
+## Credentials
+
+This node uses OAuth2 authentication with DropInBlog. You'll need to:
+
+1. Contact [DropInBlog support](https://dropinblog.com/contact/) to request OAuth credentials for your account
+2. Configure the OAuth2 credentials in n8n with the Client ID and Client Secret provided
+3. Complete the OAuth authorization flow
+
+## Compatibility
+
+Tested with n8n version 1.48.0 and above. Requires Node.js 18.10 or later.
+
+## Resources
+
+* [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
+* [DropInBlog API documentation](https://dropinblog.readme.io/reference/api-reference)
+* [DropInBlog website](https://dropinblog.com)

package/dist/credentials/DropInBlogOAuth2Api.credentials.d.ts

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

package/dist/credentials/DropInBlogOAuth2Api.credentials.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropInBlogOAuth2Api = void 0;
+const constants_1 = require("../nodes/DropInBlog/constants");
+class DropInBlogOAuth2Api {
+    constructor() {
+        this.name = 'dropInBlogOAuth2Api';
+        this.extends = ['oAuth2Api'];
+        this.displayName = 'DropInBlog OAuth2 API';
+        this.documentationUrl = 'https://dropinblog.com/docs/api';
+        this.properties = [
+            {
+                displayName: 'Grant Type',
+                name: 'grantType',
+                type: 'hidden',
+                default: 'authorizationCode',
+            },
+            {
+                displayName: 'Authorization URL',
+                name: 'authUrl',
+                type: 'hidden',
+                default: 'https://app.dropinblog.com/oauth/authorize',
+            },
+            {
+                displayName: 'Access Token URL',
+                name: 'accessTokenUrl',
+                type: 'hidden',
+                default: `${constants_1.API_BASE_URL}/oauth/token`,
+            },
+            {
+                displayName: 'Scope',
+                name: 'scope',
+                type: 'hidden',
+                default: '',
+            },
+            {
+                displayName: 'Auth URI Query Parameters',
+                name: 'authQueryParameters',
+                type: 'hidden',
+                default: '',
+            },
+            {
+                displayName: 'Authentication',
+                name: 'authentication',
+                type: 'hidden',
+                default: 'body',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                headers: {
+                    Authorization: '=Bearer {{$credentials.oauthTokenData.access_token}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: constants_1.API_BASE_URL,
+                url: '/v2/automations/blogs',
+            },
+        };
+    }
+}
+exports.DropInBlogOAuth2Api = DropInBlogOAuth2Api;

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

@@ -0,0 +1,12 @@
+import type { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { getBlogs } from './GenericFunctions';
+export declare class DropInBlog implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getBlogs: typeof getBlogs;
+            getStatuses(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/DropInBlog/DropInBlog.node.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropInBlog = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const constants_1 = require("./constants");
+const GenericFunctions_1 = require("./GenericFunctions");
+class DropInBlog {
+    constructor() {
+        this.description = {
+            displayName: 'DropInBlog',
+            name: 'dropInBlog',
+            icon: 'file:logo.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Interact with DropInBlog',
+            defaults: {
+                name: 'DropInBlog',
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'dropInBlogOAuth2Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Post',
+                            value: 'post',
+                        },
+                    ],
+                    default: 'post',
+                    description: 'The resource to operate on',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            description: 'Create a new blog post',
+                            action: 'Create a post',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            description: 'Get a post by ID or slug',
+                            action: 'Get a post',
+                        },
+                        {
+                            name: 'Search',
+                            value: 'search',
+                            description: 'Search blog posts',
+                            action: 'Search posts',
+                        },
+                    ],
+                    default: 'create',
+                },
+                // Blog ID (shared by create, get, and search)
+                {
+                    displayName: 'Blog',
+                    name: 'blogId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getBlogs',
+                    },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['create', 'get', 'search'],
+                        },
+                    },
+                    description: 'The blog to work with. Choose from the list.',
+                },
+                // Post ID or Slug (get only)
+                {
+                    displayName: 'Post ID or Slug',
+                    name: 'postIdentifier',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['get'],
+                        },
+                    },
+                    description: 'The numeric ID or slug of the post to retrieve',
+                },
+                // Title (create only)
+                {
+                    displayName: 'Title',
+                    name: 'title',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'The title of the post',
+                },
+                // Content (create only)
+                {
+                    displayName: 'Content',
+                    name: 'content',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 10,
+                    },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['create'],
+                        },
+                    },
+                    description: 'The HTML content of the post',
+                },
+                // Search Query (search only)
+                {
+                    displayName: 'Search Query',
+                    name: 'search',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['search'],
+                        },
+                    },
+                    description: 'The search query to find posts',
+                },
+                // Additional Fields (create only)
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['create'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Author Name',
+                            name: 'author_name',
+                            type: 'string',
+                            default: '',
+                            description: 'The name of the author (will create or find existing author by name)',
+                        },
+                        {
+                            displayName: 'Category Names',
+                            name: 'category_names',
+                            type: 'string',
+                            default: '',
+                            description: 'Comma separated list of category names to attach to your post (will create categories if they do not exist)',
+                        },
+                        {
+                            displayName: 'Featured Image URL',
+                            name: 'featured_image',
+                            type: 'string',
+                            default: '',
+                            description: 'URL of the featured image',
+                        },
+                        {
+                            displayName: 'Keyword',
+                            name: 'keyword',
+                            type: 'string',
+                            default: '',
+                            description: 'Primary SEO keyword for the post',
+                        },
+                        {
+                            displayName: 'SEO Title',
+                            name: 'seo_title',
+                            type: 'string',
+                            default: '',
+                            description: 'Meta title for SEO (defaults to post title)',
+                        },
+                        {
+                            displayName: 'SEO Description',
+                            name: 'seo_description',
+                            type: 'string',
+                            typeOptions: {
+                                rows: 3,
+                            },
+                            default: '',
+                            description: 'Meta description for SEO',
+                        },
+                        {
+                            displayName: 'Slug',
+                            name: 'slug',
+                            type: 'string',
+                            default: '',
+                            description: 'URL slug for the post (auto generated from title if not provided)',
+                        },
+                        {
+                            displayName: 'Status',
+                            name: 'status_id',
+                            type: 'options',
+                            typeOptions: {
+                                loadOptionsMethod: 'getStatuses',
+                            },
+                            default: '',
+                            description: 'The status of the post. Choose from the list.',
+                        },
+                    ],
+                },
+                // Search Filters (search only)
+                {
+                    displayName: 'Filters',
+                    name: 'searchFilters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: {
+                        show: {
+                            resource: ['post'],
+                            operation: ['search'],
+                        },
+                    },
+                    options: [
+                        {
+                            displayName: 'Status',
+                            name: 'status',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Draft',
+                                    value: 'draft',
+                                },
+                                {
+                                    name: 'Published',
+                                    value: 'published',
+                                },
+                            ],
+                            default: '',
+                            description: 'Filter by post status',
+                        },
+                        {
+                            displayName: 'Limit',
+                            name: 'limit',
+                            type: 'number',
+                            typeOptions: {
+                                minValue: 1,
+                                maxValue: 50,
+                            },
+                            default: 20,
+                            description: 'Max number of results to return (max 50)',
+                        },
+                    ],
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                getBlogs: GenericFunctions_1.getBlogs,
+                async getStatuses() {
+                    const returnData = [];
+                    const statuses = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                        method: 'GET',
+                        url: `${constants_1.API_BASE_URL}/v2/automations/statuses`,
+                        json: true,
+                    });
+                    for (const status of statuses) {
+                        returnData.push({
+                            name: status.name,
+                            value: status.id,
+                        });
+                    }
+                    return returnData;
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                if (resource === 'post') {
+                    if (operation === 'create') {
+                        const blogId = this.getNodeParameter('blogId', i);
+                        const title = this.getNodeParameter('title', i);
+                        const content = this.getNodeParameter('content', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const body = {
+                            title,
+                            content,
+                            ...Object.fromEntries(Object.entries(additionalFields).filter(([, v]) => v !== undefined && v !== '')),
+                        };
+                        // the write endpoint for posts
+                        const response = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                            method: 'POST',
+                            url: `${constants_1.API_BASE_URL}/v2/blog/${blogId}/posts`,
+                            body,
+                            json: true,
+                        });
+                        const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(response), { itemData: { item: i } });
+                        returnData.push(...executionData);
+                    }
+                    else if (operation === 'get') {
+                        const blogId = this.getNodeParameter('blogId', i);
+                        const postIdentifier = this.getNodeParameter('postIdentifier', i);
+                        // the read endpoint for individual posts
+                        const response = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                            method: 'GET',
+                            url: `${constants_1.API_BASE_URL}/v2/automations/${blogId}/posts/${encodeURIComponent(postIdentifier)}`,
+                            json: true,
+                        });
+                        const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(response), { itemData: { item: i } });
+                        returnData.push(...executionData);
+                    }
+                    else if (operation === 'search') {
+                        const blogId = this.getNodeParameter('blogId', i);
+                        const search = this.getNodeParameter('search', i);
+                        const searchFilters = this.getNodeParameter('searchFilters', i);
+                        const qs = { search };
+                        if (searchFilters.status) {
+                            qs.status = searchFilters.status;
+                        }
+                        if (searchFilters.limit) {
+                            qs.limit = searchFilters.limit;
+                        }
+                        // the read/search endpoint for posts
+                        const response = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                            method: 'GET',
+                            url: `${constants_1.API_BASE_URL}/v2/automations/${blogId}/posts/search`,
+                            qs,
+                            json: true,
+                        });
+                        const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(response), { itemData: { item: i } });
+                        returnData.push(...executionData);
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
+                    returnData.push(...executionData);
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+            }
+        }
+        return [returnData];
+    }
+}
+exports.DropInBlog = DropInBlog;

package/dist/nodes/DropInBlog/DropInBlogTrigger.node.d.ts

@@ -0,0 +1,18 @@
+import type { IHookFunctions, INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from 'n8n-workflow';
+import { getBlogs } from './GenericFunctions';
+export declare class DropInBlogTrigger implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getBlogs: typeof getBlogs;
+        };
+    };
+    webhookMethods: {
+        default: {
+            checkExists(this: IHookFunctions): Promise<boolean>;
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/DropInBlog/DropInBlogTrigger.node.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropInBlogTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const constants_1 = require("./constants");
+const GenericFunctions_1 = require("./GenericFunctions");
+class DropInBlogTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'DropInBlog Trigger',
+            name: 'dropInBlogTrigger',
+            icon: 'file:logo.svg',
+            group: ['trigger'],
+            version: 1,
+            subtitle: '={{$parameter["event"]}}',
+            description: 'Starts the workflow when a DropInBlog event occurs',
+            defaults: {
+                name: 'DropInBlog Trigger',
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'dropInBlogOAuth2Api',
+                    required: true,
+                },
+            ],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Blog',
+                    name: 'blogId',
+                    type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getBlogs',
+                    },
+                    required: true,
+                    default: '',
+                    description: 'The blog to listen for events from. Choose from the list.',
+                },
+                {
+                    displayName: 'Event',
+                    name: 'event',
+                    type: 'options',
+                    required: true,
+                    default: 'post.published',
+                    options: [
+                        {
+                            name: 'Post Published',
+                            value: 'post.published',
+                            description: 'Triggers when a post is published',
+                        },
+                    ],
+                    description: 'The event to listen for',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                getBlogs: GenericFunctions_1.getBlogs,
+            },
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.webhookId === undefined) {
+                        return false;
+                    }
+                    return true;
+                },
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const blogId = this.getNodeParameter('blogId');
+                    const event = this.getNodeParameter('event');
+                    const body = {
+                        hookUrl: webhookUrl,
+                        // The API expects events as a JSON-stringified array (intentional double-serialization)
+                        events: JSON.stringify([event]),
+                        source: 'n8n',
+                    };
+                    const response = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                        method: 'POST',
+                        url: `${constants_1.API_BASE_URL}/v2/blog/${blogId}/webhooks`,
+                        body,
+                        json: true,
+                    });
+                    if (response.hookId === undefined) {
+                        return false;
+                    }
+                    const webhookData = this.getWorkflowStaticData('node');
+                    webhookData.webhookId = response.hookId;
+                    webhookData.blogId = blogId;
+                    return true;
+                },
+                async delete() {
+                    const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData.webhookId !== undefined) {
+                        try {
+                            await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+                                method: 'DELETE',
+                                url: `${constants_1.API_BASE_URL}/v2/blog/${webhookData.blogId}/webhooks/${webhookData.webhookId}`,
+                                json: true,
+                            });
+                            delete webhookData.webhookId;
+                            delete webhookData.blogId;
+                        }
+                        catch (error) {
+                            return false;
+                        }
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const bodyData = this.getBodyData();
+        return {
+            workflowData: [this.helpers.returnJsonArray(bodyData)],
+        };
+    }
+}
+exports.DropInBlogTrigger = DropInBlogTrigger;

package/dist/nodes/DropInBlog/GenericFunctions.d.ts

@@ -0,0 +1,2 @@
+import type { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare function getBlogs(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;

package/dist/nodes/DropInBlog/GenericFunctions.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlogs = getBlogs;
+const constants_1 = require("./constants");
+async function getBlogs() {
+    const returnData = [];
+    const blogs = await this.helpers.requestWithAuthentication.call(this, 'dropInBlogOAuth2Api', {
+        method: 'GET',
+        url: `${constants_1.API_BASE_URL}/v2/automations/blogs`,
+        json: true,
+    });
+    for (const blog of blogs) {
+        returnData.push({
+            name: blog.name,
+            value: blog.id,
+        });
+    }
+    return returnData;
+}

package/dist/nodes/DropInBlog/constants.d.ts

@@ -0,0 +1 @@
+export declare const API_BASE_URL = "https://api.dropinblog.com";

package/dist/nodes/DropInBlog/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_BASE_URL = void 0;
+exports.API_BASE_URL = 'https://api.dropinblog.com';

package/dist/nodes/DropInBlog/logo.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024"><path fill="#ed254e" d="M0 0h1024v1024H0z"/><path fill="#fff" d="M245 717s232-165 493-205c-261-40-493-205-493-205h391l205 205-205 205Z"/></svg>

package/index.js

@@ -0,0 +1,2 @@
+// This file is required for the package to work correctly
+// The actual exports are handled by the n8n configuration in package.json

package/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@dropinblog/n8n-nodes-dropinblog",
+	"version": "1.0.0",
+	"description": "n8n community node for DropInBlog - Create posts and receive webhook notifications when posts are published",
+	"keywords": [
+		"n8n-community-node-package",
+		"n8n",
+		"dropinblog",
+		"blog",
+		"cms"
+	],
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://dropinblog.com",
+	"author": {
+		"name": "DropInBlog"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/DropInBlog/n8n-nodes.git"
+	},
+	"engines": {
+		"node": ">=18.10",
+		"pnpm": ">=9.1"
+	},
+	"packageManager": "pnpm@9.1.4",
+	"main": "index.js",
+	"scripts": {
+		"preinstall": "npx only-allow pnpm",
+		"build": "tsc && gulp build:icons",
+		"dev": "tsc --watch",
+		"format": "prettier nodes/**/*.ts credentials/**/*.ts --write",
+		"lint": "eslint nodes/**/*.ts credentials/**/*.ts package.json",
+		"lintfix": "eslint nodes/**/*.ts credentials/**/*.ts package.json --fix",
+		"prepublishOnly": "pnpm build && pnpm lint -c .eslintrc.prepublish.js nodes/**/*.ts credentials/**/*.ts"
+	},
+	"files": [
+		"dist"
+	],
+	"n8n": {
+		"n8nNodesApiVersion": 1,
+		"credentials": [
+			"dist/credentials/DropInBlogOAuth2Api.credentials.js"
+		],
+		"nodes": [
+			"dist/nodes/DropInBlog/DropInBlog.node.js",
+			"dist/nodes/DropInBlog/DropInBlogTrigger.node.js"
+		]
+	},
+	"devDependencies": {
+		"@typescript-eslint/parser": "^7.15.0",
+		"eslint": "^8.56.0",
+		"eslint-plugin-n8n-nodes-base": "^1.16.1",
+		"gulp": "^4.0.2",
+		"n8n-workflow": "^1.48.0",
+		"prettier": "^3.3.2",
+		"typescript": "^5.5.3"
+	},
+	"peerDependencies": {
+		"n8n-workflow": "*"
+	}
+}