Build a WhatsApp Fact-Checking Bot with Twilio, OpenAI, and Node.js

mkdir src
cd src
npm init -y

npm install express twilio openai dotenv

"main": "src/index.js",
  "type": "module",
  "scripts": {
    "dev": "node --watch src/index.js"
  },

PORT=3000
OPENAI_API_KEY=your_openai_api_key
OPENAI_MODEL=gpt-5.4-mini
OPENAI_TRANSCRIPTION_MODEL=gpt-4o-mini-transcribe
TWILIO_ACCOUNT_SID=ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
TWILIO_AUTH_TOKEN=your_twilio_auth_token

import "dotenv/config";
import express from "express";
import twilio from "twilio";
import { downloadTwilioMedia, getMediaKind, toDataUrl } from "./services/media.js";
import { transcribeMedia, verifyImageMessage, verifyTextMessage } from "./services/openai.js";
const app = express();
app.use(express.urlencoded({ extended: false }));
function twimlMessage(message) {
  const response = new twilio.twiml.MessagingResponse();
  response.message(message);
  return response.toString();
}

app.post("/whatsapp", async (request, response) => {
  const body = request.body.Body?.trim() ?? "";
  const numMedia = Number(request.body.NumMedia ?? 0);
  if (!body && numMedia === 0) {
    response.type("text/xml").send(
      twimlMessage("Please forward a message, image, voice note, or short video for me to review.")
    );
    return;
  }
  if (numMedia === 0) {
    const verdict = await verifyTextMessage({ messageText: body });
    response.type("text/xml").send(twimlMessage(verdict));
    return;
  }
  const mediaUrl = request.body.MediaUrl0;
  const contentType = request.body.MediaContentType0;
  const mediaKind = getMediaKind(contentType);
  // We'll handle media types in the next section.
});
const port = Number(process.env.PORT ?? 3000);
app.listen(port, () => {
    console.log(`Server listening on http://localhost:${port}`);
});

const SUPPORTED_IMAGE_TYPES = new Set(["image/jpeg", "image/png", "image/webp"]);
const SUPPORTED_AUDIO_TYPES = new Set([
  "audio/mpeg",
  "audio/mp3",
  "audio/mp4",
  "audio/m4a",
  "audio/wav",
  "audio/webm",
  "audio/ogg"
]);
const SUPPORTED_VIDEO_TYPES = new Set([
  "video/mp4",
  "video/quicktime",
  "video/webm",
  "video/ogg"
]);
export function getMediaKind(contentType = "") {
  if (SUPPORTED_IMAGE_TYPES.has(contentType)) return "image";
  if (SUPPORTED_AUDIO_TYPES.has(contentType)) return "audio";
  if (SUPPORTED_VIDEO_TYPES.has(contentType)) return "video";
  return "unsupported";
}

export async function downloadTwilioMedia(mediaUrl, contentType, credentials) {
  const response = await fetch(mediaUrl, {
    headers: {
      Authorization: `Basic ${Buffer.from(`${credentials.username}:${credentials.password}`).toString("base64")}`
    }
  });
  if (!response.ok) {
    throw new Error(`Failed to download media: ${response.status} ${response.statusText}`);
  }
  const arrayBuffer = await response.arrayBuffer();
  return {
    buffer: Buffer.from(arrayBuffer),
    filename: `incoming.${contentType.split("/")[1] ?? "bin"}`
  };
}

export function toDataUrl(buffer, contentType) {
  return `data:${contentType};base64,${buffer.toString("base64")}`;
}

const media = await downloadTwilioMedia(mediaUrl, contentType, {
  username: process.env.TWILIO_ACCOUNT_SID,
  password: process.env.TWILIO_AUTH_TOKEN
});
if (mediaKind === "image") {
  const verdict = await verifyImageMessage({
    messageText: body,
    imageDataUrl: toDataUrl(media.buffer, contentType)
  });
  response.type("text/xml").send(twimlMessage(verdict));
  return;
}
const transcript = await transcribeMedia({
  buffer: media.buffer,
  filename: media.filename,
  contentType
});
const verdict = await verifyTextMessage({
  messageText: body,
  transcript
});
response.type("text/xml").send(twimlMessage(verdict));

import OpenAI from "openai";
import { toFile } from "openai/uploads";
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function transcribeMedia({ buffer, filename, contentType }) {
  const file = await toFile(buffer, filename, { type: contentType });
  const transcript = await client.audio.transcriptions.create({
    file,
    model: process.env.OPENAI_TRANSCRIPTION_MODEL || "gpt-4o-mini-transcribe"
  });
  return transcript.text;
}

function buildInstructions() {
  return [
    "You verify forwarded WhatsApp content for everyday users.",
    "Be careful, skeptical, and easy to understand.",
    "When the content makes factual, current, or time-sensitive claims, search the web before deciding.",
    "Prefer official, primary, or highly credible sources when available.",
    "If a reliable source confirms the content, say that clearly.",
    "If reliable sources contradict it, say that clearly.",
    "If the search results are weak, missing, or inconclusive, say so instead of guessing.",
    "Use exactly this format:",
    "Verdict: <Likely legitimate | Unclear | Likely misleading>",
    "Reason: <one or two short sentences>",
    "Check next: <one practical verification step>",
    "Confidence: <Low | Medium | High>"
  ].join(" ");
}

function buildResponseOptions() {
  return {
    model: process.env.OPENAI_MODEL || "gpt-5.4-mini",
    instructions: buildInstructions(),
    tools: [
      {
        type: "web_search",
        search_context_size: "medium"
      }
    ],
    include: ["web_search_call.action.sources"]
  };
}

export async function verifyTextMessage({ messageText, transcript }) {
  const content = [
    transcript ? `Forwarded media transcript:\n${transcript}` : null,
    messageText ? `Forwarded message text:\n${messageText}` : null,
    "Assess whether this looks legitimate, misleading, or too uncertain to trust."
  ]
    .filter(Boolean)
    .join("\n\n");
  const response = await client.responses.create({
    ...buildResponseOptions(),
    input: content
  });
  return response.output_text.trim();
}

export async function verifyImageMessage({ messageText, imageDataUrl }) {
  const response = await client.responses.create({
    ...buildResponseOptions(),
    input: [
      {
        role: "user",
        content: [
          {
            type: "input_text",
            text: [
              "This image was forwarded in WhatsApp.",
              messageText ? `Caption or extra text:\n${messageText}` : "No caption was included.",
              "If the image appears to show an official notice, advisory, flyer, or screenshot, search the web to see whether matching official information exists."
            ].join("\n\n")
          },
          {
            type: "input_image",
            image_url: imageDataUrl
          }
        ]
      }
    ]
  });
  return response.output_text.trim();
}

npm run dev

ngrok http 3000

https://1234abcd.ngrok-free.app/whatsapp

Verdict: Unclear
Reason: This message makes a factual claim but does not provide a reliable source, and I could not confidently verify it from the content alone.
Check next: Look for the same claim on an official government website or a reputable news source.
Confidence: Medium

Verdict: Likely legitimate
Reason: This advisory matches information published by an official meteorological source, including the timing and warning details.
Check next: Open the matched source and confirm the advisory number or date.
Confidence: High
Matched source: Kenya Meteorological Department - https://www.meteo.go.ke/...