I want to make it a Service out of this App

Excellent idea. That’s a perfect use case for this application—turning it into a backend microservice that can be called by automation platforms like n8n.

The process is straightforward. We will add a new, dedicated webhook endpoint to your server.js. This endpoint will be different from the existing /synthesize endpoint in one key way: instead of saving a file and returning a JSON message, it will stream the MP3 data directly back in the HTTP response. This is exactly what n8n needs to receive binary data.

The great news is that no changes are needed to your Dockerfile or your docker run command. We are simply adding functionality to the application code that the container already runs.

Step 1: Modify server.js to Add a Webhook Endpoint

We will add a new POST endpoint, let’s call it /webhook. This keeps your existing web UI fully functional while providing a new machine-to-machine interface.

Here is the complete, updated server.js file. I’ve added the new endpoint near the end.

server.js (Final Version with Webhook)

JavaScript

// server.js - Final Version with Webhook

const express = require('express');
const textToSpeech = require('@google-cloud/text-to-speech');
const fs = require('fs');
const path = require('path');

const app = express();
app.use(express.json());
app.use(express.static('public')); 

const client = new textToSpeech.TextToSpeechClient({
    keyFilename: 'gcloud-credentials.json'
});

const resultsDir = path.join(__dirname, 'results');
if (!fs.existsSync(resultsDir)) {
    fs.mkdirSync(resultsDir, { recursive: true });
}

app.use('/results', express.static(resultsDir));


// Endpoint to get all available English voices
app.get('/get-voices', async (req, res) => {
    // ... (This endpoint is unchanged)
    try {
        const [result] = await client.listVoices({});
        const voices = result.voices
            .filter(voice => voice.languageCodes.some(code => code.startsWith('en-')))
            .filter(voice => voice.name.includes('-Standard-') || voice.name.includes('-Chirp-'))
            .sort((a, b) => a.name.localeCompare(b.name));
        res.json(voices);
    } catch (error) {
        console.error('ERROR fetching voices:', error);
        res.status(500).send('Failed to get voice list.');
    }
});


// Endpoint for the web UI to synthesize speech and save a file
app.post('/synthesize', async (req, res) => {
    // ... (This endpoint is unchanged)
    try {
        const { text, voice, title, gender, log } = req.body;
        if (!text || !voice || !title || !gender || !log) {
            return res.status(400).json({ message: 'Missing required fields in request' });
        }
        const languageCode = voice.split('-').slice(0, 2).join('-');
        const request = { input: { text }, voice: { languageCode, name: voice }, audioConfig: { audioEncoding: 'MP3' } };
        const [response] = await client.synthesizeSpeech(request);
        const sanitizedTitle = title.replace(/[^a-zA-Z0-9]/g, '');
        const now = new Date();
        const dateString = now.getFullYear().toString() + String(now.getMonth() + 1).padStart(2, '0') + String(now.getDate()).padStart(2, '0') + String(now.getHours()).padStart(2, '0') + String(now.getMinutes()).padStart(2, '0') + String(now.getSeconds()).padStart(2, '0');
        const formattedGender = `-${gender.charAt(0).toUpperCase() + gender.slice(1).toLowerCase()}`;
        const filename = `${sanitizedTitle}_${dateString}_Google-${voice}${formattedGender}.mp3`;
        const filePath = path.join(resultsDir, filename);
        fs.writeFileSync(filePath, response.audioContent, 'binary');
        console.log(`Audio content written to file: ${filePath}`);
        const logFilePath = path.join(resultsDir, '0Request.log');
        const logEntry = { dateTime: log.timestamp, voice: log.voice, title: log.title, characterCount: log.characterCount, outputFile: filename };
        let logs = [];
        try { const data = fs.readFileSync(logFilePath, 'utf8'); logs = JSON.parse(data); } catch (error) { if (error.code !== 'ENOENT') { console.error("Error reading log file:", error); } }
        logs.push(logEntry);
        fs.writeFileSync(logFilePath, JSON.stringify(logs, null, 2));
        res.status(200).json({ message: `File saved successfully as ${filename}`, filePath: `/results/${filename}` });
    } catch (error) {
        console.error('SYNTHESIZE ERROR:', error);
        res.status(500).json({ message: 'An error occurred while synthesizing speech.' });
    }
});


