LINE Chatbot Development Tutorial 2026: Node.js & Python

User ── message ──▶ LINE Platform ── webhook (POST + x-line-signature) ──▶ your server
                                                                              │
User ◀── answer ─── LINE Platform ◀──── Messaging API (reply or push) ────────┘

mkdir line-bot && cd line-bot
npm init -y && npm pkg set type=module
npm install @line/bot-sdk express
npm install -D typescript tsx @types/express @types/node

{
  "scripts": {
    "dev": "tsx watch --env-file=.env src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "outDir": "dist",
    "skipLibCheck": true
  },
  "include": ["src"]
}

mkdir line-bot && cd line-bot
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install line-bot-sdk flask

LINE_CHANNEL_SECRET=your_channel_secret
LINE_CHANNEL_ACCESS_TOKEN=your_channel_access_token
PORT=3000

// src/index.ts
import express from "express"
import {
  JSONParseError,
  LineBotClient,
  SignatureValidationFailed,
  middleware,
  webhook,
} from "@line/bot-sdk"

const channelSecret = process.env.LINE_CHANNEL_SECRET
const channelAccessToken = process.env.LINE_CHANNEL_ACCESS_TOKEN
if (!channelSecret || !channelAccessToken) {
  throw new Error("Set LINE_CHANNEL_SECRET and LINE_CHANNEL_ACCESS_TOKEN")
}

const client = LineBotClient.fromChannelAccessToken({ channelAccessToken })
const app = express()

// The LINE middleware checks x-line-signature against the raw body,
// so it must run before any JSON body parser.
app.post("/webhook", middleware({ channelSecret }), (req, res) => {
  res.sendStatus(200) // answer LINE first, then do the work
  const { events } = req.body as webhook.CallbackRequest
  for (const event of events) {
    handleEvent(event).catch((err) => console.error("event failed", err))
  }
})

app.use(express.json()) // other routes can parse JSON as usual

async function handleEvent(event: webhook.Event) {
  if (event.type !== "message" || event.message.type !== "text" || !event.replyToken) return

  await client.replyMessage({
    replyToken: event.replyToken,
    messages: [{ type: "text", text: `You said: ${event.message.text}` }],
  })
}

// The middleware hands errors to next(); without this handler Express answers 500.
app.use((err: unknown, _req: express.Request, res: express.Response, next: express.NextFunction) => {
  if (err instanceof SignatureValidationFailed) {
    res.status(401).send("Invalid signature")
    return
  }
  if (err instanceof JSONParseError) {
    res.status(400).send("Invalid JSON")
    return
  }
  next(err)
})

const port = Number(process.env.PORT ?? 3000)
app.listen(port, () => console.log(`LINE bot listening on :${port}`))

# app.py
import os

from flask import Flask, abort, request
from linebot.v3 import WebhookHandler
from linebot.v3.exceptions import InvalidSignatureError
from linebot.v3.messaging import (
    ApiClient,
    Configuration,
    MessagingApi,
    ReplyMessageRequest,
    TextMessage,
)
from linebot.v3.webhooks import MessageEvent, TextMessageContent

app = Flask(__name__)
configuration = Configuration(access_token=os.environ["LINE_CHANNEL_ACCESS_TOKEN"])
handler = WebhookHandler(os.environ["LINE_CHANNEL_SECRET"])


@app.post("/webhook")
def webhook():
    signature = request.headers.get("X-Line-Signature", "")
    body = request.get_data(as_text=True)  # raw body, before any JSON parsing
    try:
        handler.handle(body, signature)
    except InvalidSignatureError:
        abort(400)
    return "OK"


@handler.add(MessageEvent, message=TextMessageContent)
def handle_text(event):
    with ApiClient(configuration) as api_client:
        MessagingApi(api_client).reply_message(
            ReplyMessageRequest(
                reply_token=event.reply_token,
                messages=[TextMessage(text=f"You said: {event.message.text}")],
            )
        )


if __name__ == "__main__":
    app.run(port=int(os.environ.get("PORT", 3000)))

import { messagingApi } from "@line/bot-sdk"

const text: messagingApi.TextMessage = {
  type: "text",
  text: "Hello! How can we help today?", // up to 5,000 characters
}

const image: messagingApi.ImageMessage = {
  type: "image",
  originalContentUrl: "https://example.com/price-list.jpg", // HTTPS, JPEG or PNG, max 10 MB
  previewImageUrl: "https://example.com/price-list-preview.jpg", // max 1 MB
}

