n8n-nodes-pinterest 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# n8n-nodes-pinterest
+
+Community n8n nodes for Pinterest using cookie-based authentication that mimics the web flow.
+
+Supports:
+
+- Cookie-based authentication (session cookie)
+- List boards (current user)
+- Create a Pin with a binary image input
+
+Notes:
+
+- Uses undocumented web endpoints; use at your own risk
+- May violate Pinterest's Terms of Service and can break without notice
+- Consider proxies if Pinterest flags your IP
+
+## Install
+
+```
+npm install n8n-nodes-pinterest
+```
+
+Restart n8n. The node and credential will appear in the editor.
+
+## Credentials
+
+Add a new credential "Pinterest Cookie" and paste your `_pinterest_sess` value from a logged-in browser session. Optionally set a proxy.
+
+## Node usage
+
+### Pinterest Cookie Node: Board → Get Many
+Lists boards via Pinterest web resource endpoint.
+
+### Pinterest Cookie Node: Pin → Create
+Creates a pin using cookie-based authentication.
+
+Inputs:
+
+- Board (select from available boards)
+- Binary Property (e.g. `data`)
+- Optional: Title, Description, Link, Alt Text
+
+Binary image comes from the input item's binary property. The node uploads the image to the `upload_url` from VIPResource, derives the final `image_url` from the `ETag`, then creates the Pin via `PinResource/create/`.
+
+## Disclaimer
+
+This package uses cookie-based authentication and undocumented endpoints. Use at your own risk and in accordance with Pinterest's Terms of Service.

package/dist/credentials/PinterestCookieApi.credentials.d.ts

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

package/dist/credentials/PinterestCookieApi.credentials.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinterestCookieApi = void 0;
+class PinterestCookieApi {
+    constructor() {
+        this.name = 'pinterestCookieApi';
+        this.displayName = 'Pinterest Cookie';
+        this.documentationUrl = 'https://www.pinterest.com';
+        this.properties = [
+            {
+                displayName: 'Pinterest Session Cookie (_pinterest_sess)',
+                name: 'pinterestSess',
+                type: 'string',
+                typeOptions: { password: true },
+                default: '',
+                required: true,
+                description: 'Value of the _pinterest_sess cookie from a logged-in session',
+            },
+            {
+                displayName: 'Proxy',
+                name: 'proxy',
+                type: 'string',
+                default: '',
+                description: 'Optional HTTP proxy (e.g. http://user:pass@host:port)',
+            },
+        ];
+    }
+}
+exports.PinterestCookieApi = PinterestCookieApi;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { INodeType } from 'n8n-workflow';
+import { PinterestCookieApi } from './credentials/PinterestCookieApi.credentials';
+export declare const nodes: INodeType[];
+export declare const credentials: (typeof PinterestCookieApi)[];

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentials = exports.nodes = void 0;
+const PinterestCookie_node_1 = require("./nodes/PinterestCookie/PinterestCookie.node");
+const PinterestCookieApi_credentials_1 = require("./credentials/PinterestCookieApi.credentials");
+exports.nodes = [new PinterestCookie_node_1.PinterestCookie()];
+exports.credentials = [PinterestCookieApi_credentials_1.PinterestCookieApi];

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

