สอนเขียน LINE Bot ด้วย Node.js และ Python (Messaging API) 2026

ผู้ใช้ ── ข้อความ ──▶ LINE Platform ── webhook (POST + x-line-signature) ──▶ เซิร์ฟเวอร์ของคุณ
                                                                              │
ผู้ใช้ ◀── คำตอบ ─── LINE Platform ◀──── Messaging API (reply หรือ 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("กรุณาตั้งค่า LINE_CHANNEL_SECRET และ LINE_CHANNEL_ACCESS_TOKEN")
}

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

// middleware ของ LINE ตรวจ x-line-signature จาก body ดิบ
// จึงต้องวางไว้ก่อนตัวแปลง JSON ทุกตัว
app.post("/webhook", middleware({ channelSecret }), (req, res) => {
  res.sendStatus(200) // ตอบ LINE ก่อน แล้วค่อยประมวลผล
  const { events } = req.body as webhook.CallbackRequest
  for (const event of events) {
    handleEvent(event).catch((err) => console.error("ประมวลผล event ไม่สำเร็จ", err))
  }
})

app.use(express.json()) // route อื่นแปลง JSON ได้ตามปกติ

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: `คุณพิมพ์ว่า: ${event.message.text}` }],
  })
}

// middleware แค่ส่ง error ต่อให้ next() ถ้าไม่มี handler นี้ Express จะตอบ 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 รออยู่ที่พอร์ต ${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)  # body ดิบ ก่อนแปลงเป็น JSON
    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"คุณพิมพ์ว่า: {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: "สวัสดีค่ะ วันนี้ให้ร้านช่วยเรื่องอะไรดีคะ", // ไม่เกิน 5,000 ตัวอักษร
}

const image: messagingApi.ImageMessage = {
  type: "image",
  originalContentUrl: "https://example.com/price-list.jpg", // HTTPS, JPEG หรือ PNG, ไม่เกิน 10 MB
  previewImageUrl: "https://example.com/price-list-preview.jpg", // ไม่เกิน 1 MB
}

const card: messagingApi.FlexMessage = {
  type: "flex",
  altText: "ตัดผม ฿450", // แสดงในการแจ้งเตือนและรายการแชท
  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: "ตัดผม", weight: "bold", size: "xl" },
        { type: "text", text: "฿450 · 45 นาที", color: "#06C755" },
      ],
    },
    footer: {
      type: "box",
      layout: "vertical",
      contents: [
        {
          type: "button",
          style: "primary",
          color: "#06C755",
          action: { type: "postback", label: "จองคิว", data: "action=service&id=cut", displayText: "ขอจองคิวตัดผม" },
        },
      ],
    },
  },
}

const menu: messagingApi.TextMessage = {
  type: "text",
  text: "ต้องการทำรายการอะไรคะ",
  quickReply: {
    items: [
      // ได้สูงสุด 13 ปุ่ม
      { type: "action", action: { type: "postback", label: "จองคิว", data: "action=start_booking", displayText: "จองคิว" } },
      { type: "action", action: { type: "message", label: "เวลาเปิดร้าน", text: "เวลาเปิดร้าน" } },
      { type: "action", action: { type: "location", label: "ส่งตำแหน่งของฉัน" } },
    ],
  },
}

type Session =
  | { step: "idle" }
  | { step: "pick_date"; service: string }
  | { step: "confirm"; service: string; date: string }
  | { step: "human" } // พนักงานรับช่วงแชทนี้แล้ว

// เก็บในหน่วยความจำเพื่อการสาธิต ข้อมูลจะหายเมื่อรีสตาร์ตและไม่แชร์ระหว่างหลาย instance
// ระบบจริงให้ใช้ Redis หรือฐานข้อมูล
const sessions = new Map<string, Session>()

const SERVICES: Record<string, string> = { cut: "ตัดผม", color: "ทำสีผม" }