// Endpoint to get the log file content
app.get('/get-log', (req, res) => {
    // ... (This endpoint is unchanged)
    const logFilePath = path.join(resultsDir, '0Request.log');
    try {
        const data = fs.readFileSync(logFilePath, 'utf8');
        res.setHeader('Content-Type', 'application/json');
        res.send(data);
    } catch (error) {
        if (error.code === 'ENOENT') { res.json([]); } else { console.error('ERROR reading log file:', error); res.status(500).json({ message: 'Could not read log file.' }); }
    }
});


// --- NEW ENDPOINT: For n8n webhook integration ---
app.post('/webhook', async (req, res) => {
    try {
        const { text, voice } = req.body;

        // 1. Validate input from the webhook
        if (!text) {
            return res.status(400).json({ error: 'The "text" field is required.' });
        }

        // 2. Set a default voice if none is provided
        const voiceName = voice || 'en-US-Standard-C';
        const languageCode = voiceName.split('-').slice(0, 2).join('-');

        console.log(`Webhook received: Synthesizing ${text.length} chars with voice ${voiceName}`);

        // 3. Prepare the request for Google TTS API
        const request = {
            input: { text: text },
            voice: { languageCode: languageCode, name: voiceName },
            audioConfig: { audioEncoding: 'MP3' },
        };

        // 4. Call the API
        const [response] = await client.synthesizeSpeech(request);

        // 5. IMPORTANT: Send the MP3 data directly in the response
        // Do not save to a file. Set the correct header for n8n to recognize it as a file.
        res.setHeader('Content-Type', 'audio/mpeg');
        res.send(response.audioContent);

    } catch (error) {
        console.error('WEBHOOK ERROR:', error);
        res.status(500).json({ error: 'Failed to synthesize speech via webhook.' });
    }
});


const PORT = process.env.PORT || 3010;
app.listen(PORT, () => {
    console.log(`✅ Server is running on http://localhost:${PORT}`);
});

Step 2: Rebuild and Run Your Docker Container

Your Dockerfile and docker run command do not need to change at all. You just need to rebuild the image to include the updated server.js code.

1. Stop the current container (if it’s running): Bashdocker stop tts-container
2. Rebuild the image with your code changes: Bashdocker build -t my-tts-app .
3. Run the new container using the exact same command as before: Bashdocker run -d --rm \ -p 8080:3010 \ -v "$(pwd)/results":/app/results \ -v "$(pwd)/gcloud-credentials.json":/app/gcloud-credentials.json:ro \ -e GOOGLE_APPLICATION_CREDENTIALS="/app/gcloud-credentials.json" \ --name tts-container \ my-tts-app

Your service is now running and listening for requests on the new /webhook endpoint.

Step 3: Configure Your n8n Workflow

Here is how you would set up a simple n8n workflow to use your new webhook.

Node 1: Webhook (Trigger)

1. Add a Webhook node to your canvas.
2. In the node’s properties, copy the Test URL. You will use this to send test data to your workflow (e.g., from Postman or curl). Example curl command to test your n8n webhook trigger: Bashcurl -X POST -H "Content-Type: application/json" -d '{"text":"Hello from n8n!"}' <your_n8n_test_webhook_url>
3. Click “Listen for Test Event”.

Node 2: HTTP Request (Call Your Service)

1. Add an HTTP Request node and connect it to the Webhook node.
2. Configure the properties:
   • URL:http://<your_docker_host_ip>:8080/webhook
     • Important: Replace <your_docker_host_ip> with the IP address of the machine running Docker. If n8n and Docker are on the same machine, you might be able to use http://localhost:8080 or the Docker container’s IP address.
   • Method: POST
   • Send Body: On
   • Body Content Type: JSON
   • JSON/RAW Parameters: On
   • Body: Use an expression to pass the text from the webhook trigger to your service. JSON{ "text": "{{ $json.body.text }}", "voice": "en-GB-Standard-A" }

Node 3: Write Binary File (Process the MP3)

1. Add a Write Binary File node and connect it to the HTTP Request node. This node will take the MP3 data returned by your service and save it.
2. Configure the properties:
   • File Name: n8n_output.mp3 (or use an expression like {{ $now.toFormat('X') }}.mp3 for a unique name).
   • Data Is: Binary
   • Input Data Field: This is the most important part. By default, n8n places binary data from an HTTP Request node in a field called data. So, the expression is: {{ $binary.data }}

Now, when you trigger your n8n workflow, it will call your containerized service, receive the MP3 file directly, and save it for the next step in your automation.