Google Search Console 인덱싱 자동 모니터링 — GitHub Actions + Telegram 30분 구축기

[GitHub Actions cron]
         ↓
  1. sitemap-index.xml fetch → URL 전체 추출
         ↓
  2. URL마다 GSC URL Inspection API 호출 (서비스 계정 인증)
         ↓
  3. 이전 상태(data/indexing-status.json)와 diff 계산
         ↓
  4. 변화가 있으면 Telegram HTML 메시지 전송
         ↓
  5. 새 상태를 JSON에 저장하고 자동 커밋

scripts/gsc-monitor/
├── package.json              # googleapis + fast-xml-parser
├── run.js                    # 오케스트레이션 (40줄)
└── lib/
    ├── sitemap.js            # sitemap-index → URL 배열
    ├── gsc.js                # URL Inspection API 호출
    ├── diff.js               # 이전 결과와 비교, 요약 계산
    └── telegram.js           # HTML 메시지 빌더 + 전송

.github/workflows/gsc-monitor.yml    # cron + workflow_dispatch
data/indexing-status.json            # 상태 스냅샷 (봇이 자동 커밋)

import { XMLParser } from "fast-xml-parser"

const parser = new XMLParser({ ignoreAttributes: false })

async function fetchXml(url) {
  const res = await fetch(url, { headers: { "User-Agent": "gsc-monitor/1.0" } })
  if (!res.ok) throw new Error(`${url} → HTTP ${res.status}`)
  return parser.parse(await res.text())
}

export async function extractAllUrls(indexUrl) {
  const index = await fetchXml(indexUrl)
  const children = [].concat(index.sitemapindex?.sitemap ?? [])
  const urlSets =
    children.length > 0
      ? await Promise.all(children.map(s => fetchXml(s.loc)))
      : [index]
  const urls = new Set()
  for (const doc of urlSets) {
    for (const entry of [].concat(doc.urlset?.url ?? [])) {
      if (entry.loc) urls.add(entry.loc)
    }
  }
  return Array.from(urls)
}

import { google } from "googleapis"

export function createClient(serviceAccountKey) {
  const auth = new google.auth.GoogleAuth({
    credentials: JSON.parse(serviceAccountKey),
    scopes: ["https://www.googleapis.com/auth/webmasters.readonly"],
  })
  return google.searchconsole({ version: "v1", auth })
}

export async function inspectUrl(client, { siteUrl, inspectionUrl }) {
  const res = await client.urlInspection.index.inspect({
    requestBody: { siteUrl, inspectionUrl, languageCode: "ko" },
  })
  const idx = res.data.inspectionResult?.indexStatusResult ?? {}
  return {
    url: inspectionUrl,
    verdict: idx.verdict,
    coverageState: idx.coverageState,
    lastCrawlTime: idx.lastCrawlTime,
    googleCanonical: idx.googleCanonical,
    userCanonical: idx.userCanonical,
  }
}

const INDEXED_STATES = new Set([
  "Submitted and indexed",
  "Indexed, not submitted in sitemap",
])

export function diffResults(previous = [], current = []) {
  const prev = new Map(previous.map(r => [r.url, r]))
  const newlyIndexed = []
  const newlyDeindexed = []
  const canonicalMismatch = []

  for (const curr of current) {
    const prevEntry = prev.get(curr.url)
    const currIndexed = INDEXED_STATES.has(curr.coverageState ?? "")
    const prevIndexed = prevEntry
      ? INDEXED_STATES.has(prevEntry.coverageState ?? "")
      : false

    if (currIndexed && !prevIndexed) newlyIndexed.push(curr)
    if (!currIndexed && prevIndexed) newlyDeindexed.push(curr)
    if (
      curr.googleCanonical &&
      curr.userCanonical &&
      curr.googleCanonical !== curr.userCanonical
    )
      canonicalMismatch.push(curr)
  }

  const indexed = current.filter(c =>
    INDEXED_STATES.has(c.coverageState ?? "")
  ).length
  return {
    newlyIndexed,
    newlyDeindexed,
    canonicalMismatch,
    total: current.length,
    indexed,
    rate:
      current.length === 0
        ? 0
        : Math.round((indexed / current.length) * 1000) / 10,
  }
}

export async function sendTelegram(token, chatId, text) {
  const url = `https://api.telegram.org/bot${token}/sendMessage`
  const res = await fetch(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      chat_id: chatId,
      text,
      parse_mode: "HTML",
      disable_web_page_preview: true,
    }),
  })
  if (!res.ok) throw new Error(`Telegram ${res.status}: ${await res.text()}`)
}

name: GSC Indexing Monitor

on:
  schedule:
    - cron: "0 0 * * 1" # 매주 월요일 00:00 UTC (09:00 KST)
  workflow_dispatch:
    inputs:
      force_notify:
        description: "변경 없어도 Telegram 알림 전송"
        default: "false"
        type: choice
        options: ["false", "true"]

permissions:
  contents: write

jobs:
  monitor:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: "20" }

      - name: Install
        working-directory: scripts/gsc-monitor
        run: npm install --no-audit --no-fund

      - name: Run
        working-directory: scripts/gsc-monitor
        env:
          GSC_SERVICE_ACCOUNT_KEY: ${{ secrets.GSC_SERVICE_ACCOUNT_KEY }}
          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
          GSC_SITE_URL: sc-domain:blog.javapark.kr
          SITE_ORIGIN: https://blog.javapark.kr
          FORCE_NOTIFY: ${{ inputs.force_notify }}
        run: node run.js

      - name: Commit status
        run: |
          git config user.name "gsc-monitor-bot"
          git config user.email "bot@users.noreply.github.com"
          git add data/indexing-status.json
          if git diff --staged --quiet; then
            echo "No changes"
          else
            git commit -m "chore(gsc): update $(date -u +%Y-%m-%d)"
            git push
          fi

{
  "generatedAt": "2026-04-20T16:06:00.795Z",
  "siteUrl": "sc-domain:blog.javapark.kr",
  "summary": {
    "total": 57,
    "indexed": 0,
    "rate": 0,
    "stillPending": 57
  }
}

{
  "verdict": "NEUTRAL",
  "coverageState": "Google에는 아직 알려지지 않은 URL입니다.",
  "indexingState": "INDEXING_STATE_UNSPECIFIED",
  "lastCrawlTime": null,
  "googleCanonical": null
}

🔔 GSC Indexing Monitor
2026-04-28 · https://blog.javapark.kr

✅ 신규 인덱싱: 3건
  • /devops/k8s-understanding/
  • /devops/kubectl-essential-commands/
  • /devops/k9s-essential-guide/

⚠️ 인덱싱 대기: 54건

📈 전체: 57개 중 3개 인덱싱 (5.3%)