async function handleEvent(event: webhook.Event) {
  // บทความนี้รองรับเฉพาะแชท 1:1
  if (event.source?.type !== "user" || !event.source.userId) return
  const userId = event.source.userId

  if (event.type === "follow") {
    await reply(event.replyToken, [menuMessage("ยินดีต้อนรับค่ะ ขอบคุณที่เพิ่มร้านเป็นเพื่อน")])
    return
  }

  const session = sessions.get(userId) ?? { step: "idle" }
  if (session.step === "human") return // พนักงานตอบจาก 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("ขอบคุณค่ะ ตอนนี้บอทอ่านได้เฉพาะข้อความตัวอักษร")])
      return
    }
    const text = event.message.text.trim()
    if (["staff", "พนักงาน"].includes(text.toLowerCase())) {
      sessions.set(userId, { step: "human" })
      await reply(event.replyToken, [
        { type: "text", text: "ได้เลยค่ะ พนักงานจะตอบในแชทนี้ระหว่างเวลาทำการ (10:00-20:00)" },
      ])
      return
    }
    await reply(event.replyToken, [menuMessage("กรุณาเลือกรายการด้านล่างค่ะ")]) // หัวข้อ AI จะมาแทนบรรทัดนี้
  }
}

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: "ต้องการจองบริการไหนคะ",
      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}: สะดวกวันไหนคะ`,
      quickReply: {
        items: [{ type: "action", action: { type: "datetimepicker", label: "เลือกวันที่", 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} วันที่ ${next.date} ส่งคำขอจองเลยไหมคะ`,
      quickReply: {
        items: [
          { type: "action", action: { type: "postback", label: "ยืนยัน", data: "action=confirm", displayText: "ยืนยัน" } },
          { type: "action", action: { type: "postback", label: "ยกเลิก", data: "action=cancel", displayText: "ยกเลิก" } },
        ],
      },
    }])
    return
  }

  if (action === "confirm" && session.step === "confirm") {
    sessions.delete(userId)
    // บันทึกคำขอลงระบบจองคิว หรือแจ้งพนักงานตรงนี้
    await reply(replyToken, [
      { type: "text", text: `ได้รับคำขอแล้วค่ะ: ${session.service} วันที่ ${session.date} ร้านจะยืนยันเวลาในแชทนี้` },
    ])
    return
  }

  if (action === "cancel") {
    sessions.delete(userId)
    await reply(replyToken, [menuMessage("ยกเลิกแล้วค่ะ มีอะไรให้ช่วยอีกไหมคะ")])
  }
}

function menuMessage(text: string): messagingApi.TextMessage {
  return {
    type: "text",
    text,
    quickReply: {
      items: [
        { type: "action", action: { type: "postback", label: "จองคิว", data: "action=start_booking", displayText: "จองคิว" } },
        { type: "action", action: { type: "message", label: "ติดต่อพนักงาน", text: "พนักงาน" } },
      ],
    },
  }
}

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"วันที่เลือก: {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 // ชื่อโมเดลปัจจุบันจากเอกสารของ Google
if (!model) throw new Error("กรุณาตั้งค่า GEMINI_MODEL")

// ใส่เฉพาะข้อมูลที่ยอมให้บอทพูดซ้ำได้ทุกคำ
const FAQ = `
เวลาเปิดร้าน: 10:00-20:00 ปิดทุกวันพุธ
ที่อยู่: 12 ซอยสุขุมวิท 24 กรุงเทพฯ (BTS พร้อมพงษ์)
ตัดผม: ฿450 ประมาณ 45 นาที ทำสีผม: เริ่มต้น ฿1,500 ประมาณ 2 ชั่วโมง
จองคิว: กด "จองคิว" ในเมนู เปลี่ยนเวลาได้ก่อนนัด 3 ชั่วโมง
`

export async function answerFromFaq(question: string): Promise<string | null> {
  const response = await ai.models.generateContent({
    model: model!,
    contents: question,
    config: {
      systemInstruction:
        "คุณคือผู้ช่วยตอบคำถามลูกค้าของร้านทำผม ให้ตอบโดยใช้ข้อมูลใน FAQ ด้านล่างเท่านั้น " +
        "ถ้า FAQ ไม่มีคำตอบ ให้ตอบว่า NO_ANSWER เท่านั้น " +
        "ตอบเป็นภาษาเดียวกับลูกค้า ไม่เกิน 3 ประโยคสั้น ๆ ห้ามแต่งราคา เวลา หรือโปรโมชันขึ้นเอง\n\n" +
        `FAQ:\n${FAQ}`,
      temperature: 0.2,
      maxOutputTokens: 300,
      abortSignal: AbortSignal.timeout(15_000), // ให้เสร็จก่อน reply token หมดเวลา
    },
  })
  const text = response.text?.trim()
  if (!text || text.includes("NO_ANSWER")) return null
  return text.slice(0, 5000) // ข้อความตัวอักษรของ LINE ยาวได้ไม่เกิน 5,000 ตัวอักษร
}

// ด้านบนของ src/index.ts (ES modules ต้องใส่นามสกุล .js)
import { answerFromFaq } from "./ai.js"

// ใน handleEvent แทนการส่งเมนูทุกครั้งที่ผู้ใช้พิมพ์อิสระ:
await client.showLoadingAnimation({ chatId: userId, loadingSeconds: 20 })
const answer = await answerFromFaq(text).catch(() => null)
await reply(event.replyToken, [
  answer
    ? { type: "text", text: answer }
    : menuMessage("ขออภัยค่ะ เรื่องนี้บอทยังตอบไม่ได้ กด “ติดต่อพนักงาน” เพื่อคุยกับพนักงานได้เลย"),
])

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 -> เวลาที่ได้รับ ถ้ามีหลาย instance ให้ใช้ Redis (SET NX + TTL)

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 // event เดียวกันมาถึงสองครั้ง
    handleEvent(event).catch((err) => {
      if (err instanceof HTTPFetchError) {
        // 429: ชน rate limit หรือโควตารายเดือน; 400 "Invalid reply token": ใช้ไปแล้วหรือเกินเวลา
        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 })
      }
    })
  }
})