n8n-nodes-camb-ai 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 [Sisay Tadewos]
+
+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,35 @@
+# n8n-nodes-camb-ai
+
+An n8n community node for [Camb.ai](https://camb.ai), covering end-to-end video dubbing across 20+ locales, including Amharic.
+
+## Installation
+
+Follow the [n8n community nodes installation guide](https://docs.n8n.io/integrations/community-nodes/installation/), or install manually:
+
+```bash
+npm install n8n-nodes-camb-ai
+```
+
+## Credentials
+
+Requires a **Camb.ai API** credential:
+
+| Field | Description |
+|---|---|
+| API Key | Your Camb.ai API key |
+
+## Operations
+
+The **Camb.ai Dubbing** node supports:
+
+- **Submit & Wait for Result** — submits a dub task and polls internally until it finishes, then returns the dubbed video/audio URLs. Simplest option for most workflows.
+- **Submit Dub Task** — submits a task and returns immediately with a `task_id`, for workflows that poll separately.
+- **Get Dub Status** — checks the status of a previously submitted `task_id`.
+- **Get Dub Result** — fetches the final output for a completed `run_id`.
+- **List Source Languages** / **List Target Languages** — returns the authoritative, currently supported locale list directly from Camb.ai (locales change over time, so this is safer than hardcoding).
+
+Supports common locales including English (US/UK), Spanish (Spain/Mexico), Amharic, French, German, Italian, Portuguese (BR/PT), Hindi, Japanese, Korean, Chinese (Simplified/Traditional), Arabic, Russian, Turkish, Dutch, Polish, Indonesian, Vietnamese, Thai, and a custom locale-tag field for anything else Camb.ai adds.
+
+## License
+
+MIT

package/credentials/CambAiApi.credentials.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/**
+ * CambAiApi Credential
+ *
+ * Camb.ai authenticates every request with a single `x-api-key` header
+ * (not Bearer auth). Find your key under the "API" section of the
+ * Camb.ai studio dashboard.
+ */
+class CambAiApi {
+  constructor() {
+    this.name = 'cambAiApi';
+    this.displayName = 'Camb.ai API';
+    this.documentationUrl = 'https://docs.camb.ai/getting-started';
+    this.properties = [
+      {
+        displayName: 'API Key',
+        name: 'apiKey',
+        type: 'string',
+        typeOptions: { password: true },
+        default: '',
+        required: true,
+        description: 'Sent as the x-api-key header on every request.',
+      },
+    ];
+  }
+}
+
+module.exports = { CambAiApi };

package/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { CambAiDub } = require('./nodes/CambAiDub/CambAiDub.node');
+const { CambAiApi } = require('./credentials/CambAiApi.credentials');
+
+module.exports = {
+  nodes: [CambAiDub],
+  credentials: [CambAiApi],
+};

package/nodes/CambAiDub/CambAiDub.node.js

@@ -0,0 +1,341 @@
+'use strict';
+
+const { NodeConnectionTypes, NodeOperationError } = require('n8n-workflow');
+
+const BASE_URL = 'https://client.camb.ai/apis';
+
+// Common locale tags, mirroring the `Languages.EN_US` style enum from Camb.ai's
+// SDKs. This list is NOT exhaustive — Camb.ai supports 140+ languages/dialects.
+// Use the "List Source Languages" / "List Target Languages" operations below
+// to pull the full, authoritative, up-to-date list directly from Camb.ai;
+// use "Custom" here to type any locale tag that isn't in this shortlist.
+const LANGUAGE_OPTIONS = [
+  { name: 'English (US) — en-us', value: 'en-us' },
+  { name: 'English (UK) — en-gb', value: 'en-gb' },
+  { name: 'Spanish (Spain) — es-es', value: 'es-es' },
+  { name: 'Spanish (Mexico) — es-mx', value: 'es-mx' },
+  { name: 'Amharic — am-et', value: 'am-et' },
+  { name: 'French — fr-fr', value: 'fr-fr' },
+  { name: 'German — de-de', value: 'de-de' },
+  { name: 'Italian — it-it', value: 'it-it' },
+  { name: 'Portuguese (Brazil) — pt-br', value: 'pt-br' },
+  { name: 'Portuguese (Portugal) — pt-pt', value: 'pt-pt' },
+  { name: 'Hindi — hi-in', value: 'hi-in' },
+  { name: 'Japanese — ja-jp', value: 'ja-jp' },
+  { name: 'Korean — ko-kr', value: 'ko-kr' },
+  { name: 'Chinese (Simplified) — zh-cn', value: 'zh-cn' },
+  { name: 'Chinese (Traditional) — zh-tw', value: 'zh-tw' },
+  { name: 'Arabic — ar-sa', value: 'ar-sa' },
+  { name: 'Russian — ru-ru', value: 'ru-ru' },
+  { name: 'Turkish — tr-tr', value: 'tr-tr' },
+  { name: 'Dutch — nl-nl', value: 'nl-nl' },
+  { name: 'Polish — pl-pl', value: 'pl-pl' },
+  { name: 'Indonesian — id-id', value: 'id-id' },
+  { name: 'Vietnamese — vi-vn', value: 'vi-vn' },
+  { name: 'Thai — th-th', value: 'th-th' },
+  { name: 'Custom (type a locale tag below)', value: 'custom' },
+];
+
+async function cambRequest(ctx, { method, url, body, qs }) {
+  const credentials = await ctx.getCredentials('cambAiApi');
+  const options = {
+    method,
+    url: `${BASE_URL}${url}`,
+    headers: {
+      'x-api-key': credentials.apiKey,
+      'Content-Type': 'application/json',
+    },
+    json: true,
+  };
+  if (body) options.body = body;
+  if (qs) options.qs = qs;
+
+  try {
+    return await ctx.helpers.httpRequest(options);
+  } catch (err) {
+    const status = err.response && err.response.statusCode;
+    const data = err.response && err.response.body;
+    const detail = data ? (typeof data === 'string' ? data : JSON.stringify(data)) : err.message;
+    throw new Error(`Camb.ai request failed (${method} ${url}${status ? `, status ${status}` : ''}): ${detail}`);
+  }
+}
+
+function parseCsvInts(raw) {
+  if (!raw) return undefined;
+  const arr = String(raw)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .map((s) => Number(s));
+  return arr.length ? arr : undefined;
+}
+
+async function pollDubStatus(ctx, taskId, { pollIntervalSeconds, maxWaitMinutes }) {
+  const deadline = Date.now() + maxWaitMinutes * 60 * 1000;
+  while (true) {
+    const status = await cambRequest(ctx, { method: 'GET', url: `/dub/${taskId}` });
+    if (status.status === 'SUCCESS') return status;
+    if (status.status === 'FAILED' || status.status === 'ERROR') {
+      throw new Error(`Camb.ai dubbing task ${taskId} failed: ${JSON.stringify(status)}`);
+    }
+    if (Date.now() > deadline) {
+      throw new Error(
+        `Timed out waiting for Camb.ai dubbing task ${taskId} after ${maxWaitMinutes} minutes (last status: ${status.status})`
+      );
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalSeconds * 1000));
+  }
+}
+
+class CambAiDub {
+  constructor() {
+    this.description = {
+      displayName: 'Camb.ai Dubbing',
+      name: 'cambAiDub',
+      icon: 'file:cambai.svg',
+      group: ['transform'],
+      version: 1,
+      description: 'Submit end-to-end video dubbing tasks to Camb.ai and retrieve results',
+      defaults: { name: 'Camb.ai Dubbing' },
+      inputs: [NodeConnectionTypes.Main],
+      outputs: [NodeConnectionTypes.Main],
+      credentials: [{ name: 'cambAiApi', required: true }],
+      properties: [
+        {
+          displayName: 'Operation',
+          name: 'operation',
+          type: 'options',
+          options: [
+            {
+              name: 'Submit & Wait for Result',
+              value: 'submitAndWait',
+              description: 'Submits a dub task and polls internally until it finishes, then returns the dubbed video/audio URLs',
+            },
+            { name: 'Submit Dub Task', value: 'submit', description: 'Submits a dub task and returns immediately with a task_id' },
+            { name: 'Get Dub Status', value: 'getStatus', description: 'Checks the status of a previously submitted task_id' },
+            { name: 'Get Dub Result', value: 'getResult', description: 'Fetches the final output for a completed run_id' },
+            { name: 'List Source Languages', value: 'listSourceLanguages', description: 'Full authoritative list of source language locale tags supported right now' },
+            { name: 'List Target Languages', value: 'listTargetLanguages', description: 'Full authoritative list of target language locale tags supported right now' },
+          ],
+          default: 'submitAndWait',
+        },
+
+        // ── submit / submitAndWait fields ──────────────────────────
+        {
+          displayName: 'Video URL',
+          name: 'videoUrl',
+          type: 'string',
+          default: '',
+          required: true,
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+          description: 'Publicly accessible URL of the source video (e.g. the secure_url from Cloudinary Uploader)',
+        },
+        {
+          displayName: 'Source Language',
+          name: 'sourceLanguage',
+          type: 'options',
+          options: LANGUAGE_OPTIONS,
+          default: 'en-us',
+          required: true,
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+        },
+        {
+          displayName: 'Source Language (Custom Locale Tag)',
+          name: 'sourceLanguageCustom',
+          type: 'string',
+          default: '',
+          placeholder: 'e.g. sw-ke',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'], sourceLanguage: ['custom'] } },
+          description: 'Used only when Source Language above is set to "Custom"',
+        },
+        {
+          displayName: 'Target Languages',
+          name: 'targetLanguages',
+          type: 'multiOptions',
+          options: LANGUAGE_OPTIONS.filter((o) => o.value !== 'custom'),
+          default: [],
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+          description: 'Pick one or more from the shortlist. Add anything not listed in the field below.',
+        },
+        {
+          displayName: 'Additional Target Languages (Comma-Separated Locale Tags)',
+          name: 'targetLanguagesCustom',
+          type: 'string',
+          default: '',
+          placeholder: 'e.g. sw-ke,am-et',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+          description: 'Any extra locale tags not in the dropdown above (comma-separated). Combined with the dropdown selection.',
+        },
+        {
+          displayName: 'Transcription Mode',
+          name: 'transcriptionMode',
+          type: 'options',
+          options: [
+            { name: 'Fast (default)', value: 'fast' },
+            { name: 'Slow (more accurate)', value: 'slow' },
+          ],
+          default: 'fast',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+          description: 'Trade speed for transcript accuracy',
+        },
+        {
+          displayName: 'Project Name',
+          name: 'projectName',
+          type: 'string',
+          default: '',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+        },
+        {
+          displayName: 'Project Description',
+          name: 'projectDescription',
+          type: 'string',
+          default: '',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+        },
+        {
+          displayName: 'Chosen Dictionary IDs (Comma-Separated, Optional)',
+          name: 'chosenDictionaries',
+          type: 'string',
+          default: '',
+          displayOptions: { show: { operation: ['submit', 'submitAndWait'] } },
+          description: 'Custom terminology dictionaries configured in your Camb.ai workspace, if any (keeps specified words unchanged across languages)',
+        },
+
+        // ── submitAndWait-only polling controls ────────────────────
+        {
+          displayName: 'Poll Interval (Seconds)',
+          name: 'pollIntervalSeconds',
+          type: 'number',
+          default: 10,
+          displayOptions: { show: { operation: ['submitAndWait'] } },
+        },
+        {
+          displayName: 'Max Wait (Minutes)',
+          name: 'maxWaitMinutes',
+          type: 'number',
+          default: 20,
+          displayOptions: { show: { operation: ['submitAndWait'] } },
+          description: 'Fails the node if dubbing has not finished within this many minutes',
+        },
+
+        // ── getStatus fields ────────────────────────────────────────
+        {
+          displayName: 'Task ID',
+          name: 'taskId',
+          type: 'string',
+          default: '',
+          required: true,
+          displayOptions: { show: { operation: ['getStatus'] } },
+        },
+
+        // ── getResult fields ────────────────────────────────────────
+        {
+          displayName: 'Run ID',
+          name: 'runId',
+          type: 'string',
+          default: '',
+          required: true,
+          displayOptions: { show: { operation: ['getResult'] } },
+        },
+      ],
+    };
+  }
+
+  async execute() {
+    const items = this.getInputData();
+    const operation = this.getNodeParameter('operation', 0);
+    const results = [];
+
+    for (let i = 0; i < items.length; i++) {
+      try {
+        let output;
+
+        if (operation === 'listSourceLanguages') {
+          output = await cambRequest(this, { method: 'GET', url: '/source-languages' });
+        } else if (operation === 'listTargetLanguages') {
+          output = await cambRequest(this, { method: 'GET', url: '/target-languages' });
+        } else if (operation === 'getStatus') {
+          const taskId = this.getNodeParameter('taskId', i, '');
+          output = await cambRequest(this, { method: 'GET', url: `/dub/${taskId}` });
+        } else if (operation === 'getResult') {
+          const runId = this.getNodeParameter('runId', i, '');
+          output = await cambRequest(this, { method: 'GET', url: `/dub-result/${runId}` });
+        } else if (operation === 'submit' || operation === 'submitAndWait') {
+          const videoUrl = this.getNodeParameter('videoUrl', i);
+          const sourceLanguageChoice = this.getNodeParameter('sourceLanguage', i);
+          const sourceLanguageCustom = this.getNodeParameter('sourceLanguageCustom', i, '');
+          const targetLanguagesChoice = this.getNodeParameter('targetLanguages', i, []);
+          const targetLanguagesCustom = this.getNodeParameter('targetLanguagesCustom', i, '');
+          const transcriptionMode = this.getNodeParameter('transcriptionMode', i, 'fast');
+          const projectName = this.getNodeParameter('projectName', i, '');
+          const projectDescription = this.getNodeParameter('projectDescription', i, '');
+          const chosenDictionariesRaw = this.getNodeParameter('chosenDictionaries', i, '');
+
+          const sourceLanguage =
+            sourceLanguageChoice === 'custom' ? sourceLanguageCustom.trim() : sourceLanguageChoice;
+          if (!sourceLanguage) {
+            throw new NodeOperationError(this.getNode(), 'Source Language is required (custom locale tag was empty)', {
+              itemIndex: i,
+            });
+          }
+
+          const extraTargets = String(targetLanguagesCustom || '')
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+          const targetLanguages = Array.from(new Set([...(targetLanguagesChoice || []), ...extraTargets]));
+          if (targetLanguages.length === 0) {
+            throw new NodeOperationError(
+              this.getNode(),
+              'At least one Target Language is required (dropdown selection or custom field)',
+              { itemIndex: i }
+            );
+          }
+
+          const body = {
+            video_url: videoUrl,
+            source_language: sourceLanguage,
+            target_languages: targetLanguages,
+            transcription_mode: transcriptionMode,
+          };
+          if (projectName) body.project_name = projectName;
+          if (projectDescription) body.project_description = projectDescription;
+          const chosenDictionaries = parseCsvInts(chosenDictionariesRaw);
+          if (chosenDictionaries) body.chosen_dictionaries = chosenDictionaries;
+
+          const submitResponse = await cambRequest(this, { method: 'POST', url: '/dub', body });
+
+          if (operation === 'submit') {
+            output = submitResponse;
+          } else {
+            const pollIntervalSeconds = this.getNodeParameter('pollIntervalSeconds', i, 10);
+            const maxWaitMinutes = this.getNodeParameter('maxWaitMinutes', i, 20);
+            const finalStatus = await pollDubStatus(this, submitResponse.task_id, {
+              pollIntervalSeconds,
+              maxWaitMinutes,
+            });
+            const runId = finalStatus.run_id;
+            const result = await cambRequest(this, { method: 'GET', url: `/dub-result/${runId}` });
+            output = { task_id: submitResponse.task_id, run_id: runId, ...result };
+          }
+        } else {
+          throw new NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
+        }
+
+        results.push({ json: output });
+      } catch (err) {
+        if (this.continueOnFail()) {
+          results.push({ json: { error: String(err && err.message ? err.message : err) } });
+          continue;
+        }
+        throw err instanceof NodeOperationError
+          ? err
+          : new NodeOperationError(this.getNode(), String(err && err.message ? err.message : err), { itemIndex: i });
+      }
+    }
+
+    return this.prepareOutputData(results);
+  }
+}
+
+module.exports = { CambAiDub };

package/nodes/CambAiDub/cambai.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24">
+  <circle cx="12" cy="12" r="11" fill="#12121a"/>
+  <path d="M7 8v8M11 8v8M15 8c2.2 0 3.5 1.5 3.5 4S17.2 16 15 16" stroke="#5EF2C1" stroke-width="1.6" fill="none" stroke-linecap="round"/>
+</svg>

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "n8n-nodes-camb-ai",
+  "version": "1.0.0",
+  "description": "n8n community node for Camb AI \u2014 dubbing (Amharic / English) and Text-to-Speech (\u12a0\u1288\u134d-Audio engine) with speaker and pacing control, chainable into an English-script-to-Amharic-speech pipeline.",
+  "main": "index.js",
+  "license": "MIT",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "camb-ai",
+    "amharic",
+    "dubbing",
+    "translation",
+    "text-to-speech",
+    "tts",
+    "ethiopia"
+  ],
+  "author": {
+    "name": "Sisay Tadewos"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Sisyetad/n8n-nodes-Camb-ai"
+  },
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "strict": true,
+    "nodes": [
+      "nodes/CambAiDub/CambAiDub.node.js"
+    ],
+    "credentials": [
+      "credentials/CambAiApi.credentials.js"
+    ]
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  },
+  "files": [
+    "index.js",
+    "credentials",
+    "nodes",
+    "LICENSE",
+    "README.md"
+  ]
+}