const card: messagingApi.FlexMessage = {
  type: "flex",
  altText: "Haircut – ฿450", // shown in notifications and the chat list
  contents: {
    type: "bubble",
    hero: {
      type: "image",
      url: "https://example.com/haircut.jpg",
      size: "full",
      aspectRatio: "20:13",
      aspectMode: "cover",
    },
    body: {
      type: "box",
      layout: "vertical",
      contents: [
        { type: "text", text: "Haircut", weight: "bold", size: "xl" },
        { type: "text", text: "฿450 · 45 minutes", color: "#06C755" },
      ],
    },
    footer: {
      type: "box",
      layout: "vertical",
      contents: [
        {
          type: "button",
          style: "primary",
          color: "#06C755",
          action: { type: "postback", label: "Book", data: "action=service&id=cut", displayText: "Book a haircut" },
        },
      ],
    },
  },
}

const menu: messagingApi.TextMessage = {
  type: "text",
  text: "What would you like to do?",
  quickReply: {
    items: [
      // up to 13 buttons
      { type: "action", action: { type: "postback", label: "Book", data: "action=start_booking", displayText: "Book" } },
      { type: "action", action: { type: "message", label: "Opening hours", text: "Opening hours" } },
      { type: "action", action: { type: "location", label: "Send my location" } },
    ],
  },
}

type Session =
  | { step: "idle" }
  | { step: "pick_date"; service: string }
  | { step: "confirm"; service: string; date: string }
  | { step: "human" } // a team member has taken over this chat

// In memory for the tutorial: it is lost on restart and isn't shared between
// instances. Use Redis or your database in production.
const sessions = new Map<string, Session>()

const SERVICES: Record<string, string> = { cut: "Haircut", color: "Hair color" }

async function handleEvent(event: webhook.Event) {
  // This tutorial handles 1:1 chats only.
  if (event.source?.type !== "user" || !event.source.userId) return
  const userId = event.source.userId

  if (event.type === "follow") {
    await reply(event.replyToken, [menuMessage("Welcome! Thanks for adding us as a friend.")])
    return
  }

  const session = sessions.get(userId) ?? { step: "idle" }
  if (session.step === "human") return // staff replies from LINE Official Account Manager

  if (event.type === "postback" && event.replyToken) {
    await onPostback(userId, session, event.postback, event.replyToken)
    return
  }

  if (event.type === "message" && event.replyToken) {
    if (event.message.type !== "text") {
      await reply(event.replyToken, [menuMessage("Thanks! I can only read text messages.")])
      return
    }
    const text = event.message.text.trim()
    if (["staff", "human"].includes(text.toLowerCase())) {
      sessions.set(userId, { step: "human" })
      await reply(event.replyToken, [
        { type: "text", text: "OK! A team member will answer in this chat during opening hours (10:00-20:00)." },
      ])
      return
    }
    await reply(event.replyToken, [menuMessage("Please choose an option below.")]) // AI section replaces this line
  }
}

async function onPostback(userId: string, session: Session, postback: webhook.PostbackContent, replyToken: string) {
  const data = new URLSearchParams(postback.data)
  const action = data.get("action")

  if (action === "start_booking") {
    await reply(replyToken, [{
      type: "text",
      text: "Which service would you like?",
      quickReply: {
        items: Object.entries(SERVICES).map(([id, label]) => ({
          type: "action" as const,
          action: { type: "postback" as const, label, data: `action=service&id=${id}`, displayText: label },
        })),
      },
    }])
    return
  }

  if (action === "service") {
    const service = SERVICES[data.get("id") ?? ""]
    if (!service) return
    sessions.set(userId, { step: "pick_date", service })
    await reply(replyToken, [{
      type: "text",
      text: `${service}: which day suits you?`,
      quickReply: {
        items: [{ type: "action", action: { type: "datetimepicker", label: "Pick a date", data: "action=date", mode: "date" } }],
      },
    }])
    return
  }

  if (action === "date" && session.step === "pick_date" && postback.params?.date) {
    const next: Session = { step: "confirm", service: session.service, date: postback.params.date }
    sessions.set(userId, next)
    await reply(replyToken, [{
      type: "text",
      text: `${next.service} on ${next.date}. Shall I send the request?`,
      quickReply: {
        items: [
          { type: "action", action: { type: "postback", label: "Confirm", data: "action=confirm", displayText: "Confirm" } },
          { type: "action", action: { type: "postback", label: "Cancel", data: "action=cancel", displayText: "Cancel" } },
        ],
      },
    }])
    return
  }

  if (action === "confirm" && session.step === "confirm") {
    sessions.delete(userId)
    // Save the request in your booking system or notify your team here.
    await reply(replyToken, [
      { type: "text", text: `Request received: ${session.service} on ${session.date}. We'll confirm the time in this chat.` },
    ])
    return
  }

  if (action === "cancel") {
    sessions.delete(userId)
    await reply(replyToken, [menuMessage("Cancelled. Anything else?")])
  }
}