@@ -0,0 +1,10 @@
+import type { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class PinterestCookie implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getBoardsCookie(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/PinterestCookie/PinterestCookie.node.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinterestCookie = void 0;
+function randomCsrf() {
+    // similar to plugin: base64 of microtime + random
+    const seed = `${Date.now()}${Math.floor(Math.random() * 100000)}`;
+    return Buffer.from(seed).toString('base64');
+}
+function buildCommonHeaders(csrf) {
+    return {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:75.0) Gecko/20100101 Firefox/75.0',
+        'x-pinterest-pws-handler': 'www/[username].js',
+        'x-CSRFToken': csrf,
+    };
+}
+function buildCookieHeader(sess, csrf) {
+    return `_pinterest_sess=${sess}; csrftoken=${csrf};`;
+}
+const PINTEREST_BASE = 'https://www.pinterest.com';
+class PinterestCookie {
+    constructor() {
+        this.description = {
+            displayName: 'Pinterest (Cookie)',
+            name: 'pinterestCookie',
+            icon: 'fa:pinterest',
+            group: ['output'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Pinterest via cookie method (web endpoints)',
+            defaults: { name: 'Pinterest (Cookie)' },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                { name: 'pinterestCookieApi', required: true },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        { name: 'Pin', value: 'pin' },
+                        { name: 'Board', value: 'board' },
+                        { name: 'Me', value: 'me' },
+                    ],
+                    default: 'pin',
+                },
+                // Pin operations
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    displayOptions: { show: { resource: ['pin'] } },
+                    options: [
+                        { name: 'Create', value: 'create', action: 'Create a pin' },
+                    ],
+                    default: 'create',
+                },
+                {
+                    displayName: 'Board',
+                    name: 'boardId',
+                    type: 'options',
+                    typeOptions: { loadOptionsMethod: 'getBoardsCookie' },
+                    displayOptions: { show: { resource: ['pin'], operation: ['create'] } },
+                    default: '',
+                    required: true,
+                    description: 'Board to pin to',
+                },
+                {
+                    displayName: 'Binary Property',
+                    name: 'binaryProperty',
+                    type: 'string',
+                    default: 'data',
+                    required: true,
+                    displayOptions: { show: { resource: ['pin'], operation: ['create'] } },
+                    description: 'Name of the binary property containing the image',
+                },
+                {
+                    displayName: 'Title',
+                    name: 'title',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['pin'], operation: ['create'] } },
+                },
+                {
+                    displayName: 'Description',
+                    name: 'description',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['pin'], operation: ['create'] } },
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'additionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { resource: ['pin'], operation: ['create'] } },
+                    options: [
+                        { displayName: 'Alt Text', name: 'alt_text', type: 'string', default: '' },
+                        { displayName: 'Link', name: 'link', type: 'string', default: '' },
+                    ],
+                },
+                // Board ops
+                {
+                    displayName: 'Operation',
+                    name: 'boardOperation',
+                    type: 'options',
+                    displayOptions: { show: { resource: ['board'] } },
+                    options: [
+                        { name: 'Get Many', value: 'getAll', action: 'List boards' },
+                    ],
+                    default: 'getAll',
+                },
+                // Me ops
+                {
+                    displayName: 'Operation',
+                    name: 'meOperation',
+                    type: 'options',
+                    displayOptions: { show: { resource: ['me'] } },
+                    options: [
+                        { name: 'Get', value: 'get', action: 'Get my info' },
+                    ],
+                    default: 'get',
+                },
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getBoardsCookie() {
+                    var _a, _b;
+                    const creds = (await this.getCredentials('pinterestCookieApi'));
+                    const pinterestSess = String(creds.pinterestSess || creds.pinterestsess || '');
+                    const proxy = creds.proxy || '';
+                    const csrf = randomCsrf();
+                    const headers = {
+                        ...buildCommonHeaders(csrf),
+                        Cookie: buildCookieHeader(pinterestSess, csrf),
+                    };
+                    // Fetch username first (like plugin getMyInfo)
+                    const meResp = (await this.helpers.request({
+                        method: 'GET',
+                        uri: `${PINTEREST_BASE}/resource/HomefeedBadgingResource/get/`,
+                        headers,
+                        proxy: proxy || undefined,
+                    }));
+                    const meJson = JSON.parse(meResp);
+                    const username = String(((_b = (_a = meJson.client_context) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.username) || '');
+                    const boards = [];
+                    let bookmark = '';
+                    while (true) {
+                        const data = {
+                            options: {
+                                isPrefetch: false,
+                                privacy_filter: 'all',
+                                sort: 'custom',
+                                field_set_key: 'profile_grid_item',
+                                username,
+                                page_size: 25,
+                                group_by: 'visibility',
+                                include_archived: true,
+                                redux_normalize_feed: true,
+                                ...(bookmark ? { bookmarks: [bookmark] } : {}),
+                            },
+                            context: {},
+                        };
+                        const qs = { data: JSON.stringify(data) };
+                        const resp = (await this.helpers.request({
+                            method: 'GET',
+                            uri: `${PINTEREST_BASE}/resource/BoardsResource/get/`,
+                            qs,
+                            headers,
+                            proxy: proxy || undefined,
+                            json: true,
+                        }));
+                        const resource = resp.resource_response || {};
+                        const pageBoards = resource.data || [];
+                        for (const b of pageBoards) {
+                            boards.push({ id: String(b.id), name: String(b.name || b.id) });
+                        }
+                        const next = String(resource.bookmark || '');
+                        if (!next || next === '-end-')
+                            break;
+                        bookmark = next;
+                    }
+                    return boards.map((b) => ({ name: b.name, value: b.id }));
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d;
+        const items = this.getInputData();
+        const returnData = [];
+        const creds = (await this.getCredentials('pinterestCookieApi'));
+        const pinterestSess = String(creds.pinterestSess || creds.pinterestsess || '');
+        const proxy = creds.proxy || '';
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const csrf = randomCsrf();
+                const baseHeaders = buildCommonHeaders(csrf);
+                const cookieHeader = buildCookieHeader(pinterestSess, csrf);
+                if (resource === 'me') {
+                    const resp = (await this.helpers.request({
+                        method: 'GET',
+                        uri: `${PINTEREST_BASE}/resource/HomefeedBadgingResource/get/`,
+                        headers: { ...baseHeaders, Cookie: cookieHeader },
+                        proxy: proxy || undefined,
+                    }));
+                    const json = JSON.parse(resp);
+                    returnData.push({ json });
+                    continue;
+                }
+                if (resource === 'board') {
+                    // Fetch username first to scope boards
+                    const meResp = (await this.helpers.request({
+                        method: 'GET',
+                        uri: `${PINTEREST_BASE}/resource/HomefeedBadgingResource/get/`,
+                        headers: { ...baseHeaders, Cookie: cookieHeader },
+                        proxy: proxy || undefined,
+                    }));
+                    const meJson = JSON.parse(meResp);
+                    const username = String(((_b = (_a = meJson.client_context) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.username) || '');
+                    const resp = (await this.helpers.request({
+                        method: 'GET',
+                        uri: `${PINTEREST_BASE}/resource/BoardsResource/get/`,
+                        qs: {
+                            data: JSON.stringify({
+                                options: {
+                                    isPrefetch: false,
+                                    privacy_filter: 'all',
+                                    sort: 'custom',
+                                    field_set_key: 'profile_grid_item',
+                                    username,
+                                    page_size: 25,
+                                    group_by: 'visibility',
+                                    include_archived: true,
+                                    redux_normalize_feed: true,
+                                },
+                                context: {},
+                            }),
+                        },
+                        headers: { ...baseHeaders, Cookie: cookieHeader },
+                        proxy: proxy || undefined,
+                        json: true,
+                    }));
+                    returnData.push({ json: resp });
+                    continue;
+                }
+                if (resource === 'pin') {
+                    const operation = this.getNodeParameter('operation', i);
+                    if (operation === 'create') {
+                        const boardId = this.getNodeParameter('boardId', i);
+                        const binaryProperty = this.getNodeParameter('binaryProperty', i);
+                        const title = this.getNodeParameter('title', i, '');
+                        const description = this.getNodeParameter('description', i, '');
+                        const additionalFields = this.getNodeParameter('additionalFields', i, {});
+                        const binary = (_c = items[i].binary) === null || _c === void 0 ? void 0 : _c[binaryProperty];
+                        if (!binary)
+                            throw new Error(`Binary property "${binaryProperty}" is missing on item ${i}`);
+                        // Step 1: request upload slot
+                        const vipResp = (await this.helpers.request({
+                            method: 'POST',
+                            uri: `${PINTEREST_BASE}/resource/VIPResource/create/`,
+                            form: {
+                                source_url: '/pin-builder/',
+                                data: '{"options":{"type":"pinimage"},"context":{}}',
+                            },
+                            headers: { ...baseHeaders, Cookie: cookieHeader },
+                            proxy: proxy || undefined,
+                        }));
+                        const vip = JSON.parse(vipResp);
+                        const res = vip.resource_response || {};
+                        const data = res.data || {};
+                        const uploadUrl = String(data.upload_url || '');
+                        const uploadParams = data.upload_parameters || {};
+                        if (!uploadUrl)
+                            throw new Error('Failed to get upload URL');
+                        // Step 2: upload image
+                        const buffer = Buffer.from(binary.data, 'base64');
+                        const contentType = binary.mimeType || 'image/jpeg';
+                        const formData = {};
+                        for (const [k, v] of Object.entries(uploadParams))
+                            formData[k] = String(v);
+                        formData['file'] = {
+                            value: buffer,
+                            options: {
+                                filename: 'blob',
+                                contentType,
+                            },
+                        };
+                        const uploadResp = (await this.helpers.request({
+                            method: 'POST',
+                            uri: uploadUrl,
+                            headers: {
+                                Accept: '*/*',
+                                'Accept-Encoding': 'gzip',
+                                'User-Agent': baseHeaders['User-Agent'],
+                                Origin: 'https://www.pinterest.com',
+                                Referer: 'https://www.pinterest.com',
+                            },
+                            formData,
+                            proxy: proxy || undefined,
+                            // get full response to read headers
+                            resolveWithFullResponse: true,
+                            simple: false,
+                        }));
+                        const etagRaw = uploadResp.headers['etag'] || uploadResp.headers['ETag'] || '';
+                        const etag = String(etagRaw).replace(/"/g, '');
+                        if (!etag)
+                            throw new Error('Upload failed: missing ETag');
+                        // compute imageUrl like plugin
+                        const imageUrl = `https://i.pinimg.com/736x/${etag[0]}${etag[1]}/${etag[2]}${etag[3]}/${etag[4]}${etag[5]}/${etag}.jpg`;
+                        // Step 3: create pin
+                        const sendData = {
+                            options: {
+                                board_id: boardId,
+                                field_set_key: 'create_success',
+                                skip_pin_create_log: true,
+                                description,
+                                alt_text: additionalFields.alt_text || '',
+                                link: additionalFields.link || '',
+                                title,
+                                image_url: imageUrl,
+                                method: 'uploaded',
+                                upload_metric: { source: 'pinner_upload_standalone' },
+                                user_mention_tags: [],
+                                no_fetch_context_on_resource: false,
+                            },
+                            context: {},
+                        };
+                        const createResp = (await this.helpers.request({
+                            method: 'POST',
+                            uri: `${PINTEREST_BASE}/resource/PinResource/create/`,
+                            form: {
+                                source_url: '/pin-builder/',
+                                data: JSON.stringify(sendData),
+                            },
+                            headers: { ...baseHeaders, Cookie: cookieHeader },
+                            proxy: proxy || undefined,
+                        }));
+                        const created = JSON.parse(createResp);
+                        const createdRes = created.resource_response || {};
+                        const pinData = createdRes.data || {};
+                        const id = String(pinData.id || '');
+                        if (!id) {
+                            const message = createdRes.message || ((_d = createdRes.error) === null || _d === void 0 ? void 0 : _d.message) || 'Create failed';
+                            throw new Error(String(message));
+                        }
+                        returnData.push({ json: { id, link: `https://www.pinterest.com/pin/${id}` } });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.PinterestCookie = PinterestCookie;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "n8n-nodes-pinterest",
+  "version": "0.1.0",
+  "description": "n8n community nodes for Pinterest v5 API (list boards, create pins)",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "pinterest",
+    "pins",
+    "boards"
+  ],
+  "author": "Community",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsc -p ."
+  },
+  "n8n": {
+    "credentials": [
+      "dist/credentials/PinterestCookieApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/PinterestCookie/PinterestCookie.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.0",
+    "n8n-core": "^1.58.0",
+    "n8n-workflow": "^1.58.0",
+    "typescript": "^5.4.5"
+  }
+}