# Audit & Auto-Fix Internal Linking Menggunakan Python + Gemini API: Cara Memetakan Topical Authority dari Ratusan Artikel WordPress dan Menyuntikkan Internal Link Kontekstual Secara Otomatis Tanpa Merusak Struktur HTML

- URL: https://komunitech.com/blog/tutorial/audit-auto-fix-internal-linking-python-gemini-api/
- Diterbitkan: 2026-11-20
- Diperbarui: 2026-11-20
- Penulis: Priyo Harjiyono
- Penerbit: KomuniTech (https://komunitech.com)

---

**TL;DR:** Kalau situsmu sudah ratusan artikel, internal link manual satu-satu tidak akan pernah selesai — dan kamu tidak tahu artikel mana yang yatim alias tidak punya satu pun inbound link. Artikel ini membangun skrip Python yang menarik semua artikel WordPress lewat REST API, memetakan klaster topik dan artikel yatim, lalu memakai Gemini API buat menilai pasangan artikel yang relevan dan menyuntikkan link-nya ke HTML dengan BeautifulSoup. Semua jalan dalam mode dry-run dulu, dengan backup, sebelum ada perubahan yang ditulis balik.



**💡 Key Takeaway**




- **Internal link itu peta topical authority.** Link internal membantu crawler menemukan halaman, menyalurkan otoritas dari halaman kuat, dan memberi sinyal hubungan antar topik.

- **REST API WordPress mengembalikan maksimal 100 artikel per request.** Baca totalnya dari header X-WP-TotalPages, lalu looping dengan per_page=100 dan _fields.

- **Gemini menilai relevansi lewat structured output.** Skema Pydantic memaksa jawaban selalu berbentuk JSON yang bisa diparse.

- **Injeksi yang aman cuma di dalam <p> yang belum punya link.** Jangan sentuh heading, code block, atau link yang sudah ada; anchor harus frasa yang sudah tertulis di teks.

- **Dry-run dan backup dulu, selalu.** Skor Gemini itu pendapat model, bukan kebenaran — review laporan sebelum menulis balik.





## Ratusan artikel, nol peta: kenapa internal link-mu mungkin berantakan


Bayangin blog WordPress dengan 500 artikel. Setiap kali ada artikel baru, penulisnya menambahkan dua-tiga internal link dari ingatan — artikel yang dia ingat atau kebetulan muncul di pencarian wp-admin. Setelah dua tahun, artikel pilar yang seharusnya jadi pusat topik malah sepi inbound link, sementara sepuluh artikel acak saling menautkan tanpa pola. Ada juga artikel bagus yang tidak pernah ditautkan dari mana pun. Di dunia SEO, artikel seperti itu disebut orphan page.


Masalahnya bukan cuma soal kerapian. Crawler Google menemukan halaman lewat link — artikel tanpa inbound link internal jauh lebih lambat ditemukan dan diindeks, dan pembaca pun praktis tidak pernah sampai ke sana. Membereskannya manual itu pekerjaan berminggu-minggu. Automasi masuk akal justru di sini: memindai seluruh situs, menghitung siapa menautkan siapa, lalu mengusulkan pasangan artikel yang relevan berdasarkan isi, bukan ingatan.



## Kenapa internal link itu soal authority, bukan cuma navigasi


Banyak orang mengira internal link cuma soal kenyamanan pembaca — benar, tapi cuma sepertiga ceritanya. Buat mesin pencari, internal link punya tiga fungsi sekaligus. **Pertama, discovery:** crawler menemukan halaman baru dengan mengikuti link dari halaman yang sudah dikenal. **Kedua, distribusi authority:** halaman yang sudah kuat "mengalirkan" sebagian otoritasnya ke halaman yang ditautkannya, sehingga artikel pilar bisa mengangkat seluruh klaster. **Ketiga, sinyal topikal:** anchor text dan konteks paragraf di sekitar link memberi tahu Google bahwa dua halaman itu berhubungan. Inilah inti topical authority: bukan satu artikel yang hebat, tapi satu jaringan artikel yang saling menguatkan.





| **Peran**
| **Cirinya**
| **Yang harus dilakukan**



| Halaman pilar
| Membahas topik luas, jadi rujukan utama satu klaster
| Ditaautkan dari semua artikel pendukung di klasternya



| Artikel pendukung
| Membahas sub-topik spesifik, menautkan balik ke pilar
| Dapat 1–3 link dari artikel lain di klaster yang sama



| Artikel yatim (orphan)
| Tidak punya satu pun inbound link internal
| Prioritas pertama audit — cari pasangan yang relevan dan tautkan





Topical authority bukan metrik resmi Google — ini kerangka kerja praktisi SEO, yang makin relevan di era AI search, seperti dibahas di artikel soal [perbedaan SEO, AEO, GEO, dan AIO](https://komunitech.com/blog/karir-skill/geo-aeo-aio-adalah-perbedaan-dengan-seo/).



## Langkah 1: tarik semua artikel dari WordPress lewat REST API


Semua bermula dari satu pertanyaan: artikel apa saja yang ada di situs ini, dan apa isinya? WordPress sudah menyediakan jawabannya lewat REST API bawaan: endpoint GET /wp/v2/posts mengembalikan daftar artikel sebagai JSON, lengkap dengan judul, slug, URL, dan kategori. Artikel publik bisa dibaca tanpa login; yang butuh autentikasi cuma write-back nanti.


Ada dua detail yang wajib kamu pegang. **Pertama, pagination.** REST API mengembalikan maksimal 10 artikel per request secara default, dan parameter per_page dibatasi 1 sampai 100 — minta lebih dari itu dan server menjawab HTTP 400. Setiap respons paginasi membawa dua header penting: X-WP-Total dan X-WP-TotalPages — baca dari respons pertama, lalu looping halaman demi halaman sampai selesai. **Kedua, ringankan responsnya.** Field content.rendered itu besar; parameter _fields membatasi field yang dikembalikan — cukup id,slug,link,title,categories,content buat audit ini. Kalau WordPress-mu terpasang di subdirektori seperti /blog, endpoint-nya ikut di sana, misalnya https://situsmu.com/blog/wp-json/wp/v2/posts.



## Langkah 2: petakan topical authority-mu — siapa yatim, siapa pilar


Setelah semua artikel ketarik, jangan langsung menilai relevansi — itu tugas Gemini nanti. Hitung dulu siapa menautkan siapa. Setiap content.rendered adalah HTML; parse dengan BeautifulSoup dan hitung berapa inbound link yang diterima tiap artikel. Artikel dengan inbound nol itulah daftar yatimmu — prioritas pertama audit. Fungsi hitung_inbound di skrip lengkap melakukan itu: URL dinormalisasi dengan membuang garis miring di akhir, dan self-link sengaja tidak dihitung. Satu keterbatasan: fungsi ini cuma menghitung link absolut — kalau situsmu memakai link relatif, normalisasi dulu semua href.


Dari hitungan ini, peta situsmu langsung terlihat: sebagian besar artikel pendukung punya 1–3 inbound link, dan 10–20% tidak punya inbound sama sekali — angka kasar dari pengalaman audit, bukan kutipan penelitian. Klaster topiknya bisa dipetakan dari kategori WordPress dan kata kunci judul. Fungsi shortlist di skrip lengkap melakukan itu: ambil kata kunci judul, beri skor tumpang tindih kata plus bonus kategori sama, lalu ambil 8 kandidat teratas per artikel — makin sedikit kandidat yang dikirim ke Gemini, makin murah.



## Langkah 3: biar Gemini yang menilai relevan atau tidak


Pencocokan kata kunci cuma bisa bilang "judulnya mirip" — dia tidak bisa bilang apakah artikel A benar-benar membantu pembaca artikel B — penilaian seperti itu butuh membaca, dan di sinilah model bahasa masuk: kirim judul plus cuplikan isi artikel sumber dan 8 kandidatnya ke Gemini, lalu minta dia mengembalikan pasangan yang benar-benar relevan sebagai JSON. Kuncinya: structured output lewat skema Pydantic — tanpa ini, satu respons nyasar saja sudah cukup merusak seluruh jalan skrip.


Model yang dipakai sengaja yang murah: gemini-3.8-flash — menilai relevansi itu tugas klasifikasi ringan, tidak butuh penalaran berlapis model paling mahal. Harga per 20 November 2026, dari halaman pricing resmi Google (Gemini 4 Carbon harganya sama dengan Argon):





| **Model**
| **Input / 1 jt token**
| **Output / 1 jt token**
| **Cache baca / 1 jt token**



| Gemini 3.8 Flash
| $0,75 s.d. 31 Des 2026, lalu $1,50 mulai 1 Jan 2027
| $3,75 s.d. 31 Des 2026, lalu $7,50 mulai 1 Jan 2027
| $0,075 s.d. 31 Des 2026, lalu $0,15 mulai 1 Jan 2027



| Gemini 4 Argon
| $2,00 s.d. 30 Nov 2026, lalu $4,00 mulai 1 Des 2026
| $10,00 s.d. 30 Nov 2026, lalu $20,00 mulai 1 Des 2026
| $0,10 s.d. 30 Nov 2026, lalu $0,20 mulai 1 Des 2026





Harga di atas adalah foto per 20 November 2026 — Argon dan Carbon naik dua kali lipat per 1 Desember 2026, Flash naik per 1 Januari 2027. Cek halaman pricing Google sebelum menghitung anggaran. Batch API memberi diskon 50% buat pekerjaan yang tidak butuh jawaban seketika, seperti dibahas di artikel soal [tujuh fitur Gemini API yang jarang dipakai](https://komunitech.com/blog/tutorial/7-fitur-gemini-api-yang-jarang-dipakai-tapi-bikin-agent-lebih-murah-2026/). Terakhir: skor Gemini itu pendapat model, bukan kebenaran — karena itu ada ambang skor 70, batas 3 link baru per artikel, dan laporan buat direview.



## Aturan injeksi yang aman: jangan rusak HTML yang sudah bagus


Menilai relevansi itu separuh pekerjaan. Separuh lainnya adalah menyuntikkan link ke HTML tanpa merusaknya, dan godaan terbesar di sini adalah regex. Regex tidak paham struktur HTML: dia bisa menyisipkan link di dalam atribut alt gambar, memotong tag yang sedang terbuka, atau membuat link bersarang. Karena itu injeksi harus dilakukan di level parse tree. Aturannya:





| **Aturan**
| **Kenapa**



| Hanya di dalam <p>
| Paragraf adalah tempat link kontekstual tinggal; heading, list, dan tabel bukan tempatnya



| Jangan sentuh teks di dalam <a>, <code>, dan <pre>
| Link bersarang tidak valid; anchor di dalam contoh kode merusak kode itu sendiri



| Anchor harus frasa yang sudah ada di teks
| Menambah kata baru ke kalimat berarti mengubah tulisan penulis — bukan tugas skrip audit



| Jangan self-link, satu pasangan cuma sekali
| Artikel menautkan ke dirinya sendiri tidak membantu siapa pun; menautkan artikel yang sama dua kali itu spam



| Maksimal 3 link baru per artikel per jalan
| Artikel yang tiba-tiba dapat 10 link baru terlihat seperti dipompa, bukan dirapikan





Fungsi injeksi di skrip lengkap bekerja begini: untuk tiap rencana link, cari paragraf pertama yang belum punya link dan mengandung frasa anchor, lalu pecah node teks itu jadi tiga bagian dan ganti bagian tengah dengan tag <a> baru. Kalau frasa anchor tidak ditemukan persis di teks mana pun, lewati saja — lebih baik satu link hilang daripada satu kalimat rusak.



## Skrip lengkapnya: audit, skor, injeksi, laporan


Semua fungsi di atas dirangkai jadi satu file, audit_link.py: tarik artikel, hitung inbound, lewati artikel yang inbound-nya sudah 3 atau lebih, shortlist kandidat, skor dengan Gemini, saring skor di bawah 70, injeksi maksimal 3 link, simpan backup, lalu — hanya dengan flag --apply — tulis balik ke WordPress lewat POST /wp/v2/posts/<id> dengan Application Password. Tanpa flag itu, skrip cuma menulis laporan JSON.


Yang perlu disiapkan: Python 3.10+, pip install requests beautifulsoup4 google-genai pydantic, dan kunci API Gemini di GEMINI_API_KEY. Buat write-back, buat Application Password di wp-admin dan simpan di WP_APP_PASSWORD. Satu hal yang wajib ditegaskan: **skrip di bawah disusun mengikuti dokumentasi resmi, tapi belum dieksekusi terhadap situs produksi mana pun saat artikel ini ditulis.** Jalankan dulu dengan dry-run di situs staging, atau baca laporan JSON-nya sebelum memakai --apply.


#!/usr/bin/env python3
"""Audit & auto-fix internal linking WordPress.
Default: dry-run. Tulis balik hanya dengan --apply.
"""
import argparse
import json
import os
import re
import time
from pathlib import Path

import requests
from bs4 import BeautifulSoup, NavigableString
from google import genai
from pydantic import BaseModel, Field

MODEL = "gemini-3.8-flash"
MAX_NEW_LINKS = 3
MIN_SKOR = 70


class Penilaian(BaseModel):
url: str = Field(description="URL target")
anchor: str = Field(description="Frasa di teks sumber")
skor: int = Field(description="Skor 0-100")


class HasilSkor(BaseModel):
penilaian: list[Penilaian]


def teks_bersih(html):
return BeautifulSoup(html, "html.parser").get_text(" ", strip=True)


def fetch_all_posts(base_url):
posts, page = [], 1
while True:
r = requests.get(
f"{base_url}/wp-json/wp/v2/posts",
params={"per_page": 100, "page": page,
"_fields": "id,slug,link,title,categories,content"})
r.raise_for_status()
posts.extend(r.json())
total_pages = int(r.headers.get("X-WP-TotalPages", 1))
if page >= total_pages:
break
page += 1
time.sleep(0.2)
return posts


def hitung_inbound(posts):
inbound = {p["id"]: 0 for p in posts}
url_ke_id = {p["link"].rstrip("/"): p["id"] for p in posts}
for p in posts:
soup = BeautifulSoup(p["content"]["rendered"], "html.parser")
for a in soup.find_all("a", href=True):
target = a["href"].rstrip("/")
if target in url_ke_id and url_ke_id[target] != p["id"]:
inbound[url_ke_id[target]] += 1
return inbound


def kata_kunci(teks):
stop = {"dan", "yang", "untuk", "dengan", "dari", "cara", "atau", "ini", "itu"}
return {k for k in re.findall(r"[a-z]{4,}", teks.lower())
if k not in stop}


def shortlist(sumber, posts, maksimal=8):
kunci_sumber = kata_kunci(sumber["title"]["rendered"])
calon = []
for p in posts:
if p["id"] == sumber["id"]:
continue
tumpang = len(kunci_sumber & kata_kunci(p["title"]["rendered"]))
sama_kategori = bool(set(sumber["categories"]) & set(p["categories"]))
if tumpang >= 1 or sama_kategori:
calon.append((tumpang + (1 if sama_kategori else 0), p))
calon.sort(key=lambda x: x[0], reverse=True)
return [p for _, p in calon[:maksimal]]


def skor_kandidat(client, sumber, calon):
ringkas = lambda p: (
f"- {p['title']['rendered']} ({p['link']}): "
f"{teks_bersih(p['content']['rendered'])[:400]}")
prompt = (
"Nilai relevansi kandidat sebagai target internal link "
"dari artikel sumber. Kembalikan hanya pasangan yang benar-benar "
"relevan. Anchor harus frasa yang sudah ada di teks sumber.nn"
f"SUMBER: {sumber['title']['rendered']}n"
f"{teks_bersih(sumber['content']['rendered'])[:1200]}nn"
"KANDIDAT:n" + "n".join(ringkas(p) for p in calon))
inter = client.interactions.create(
model=MODEL, input=prompt,
response_format={"type": "text", "mime_type": "application/json",
"schema": HasilSkor.model_json_schema()})
return HasilSkor.model_validate_json(inter.output_text).penilaian


def sisipkan_satu(paragraf, anchor, url, soup):
for node in list(paragraf.descendants):
if not isinstance(node, NavigableString):
continue
if any(a.name in ("a", "code", "pre") for a in node.parents):
continue
cocok = re.search(re.escape(anchor), str(node), re.IGNORECASE)
if not cocok:
continue
teks = str(node)
tautan = soup.new_tag("a", href=url)
tautan.string = teks[cocok.start():cocok.end()]
node.replace_with(teks[:cocok.start()], tautan, teks[cocok.end():])
return True
return False


def injeksi(html, rencana):
soup = BeautifulSoup(html, "html.parser")
dipakai = set()
for item in rencana:
if item.url in dipakai:
continue
for p in soup.find_all("p"):
if p.find("a"):
continue
if sisipkan_satu(p, item.anchor, item.url, soup):
dipakai.add(item.url)
break
return str(soup)


def main():
ap = argparse.ArgumentParser()
ap.add_argument("--site", required=True)
ap.add_argument("--out", default="laporan-link.json")
ap.add_argument("--apply", action="store_true")
ap.add_argument("--user", default="")
args = ap.parse_args()

client = genai.Client()
posts = fetch_all_posts(args.site)
inbound = hitung_inbound(posts)
laporan = []

for p in posts:
if inbound[p["id"]] >= 3:
continue
calon = shortlist(p, posts)
if not calon:
continue
nilai = sorted([x for x in skor_kandidat(client, p, calon)
if x.skor >= MIN_SKOR],
key=lambda x: x.skor, reverse=True)
rencana = nilai[:MAX_NEW_LINKS]
if not rencana:
continue
html_baru = injeksi(p["content"]["rendered"], rencana)
Path("backup").mkdir(exist_ok=True)
Path(f"backup/{p['id']}.html").write_text(
p["content"]["rendered"], encoding="utf-8")
if args.apply:
app_pw = os.environ["WP_APP_PASSWORD"]
r = requests.post(
f"{args.site}/wp-json/wp/v2/posts/{p['id']}",
auth=(args.user, app_pw),
json={"content": html_baru})
r.raise_for_status()
laporan.append({
"id": p["id"], "slug": p["slug"],
"inbound_lama": inbound[p["id"]],
"link_baru": [{"url": x.url, "anchor": x.anchor,
"skor": x.skor} for x in rencana],
"ditulis_balik": bool(args.apply)})

Path(args.out).write_text(
json.dumps(laporan, indent=2, ensure_ascii=False), encoding="utf-8")
print(f"{len(posts)} artikel dipindai, "
f"{len(laporan)} artikel dapat link baru.")


if __name__ == "__main__":
main()
Cara menjalankannya: pertama python audit_link.py --site https://situsmu.com/blog buat dry-run. Buka laporan-link.json dan periksa pasangan link yang diusulkan — buka artikel sumber dan targetnya, pastikan tautannya masuk akal. Kalau sudah yakin, jalankan lagi dengan --apply --user nama-user-wp. Dan ingat pelajaran dari produksi blog Komunitech, yang didokumentasikan di artikel soal [AI Agent untuk konten SEO](https://komunitech.com/blog/riset/ai-agent-untuk-konten-seo-alur-riset-sampai-terbit-2026/): jangan pernah membiarkan mesin menebak URL — semua URL target di skrip ini berasal dari daftar artikel yang sudah terverifikasi lewat REST API, bukan dari ingatan model.



## Berapa biayanya buat 500 artikel?


Asumsinya: 500 artikel, tiap artikel dibandingkan dengan maksimal 8 kandidat tapi rata-rata cuma 5 yang lolos shortlist. Satu panggilan Gemini membawa judul plus cuplikan sumber (sekitar 300 token), 5 kandidat (sekitar 750 token), dan instruksi prompt (sekitar 150 token) — total sekitar 1.200 token input dan 150 output. Perkiraan token di sini kasar, tapi cukup buat mengukur orde biayanya.





| **Komponen**
| **Hitungan**
| **Gemini 3.8 Flash**
| **Gemini 4 Argon**



| Token input
| 2.500 × 1.200 ≈ 3,0 juta token
| 3,0 × $0,75 = $2,25
| 3,0 × $2,00 = $6,00



| Token output
| 2.500 × 150 ≈ 375 ribu token
| 0,375 × $3,75 = $1,41
| 0,375 × $10,00 = $3,75



| **Total satu audit penuh**
| **Harga per 20 Nov 2026**
| **≈ $3,66**
| **≈ $9,75**





Jadi satu audit penuh buat 500 artikel biayanya sekitar $3,66 dengan Flash. Pakai Batch API (diskon 50%) dan angkanya turun ke sekitar $1,80, dengan catatan hasilnya tidak instan. Bandingkan dengan biaya manusianya: satu artikel butuh 10 menit buat dibaca dan diputuskan tautannya — 500 artikel itu 83 jam kerja. Catatan: angka di atas memakai harga Flash sebelum kenaikan 1 Januari 2027 — setelah tanggal itu, total yang sama jadi sekitar $7,30.



## Kalau mentok: troubleshooting





| **Gejala**
| **Kemungkinan penyebab**
| **Perbaikannya**



| 401 / 403 saat --apply
| Application Password salah, atau user tidak punya izin edit
| Buat ulang Application Password; pastikan user berperan Editor atau Administrator



| 400 saat menarik artikel
| per_page di atas 100, atau page melebihi total
| Batasi per_page ke 100; berhenti berdasarkan header X-WP-TotalPages



| Respons Gemini tidak bisa diparse
| Skema tidak terkirim atau model mengembalikan teks di luar JSON
| Pastikan response_format terisi; coba sekali lagi lalu lewati pasangan itu



| 429 dari Gemini API
| Terlalu banyak panggilan dalam waktu singkat
| Tambahkan time.sleep() antar panggilan, atau pindah ke Batch API



| Link tidak tersisip padahal skornya tinggi
| Anchor tidak ditemukan persis di teks paragraf mana pun
| Normal — lewati. Jangan paksa dengan mengganti kata di kalimat






## Kapan automasi ini TIDAK cocok


**Situs kecil, di bawah 50 artikel.** Kalau seluruh situsmu bisa dibaca dalam satu sore, kerjakan manual — kamu kenal tiap artikel dan link yang kamu pasang dengan tangan akan lebih tepat daripada skor model. **Topik sensitif atau teregulasi.** Artikel soal kesehatan, keuangan, atau hukum punya risiko kalau anchor-nya salah tempat; tetap pakai skrip buat audit dan pemetaan, tapi pasang link-nya manual satu-satu. **Tidak ada proses review manusia.** Ini yang paling penting: skrip ini dirancang dengan dry-run dan laporan justru karena hasil mesin harus dicek. Kalau rencanamu adalah menjalankan --apply lalu tidak pernah membuka laporannya, jangan jalankan skrip ini. Automasi tanpa review bukan efisiensi — itu penyerahan kendali.



## Pertanyaan yang sering ditanya soal ini



### Apakah internal link otomatis bisa kena penalti Google?


Tidak ada penalti khusus — Google menilai hasilnya, bukan alatnya. Manipulasi itu pola berskala yang dibuat semata-mata buat memengaruhi ranking: ratusan link dengan anchor yang sama persis atau link yang tidak relevan. Selama link-nya relevan dan anchor-nya natural, Google memperlakukannya sama seperti link manual.



### Berapa banyak internal link baru per artikel yang aman?


Batasnya 3 link baru per artikel per jalan — angka konservatif, bukan aturan resmi Google. Artikel yang tiba-tiba dapat 10 link baru terlihat seperti dipompa. Kalau masih ada artikel yatim, jalankan lagi bulan depan; internal linking itu perawatan rutin.



### Apakah skor relevansi Gemini bisa dipercaya 100%?


Tidak. Skor itu pendapat model berdasarkan cuplikan teks — dia tidak membaca seluruh artikel. Karena itu ada ambang skor 70, batas 3 link, dan laporan JSON buat direview.



### Apakah skrip ini bisa jalan di WordPress.com, bukan self-hosted?


Bagian bacanya bisa: REST API publik tersedia di WordPress.com juga. Bagian tulis baliknya beda — Application Password adalah fitur self-hosted, sementara WordPress.com memakai OAuth2. Jalankan audit secara lokal, lalu terapkan manual.



### Kenapa tidak pakai regex saja buat menyisipkan link?


Karena regex tidak paham struktur HTML — dia bekerja di level string dan tidak tahu apakah frasa yang ditemukan ada di dalam tag <a>, atribut, blok kode, atau shortcode. BeautifulSoup bekerja di level pohon tag, jadi aturan injeksi bisa ditegakkan.



### Berapa sering audit ini perlu dijalankan?


Cukup tiap ada batch artikel baru yang signifikan, atau sebulan sekali kalau publikasimu rutin. Yang berubah adalah artikel baru — berpotensi jadi target dan sumber link.



## Penutup: peta dulu, baru suntik


Urutan kerja di artikel ini sengaja begitu: peta dulu, baru suntik. Kebanyakan orang yang gagal langsung loncat ke bagian menyuntikkan link, tanpa pernah tahu artikel mana yang yatim dan halaman pilar mana yang seharusnya menerima link terbanyak. Hasilnya, link-nya memang bertambah — tapi otoritasnya tidak mengalir ke mana-mana.


Mulai dari yang kecil: jalankan dry-run di situsmu, baca laporan JSON-nya, dan lihat berapa banyak artikel yatim yang ternyata kamu punya. Review 10 pasangan pertama dengan tanganmu sendiri — kalau 8 dari 10 terasa natural, lanjutkan; kalau cuma 4 dari 10, naikkan ambang skornya atau perbaiki shortlist-nya.


Kamu sendiri gimana — sudah pernah mengaudit internal link di situsmu, atau selama ini cuma menambahkan link dari ingatan? Ceritain di kolom komentar.



## Sumber dan bacaan lanjutan




- WordPress REST API Handbook, referensi Posts: *[https://developer.wordpress.org/rest-api/reference/posts/](https://developer.wordpress.org/rest-api/reference/posts/)* (diakses November 2026)

- WordPress REST API Handbook, Pagination: *[https://developer.wordpress.org/rest-api/using-the-rest-api/pagination/](https://developer.wordpress.org/rest-api/using-the-rest-api/pagination/)* (diakses November 2026)

- Dokumentasi Gemini API, halaman pricing: *[https://ai.google.dev/gemini-api/docs/pricing](https://ai.google.dev/gemini-api/docs/pricing)* (diakses 20 November 2026)

- Dokumentasi Gemini API, Structured outputs: *[https://ai.google.dev/gemini-api/docs/structured-output](https://ai.google.dev/gemini-api/docs/structured-output)* (diakses 20 November 2026)

- Dokumentasi BeautifulSoup 4.15.0: *[https://www.crummy.com/software/BeautifulSoup/bs4/doc/](https://www.crummy.com/software/BeautifulSoup/bs4/doc/)* (diakses 20 November 2026)

- Google Search Central, SEO Starter Guide: *[https://developers.google.com/search/docs/fundamentals/seo-starter-guide](https://developers.google.com/search/docs/fundamentals/seo-starter-guide)* (diakses November 2026)