function menuMessage(text: string): messagingApi.TextMessage {
  return {
    type: "text",
    text,
    quickReply: {
      items: [
        { type: "action", action: { type: "postback", label: "Book", data: "action=start_booking", displayText: "Book" } },
        { type: "action", action: { type: "message", label: "Staff", text: "staff" } },
      ],
    },
  }
}

async function reply(replyToken: string, messages: messagingApi.Message[]) {
  await client.replyMessage({ replyToken, messages })
}

from urllib.parse import parse_qsl

from linebot.v3.webhooks import PostbackEvent


@handler.add(PostbackEvent)
def handle_postback(event):
    data = dict(parse_qsl(event.postback.data))  # "action=service&id=cut"
    if data.get("action") == "date" and event.postback.params:
        text = f"Date chosen: {event.postback.params['date']}"
    else:
        text = f"Action: {data.get('action')}"
    with ApiClient(configuration) as api_client:
        MessagingApi(api_client).reply_message(
            ReplyMessageRequest(reply_token=event.reply_token, messages=[TextMessage(text=text)])
        )

// src/ai.ts
import { GoogleGenAI } from "@google/genai"

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY })
const model = process.env.GEMINI_MODEL // a current model name from Google's documentation
if (!model) throw new Error("Set GEMINI_MODEL")

// Only facts you are happy for the bot to repeat word for word.
const FAQ = `
Opening hours: 10:00-20:00, closed on Wednesdays.
Address: 12 Sukhumvit Soi 24, Bangkok (BTS Phrom Phong).
Haircut: ฿450, 45 minutes. Hair color: from ฿1,500, about 2 hours.
Booking: tap "Book" in the menu. Changes are possible up to 3 hours before.
`

export async function answerFromFaq(question: string): Promise<string | null> {
  const response = await ai.models.generateContent({
    model: model!,
    contents: question,
    config: {
      systemInstruction:
        "You answer customer questions for a hair salon using ONLY the FAQ below. " +
        "If the FAQ doesn't contain the answer, reply exactly NO_ANSWER. " +
        "Answer in the customer's language, in at most 3 short sentences. Never invent prices, times or promotions.\n\n" +
        `FAQ:\n${FAQ}`,
      temperature: 0.2,
      maxOutputTokens: 300,
      abortSignal: AbortSignal.timeout(15_000), // stay well inside the reply token's time limit
    },
  })
  const text = response.text?.trim()
  if (!text || text.includes("NO_ANSWER")) return null
  return text.slice(0, 5000) // a LINE text message holds up to 5,000 characters
}

// at the top of src/index.ts (ES modules need the .js extension)
import { answerFromFaq } from "./ai.js"

// in handleEvent, instead of always sending the menu for free text:
await client.showLoadingAnimation({ chatId: userId, loadingSeconds: 20 })
const answer = await answerFromFaq(text).catch(() => null)
await reply(event.replyToken, [
  answer
    ? { type: "text", text: answer }
    : menuMessage("I'm not sure about that one. Tap Staff to reach a team member."),
])

FROM node:22-slim AS build
WORKDIR /app
COPY package*.json tsconfig.json ./
RUN npm ci
COPY src ./src
RUN npm run build

FROM node:22-slim
WORKDIR /app
ENV NODE_ENV=production
COPY package*.json ./
RUN npm ci --omit=dev
COPY --from=build /app/dist ./dist
EXPOSE 3000
CMD ["node", "dist/index.js"]

import { HTTPFetchError } from "@line/bot-sdk"

const seen = new Map<string, number>() // webhookEventId -> time received. Use Redis (SET NX + TTL) with several instances.

function firstDelivery(event: webhook.Event): boolean {
  const now = Date.now()
  for (const [id, at] of seen) if (now - at > 30 * 60_000) seen.delete(id)
  if (seen.has(event.webhookEventId)) return false
  seen.set(event.webhookEventId, now)
  return true
}

function log(level: "info" | "error", msg: string, data: Record<string, unknown> = {}) {
  console.log(JSON.stringify({ time: new Date().toISOString(), level, msg, ...data }))
}

app.post("/webhook", middleware({ channelSecret }), (req, res) => {
  res.sendStatus(200)
  const { events } = req.body as webhook.CallbackRequest
  for (const event of events) {
    if (!firstDelivery(event)) continue // same event delivered twice
    handleEvent(event).catch((err) => {
      if (err instanceof HTTPFetchError) {
        // 429: rate limit or monthly message limit; 400 "Invalid reply token": used or too old
        log("error", "LINE API error", { status: err.status, body: err.body, eventId: event.webhookEventId })
      } else {
        log("error", "event failed", { error: String(err), eventId: event.webhookEventId })
      }
    })
  }
})