API မှတစ်ဆင့် ပို့စ်တင်ခြင်း မည်သည့်ဝက်ဘ်ဆိုက်ပေါ်သို့မဆို။

/ ခြုံငုံသုံးသပ်ချက်

အလုပ်လုပ်ပုံ

keyword တစ်ခုအတွက် ဆောင်းပါးရေးပြီးသည့်အခါ Orova က သင်မှတ်ပုံတင်ထားသော endpoint URL သို့ HTTP POST request တစ်ခုတည်း ပို့သည်။ request body သည် JSON ဖြစ်ပြီး ဆောင်းပါးတစ်ပုဒ်လုံး ပါဝင်သည်။ သင့် endpoint က သင့်ဘက်တွင် ပို့စ်ဖန်တီးပြီး ဆောင်းပါး၏ နောက်ဆုံး အများမြင် URL ကို ပြန်ပေးသည်။ Orova က ထို URL ကို WordPress ပို့စ်ကဲ့သို့ပင် တင်ပြီးသော link အဖြစ် သိမ်းသည်။ WordPress မဟုတ်သော ဝက်ဘ်ဆိုက်တွင် အလိုအလျောက် တင်လိုသည့်အခါ သို့မဟုတ် ပို့စ်သိမ်းပုံကို ကိုယ်တိုင် ထိန်းချုပ်လိုသည့်အခါ ဤနည်းကို သုံးပါ။

/ သတ်မှတ်ခြင်း

သတ်မှတ်ခြင်း — အဆင့် ခြောက်ဆင့်

• 1

  project ထဲတွင် “API မှတစ်ဆင့် ချိတ်ဆက်ရန်” ကို ဖွင့်ပါ. သင့် project ကို ဖွင့်ပါ (Project များ → သင့် project → ချိတ်ဆက်မှုများ)။ WordPress ကတ်ဘေးတွင် API မှတစ်ဆင့် ချိတ်ဆက်ရန် ကတ် ရှိသည်။ ထိုနေရာတွင် သင့် endpoint URL ကို ထည့်ပါ။ secret key အကွက်သည် ရွေးချယ်နိုင်သည်- ဗလာထားလျှင် Orova က key တစ်ခု ထုတ်ပေးမည်၊ သို့မဟုတ် သင့်ဆိုက်က သုံးနေသော key ကို ကူးထည့်ပါ။ သိမ်းပြီးသည်နှင့် key ကို ကတ်ပေါ်တွင် Copy ခလုတ်နှင့်အတူ ပြမည်။ project တစ်ခုသည် နေရာတစ်ခုသို့သာ တင်သည် — API မှတစ်ဆင့် ချိတ်လျှင် WordPress ခလုတ် ပိတ်သွားမည်ဖြစ်ပြီး ပြောင်းပြန်လည်း ထိုနည်းတူ။

• 2

  POST လက်ခံသော endpoint တည်ဆောက်ပါ. သင့်ဝက်ဘ်ဆိုက် သို့မဟုတ် ဆာဗာပေါ်တွင် JSON body ပါ HTTP POST ကို နားထောင်သော route တစ်ခု ဖန်တီးပါ။ ဤသည်မှာ project ၏ ချိတ်ဆက်မှု စခရင်တွင် ပြန်ကူးထည့်ရမည့် URL ဖြစ်သည်။ ဆောင်းပါးတစ်ပုဒ် ရေးပြီးတိုင်း Orova က ၎င်းကို တစ်ကြိမ်တိတိ ခေါ်သည်။

• 3

  request တိုင်းတွင် Bearer token ကို စစ်ဆေးပါ. Orova မှ request တိုင်းတွင် “Bearer <secret>” ပုံစံ Authorization header ပါပြီး project တွင်ပြထားသော secret key အတိအကျကို သုံးသည်။ သင်သိမ်းထားသော မိတ္တူနှင့် တိုက်စစ်ပြီး မကိုက်ညီသော request အားလုံးကို ပယ်ပါ — ဤအချက်တစ်ခုတည်းကသာ အခြားသူများ သင့်ဆိုက်သို့ ပို့စ်တင်ခြင်းကို တားဆီးသည်။

• 4

  payload မှ ဆောင်းပါး ဖန်တီးပါ. JSON body ကို ဖတ်ပြီး သင့် CMS သို့မဟုတ် database တွင် ပို့စ်ဖန်တီးပါ- ဆောင်းပါးအတွက် title၊ slug နှင့် content_html ကို သုံးပါ၊ excerpt ကို meta description အဖြစ်၊ featured_image_url ကို မျက်နှာဖုံးပုံအဖြစ်၊ keyword / lang / published_at ကို metadata အဖြစ် သုံးပါ။

• 5

  ဆောင်းပါး၏ အစစ်အမှန် URL ကို ပြန်ပေးပါ. HTTP 200 သို့မဟုတ် 201 နှင့် { "url": "https://yoursite.com/the-new-article" } JSON body ကို ပြန်ပေးပါ။ Orova က ထို URL ကို ဆောင်းပါး၏ တင်ပြီးသော link အဖြစ် သိမ်းသည်။ 2xx မဟုတ်သော ကုဒ် ပြန်ပေးလျှင် သို့မဟုတ် url field မပါလျှင် Orova က တင်ခြင်း မအောင်မြင်ဟု သတ်မှတ်သည်။

• 6

  Optimize engine မှ update request များကို ကိုင်တွယ်ပါ. body တွင် action = "update" ပါလျှင် target_url (သို့မဟုတ် slug) ဖြင့် ရှိပြီးသား ပို့စ်ကို ရှာပြီး title၊ content_html နှင့် excerpt ကို နေရာတွင်ပင် ထပ်ရေးပါ — URL မပြောင်းပါနှင့်။ ထိုပို့စ်ကိုယ်တိုင်ကို ညွှန်သော { "url": ... } နှင့် 200 ပြန်ပေးပါ။ ဤအပိုင်းကို မကိုင်တွယ်ရသေးသော endpoint များသည် Orova ကို optimize လုပ်ခြင်း မအောင်မြင်ဟု အစီရင်ခံစေရုံသာ; ဆောင်းပါးအသစ်တင်ခြင်းမှာ ယခင်အတိုင်း အလုပ်လုပ်သည်။

/ စာချုပ်

Orova ပို့သော request

ရေးပြီးသော ဆောင်းပါးတစ်ပုဒ်စီသည် ဤပုံစံ request တစ်ခုအဖြစ် ရောက်လာသည်-

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>     # the secret key shown in Project -> Connections
  User-Agent: Orova-SEO

Body (JSON):
  {
    "title": "...",                  # article headline
    "slug": "...",                   # URL-friendly identifier
    "content_html": "...",           # full article HTML
    "excerpt": "...",                # meta description
    "featured_image_url": "..." | null,
    "keyword": "...",                # target keyword
    "lang": "en",                    # ISO language code
    "published_at": "2026-05-17T09:00:00.482913",  # ISO 8601, UTC, no offset suffix
    "status": "draft"                # optional: "draft" keeps it unpublished
  }
  # Optional fields are left out of the body when empty — never sent as null.

/ ကိုးကားချက်

Payload field များ

ဆောင်းပါးအသစ်တင်သော request ၏ field များ။ ဖျက်ခြင်းနှင့် update request များသည် ဤ endpoint တူကိုပင် သုံးပြီး body ပိုသေးသည် — အောက်ပါ ၎င်းတို့၏ ကိုယ်ပိုင်အပိုင်းတွင် ကြည့်ပါ။

ရွေးချယ်နိုင်သော field တွင် ပို့စရာမရှိလျှင် Orova က ထို key ကို လုံးဝဖယ်ထားပြီး null မပို့ပါ — ရွေးချယ်နိုင်သော field အားလုံးကို ကာကွယ်သည့်ပုံစံဖြင့် ဖတ်ပါ။ status လည်း ရွေးချယ်နိုင်သည်- "draft" က ဆောင်းပါးကို မူကြမ်းအဖြစ် ဖန်တီးပြီး "publish" သို့မဟုတ် status မပါလျှင် ချက်ချင်း တင်သည်။

/ စာချုပ်

သင် ပြန်ပေးရမည့် response

ပို့စ်ဖန်တီးပြီးသည်နှင့် HTTP 200 သို့မဟုတ် 201 status နှင့် ဤ JSON body ကို ပြန်ပေးပါ-

HTTP 200 (or 201)
Content-Type: application/json

{
  "url": "https://yoursite.com/published-article"
}

Orova က ထို url ကို ဆောင်းပါး၏ တင်ပြီးသော link အဖြစ် သိမ်းသည်။ သင့် endpoint က 2xx မဟုတ်သော status ပြန်ပေးလျှင် သို့မဟုတ် body သည် url field ပါသော JSON object မဟုတ်လျှင် Orova က တင်ခြင်း မအောင်မြင်ဟု သတ်မှတ်ပြီး ပြန်လုပ်နိုင်ရန် ဆောင်းပါးကို မှတ်သားထားမည်။ 60 စက္ကန့် အတွင်း တုံ့ပြန်ပါ — ကျော်လျှင် Orova က request ကို ဖြတ်မည် (တင်ခြင်း၊ update နှင့် ဖျက်ခြင်း အားလုံးတွင် သက်ရောက်သည်)။

/ ဥပမာ

နမူနာကုဒ်

Node.js နှင့် Express ဖြင့် ရေးထားသော အရိုးရှင်းဆုံး လက်ခံ endpoint။ token စစ်ခြင်း၊ action (update / delete) အလိုက် ခွဲခြင်း၊ ပို့စ် ဖန်တီး သို့မဟုတ် ပြင်ခြင်း၊ URL ပြန်ပေးခြင်း ဟူသော အဆင့်များသည် မည်သည့် ဘာသာစကား သို့မဟုတ် framework တွင်မဆို အတူတူပင်။

// Node.js / Express — a minimal receiving endpoint
import express from "express";

const app = express();
app.use(express.json({ limit: "5mb" }));

// The secret Orova generated for this project.
const OROVA_SECRET = process.env.OROVA_SECRET;

app.post("/orova/publish", async (req, res) => {
  // 1. Verify the Bearer token.
  const auth = req.get("authorization") || "";
  if (auth !== "Bearer " + OROVA_SECRET) {
    return res.status(401).json({ error: "unauthorized" });
  }

  // 2. Required: list your articles (duplicate check, internal links). action = "list".
  if (req.body.action === "list") {
    const posts = await listPosts(req.body.limit || 500); // newest first, 500 max
    // each post: { id, title, slug, link, date, modified, status, author, excerpt? }
    return res.status(200).json({ ok: true, posts });
  }

  // 3. Required: read one article in full (used when optimizing it). action = "get".
  if (req.body.action === "get") {
    const post = await findPost(req.body.id, req.body.target_url, req.body.slug);
    if (!post) return res.status(404).json({ ok: false, err: "not_found" });
    return res.status(200).json({ ok: true, post });
  }

  // 4. Visual Editor: store an image, answer with its absolute URL.
  if (req.body.action === "upload_image") {
    const { filename, mime, data_base64 } = req.body;
    if (!String(mime || "").startsWith("image/")) {
      return res.status(422).json({ error: "image files only" });
    }
    const bytes = Buffer.from(data_base64, "base64");
    if (bytes.length > 15 * 1024 * 1024) {
      return res.status(413).json({ error: "image too large" });
    }
    return res.status(200).json({ ok: true, url: await saveImage(filename, bytes) });
  }

  // 5. Delete requests: body carries action = "delete".
  if (req.body.action === "delete") {
    const removed = await deletePostByUrl(req.body.url, req.body.slug);
    if (!removed) return res.status(404).json({ deleted: true }); // already gone
    return res.status(200).json({ deleted: true });
  }

  // 6. Update requests: action = "update". Optional fields may be absent.
  if (req.body.action === "update") {
    const updated = await updatePost(req.body.id, req.body.target_url, {
      title: req.body.title,
      html: req.body.content_html,
      metaDescription: req.body.excerpt,
      coverImage: req.body.featured_image_url,  // optional
      status: req.body.status,                  // optional: "publish" | "draft"
    });
    if (!updated) return res.status(404).json({ error: "post not found" });
    return res.status(200).json({ url: updated.url });
  }

  // 7. New article: read the payload Orova sent.
  const {
    title, slug, content_html, excerpt,
    featured_image_url, keyword, lang, published_at, status,
  } = req.body;

  // 8. Create the article in your own CMS or database.
  const post = await createPost({
    title,
    slug,
    html: content_html,
    metaDescription: excerpt,
    coverImage: featured_image_url,
    keyword,
    lang,
    publishedAt: published_at,
    draft: status === "draft",   // status is optional; absent means publish now
  });

  // 9. Return 200/201 with the live URL.
  return res.status(201).json({
    url: "https://yoursite.com/" + post.slug,
  });
});

app.listen(3000);

/ စာချုပ် — update

ဆောင်းပါး update လုပ်ခြင်း (Optimize)

Orova ၏ Optimize engine သည် တင်ပြီးသား ဆောင်းပါးများကို ပြန်ရေးသည် — အချက်အလက် update၊ ခေါင်းစဉ်ပြင်ခြင်း၊ အကြောင်းအရာ ပေါင်းခြင်း — ထို့နောက် ရှိပြီးသား ပို့စ်ကို နေရာတွင်ပင်၊ URL မပြောင်းဘဲ ထပ်ရေးသည်။ request သည် endpoint URL တူတူ သို့ ရောက်ပြီး Bearer token တူဖြင့် POST ဖြစ်သည်-

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>
  User-Agent: Orova-SEO

Body (JSON):
  {
    "action": "update",          # always the literal string "update"
    "id": 123,                   # optional: post id, match on this first
    "target_url": "...",         # public URL of the post to overwrite (match next)
    "title": "...",              # new headline
    "slug": "...",               # slug fallback for matching, may be empty
    "content_html": "...",       # full new article body as HTML
    "excerpt": "...",            # new meta description
    "featured_image_url": "...", # optional: new cover image
    "status": "publish"          # optional: "publish" or "draft"
  }
  # Optional fields are left out of the body when empty — never sent as null.

target_url ဖြင့် ပို့စ်ကို ရှာပါ (မတွေ့လျှင် slug ဖြင့်)၊ ခေါင်းစဉ်၊ body နှင့် meta description ကို အစားထိုးပါ၊ URL ကို မူလအတိုင်းထားပြီး { "url": "<same post URL>" } နှင့် 200 ပြန်ပေးပါ။ 2xx မဟုတ်သော status သို့မဟုတ် url မပါသော body သည် Orova ကို optimize လုပ်ခြင်း မအောင်မြင်ဟု မှတ်သားစေသည် (Orova သည် ထပ်နေသော ပို့စ်ကို ဘယ်တော့မှ မဖန်တီးပါ)။ ဤအပိုင်းကို မလုပ်ရသေးသော endpoint များသည် ဆောင်းပါးအသစ်ကို ပုံမှန်တင်နေဆဲ — Optimize စခရင်ကို သုံးမှသာ ထပ်ဖြည့်ရန် လိုသည်။

29/8 မှစ၍ update body တွင် id (target_url မတိုင်မီ id ဖြင့် အရင်ရှာ)၊ မျက်နှာဖုံးပုံအသစ်အတွက် featured_image_url နှင့် "publish" သို့မဟုတ် "draft" ယူသော status တို့လည်း ပါနိုင်သည်။ သုံးခုလုံး ရွေးချယ်နိုင်သည်; တန်ဖိုးမရှိလျှင် Orova က key ကို လုံးဝဖယ်ပြီး null မပို့ပါ။

/ စာချုပ် — Visual Editor

ဆောင်းပါးဖတ်ခြင်း (မဖြစ်မနေ)

Orova သည် သင့်ဝက်ဘ်ဆိုက်ပေါ်ရှိ ဆောင်းပါးများကို ဖတ်နိုင်ရန် လိုသည် — ခေါင်းစဉ်ထပ်ခြင်း ရှောင်ရန်၊ အတွင်းပိုင်း link ထည့်ရန်နှင့် ဆောင်းပါးဟောင်းများ optimize လုပ်ရန်။ endpoint URL တူတူ ပေါ်တွင် Bearer token တူဖြင့် action နှစ်ခု ထပ်ထည့်ပါ- list က ဆောင်းပါးစာရင်း ပြန်ပေးပြီး get က ဆောင်းပါးတစ်ပုဒ်ကို အပြည့်အစုံ ပြန်ပေးသည်။

POST <your endpoint URL>     # same endpoint, same Bearer secret

Body (JSON):
  {
    "action": "list",            # always the literal string "list"
    "limit": 500                 # newest article first, 500 maximum
  }

Response — HTTP 200:
  {
    "ok": true,
    "posts": [
      {
        "id": 123,               # your own post id, reused by "get" and "update"
        "title": "...",
        "slug": "...",
        "link": "https://yoursite.com/the-article",
        "date": "2026-08-29",    # published date, YYYY-MM-DD
        "modified": "2026-08-29",
        "status": "publish",     # "publish" or "draft"
        "author": "...",
        "excerpt": "..."         # optional: short summary, 300 characters max
      }
    ]
  }
  # Required: Orova reads this list to avoid duplicate topics,
  # add internal links and analyze the whole site.

POST <your endpoint URL>

Body (JSON):
  {
    "action": "get",             # always the literal string "get"
    "id": 123,                   # match on this first
    "target_url": "...",         # then the public URL
    "slug": "..."                # then the slug
  }

Response — HTTP 200:
  {
    "ok": true,
    "post": {
      "id": 123,
      "title": "...",
      "slug": "...",
      "link": "https://yoursite.com/the-article",
      "content_html": "...",     # full article body as HTML
      "excerpt": "...",
      "featured_image_url": "...",
      "status": "publish"        # "publish" or "draft"
    }
  }

No such post — HTTP 404:
  { "ok": false, "err": "not_found" }

limit အများဆုံး 500 ဖြစ်ပြီး နောက်ဆုံးဆောင်းပါး ထိပ်ဆုံးတွင် ရှိသည်။ get အတွက် Orova က id၊ target_url နှင့် slug ကို တစ်ပြိုင်နက် ပို့သည် — သင်မှတ်မိသည့်အရာဖြင့် ထိုအစီအစဉ်အတိုင်း ရှာပါ။ မတွေ့လျှင် { "ok": false, "err": "not_found" } နှင့် 404 ပြန်ပေးပါ။ list ရှိ excerpt သည် ရွေးချယ်နိုင်သည် (အများဆုံး စာလုံး 300)။ မဖြစ်မနေ- Orova သည် ရှိပြီးသား ဆောင်းပါးများကို သိရန် (ထပ်ရေးခြင်းရှောင်ရန်၊ အတွင်းပိုင်း link ထည့်ရန်၊ ဆိုက်တစ်ခုလုံး ခွဲခြမ်းစိတ်ဖြာရန်) list ကို ခေါ်ပြီး ဆောင်းပါး optimize လုပ်ချိန်တွင် အကြောင်းအရာဖတ်ရန် get ကို ခေါ်သည်။ ဝက်ဘ်ဆိုက်က ဤ action နှစ်ခုကို မတုံ့ပြန်လျှင် ဆောင်းပါးအသစ်တွင် အတွင်းပိုင်း link မပါဘဲ ဆောင်းပါးဟောင်းများကို optimize မလုပ်နိုင်ပါ။

/ စာချုပ် — Visual Editor

ပုံတင်ခြင်း (Visual Editor)

Visual Editor ထဲသို့ ပုံတစ်ပုံ ချလိုက်သည့်အခါ Orova က ၎င်းကို endpoint URL တူတူ သို့ JSON body အတွင်း base64 အဖြစ် ပို့သည် — multipart မရှိ၊ ကာကွယ်ရမည့် ဒုတိယ URL မရှိ။

POST <your endpoint URL>

Body (JSON):
  {
    "action": "upload_image",    # always the literal string "upload_image"
    "filename": "cover.png",     # original file name, extension included
    "mime": "image/png",         # image/* only
    "data_base64": "iVBORw0KGgo..."   # file bytes, base64, 15 MB maximum
  }

Response — HTTP 200 (or 201):
  {
    "ok": true,
    "url": "https://yoursite.com/uploads/cover.png"   # absolute URL
  }

image/* ကိုသာ လက်ခံပြီး 15 MB ကျော်သော ဖိုင်ကို ပယ်ပါ။ ဖိုင်သိမ်းပြီးလျှင် ပုံ၏ absolute URL ကို ပြန်ပေးပါ- relative path သည် ဆောင်းပါးကို အခြားနေရာတွင် ပြသည်နှင့် ပျက်သွားမည်။ ဤ action ကို Visual Editor အတွက်သာ လိုသည်။

/ စာချုပ် — ဖျက်ခြင်း

ဆောင်းပါးဖျက်ခြင်း

အသုံးပြုသူက Orova ထဲမှ (ဆောင်းပါးရေး သို့မဟုတ် အစီရင်ခံစာ စခရင်မှ) တင်ပြီးသော ဆောင်းပါးကို ဖယ်ရှားသည့်အခါ Orova က သင့်ဆိုက်ကိုလည်း ထိုဆောင်းပါးကို ဖျက်ရန် တောင်းဆိုသည်။ request သည် endpoint URL တူတူ သို့ ရောက်ပြီး Bearer token တူဖြင့် POST ဖြစ်သည် — body သာ ကွဲပြားသည်-

POST <your endpoint URL>

Headers:
  Content-Type: application/json
  Authorization: Bearer <secret>
  User-Agent: Orova-SEO

Body (JSON):
  {
    "action": "delete",          # always the literal string "delete"
    "url": "...",                # public URL of the article to remove (match on this first)
    "slug": "...",               # slug fallback, may be empty
    "keyword": "..."             # the article's target keyword, for your logs
  }

url ဖြင့် ပို့စ်ကို ရှာပါ (မတွေ့လျှင် slug ဖြင့်)၊ ဖျက် သို့မဟုတ် တင်ခြင်းကို ပြန်ရုပ်သိမ်းပြီး { "deleted": true } နှင့် 200 ပြန်ပေးပါ — body ဗလာ 204 လည်း ရသည်။ ပို့စ် မရှိတော့လျှင် 404 ပြန်ပေးပါ၊ Orova က ဖျက်ပြီးသားဟု နားလည်မည်။ { "deleted": false } ပြန်ပေးခြင်းသည် ပို့စ်ကို မဖယ်ရှားရသေးကြောင်း Orova ကို အသိပေးခြင်းဖြစ်သည်။ ပုံမှန် တင်ခြင်း request တွင် action field ဘယ်တော့မှ မပါသဖြင့် ရှိပြီးသား endpoint များ ဆက်အလုပ်လုပ်မည် — ဖျက်ခြင်းအပိုင်း လုပ်ရန်မှာ ရွေးချယ်နိုင်သော်လည်း လုပ်သင့်သည်။

/ လုံခြုံရေး

လုံခြုံရေး မှတ်ချက်များ

• Bearer token ကို အမြဲစစ်ဆေးပါ. သင့် endpoint သည် အများမြင် URL ဖြစ်သည် — မည်သူမဆို ခေါ်နိုင်သည်။ Authorization header သည် request က Orova မှ အမှန်တကယ် လာကြောင်း သက်သေပြသော တစ်ခုတည်းသော အရာဖြစ်သဖြင့် သင်သိမ်းထားသော secret နှင့် token အတိအကျ မကိုက်ညီသော request အားလုံးကို ပယ်ပါ။
• endpoint ကို HTTPS ပေါ်တွင် run ပါ. secret သည် header ထဲတွင် သွားသည်။ HTTPS က လမ်းခရီးတွင် ၎င်းကို မဖတ်နိုင်အောင် ကာကွယ်သည်။
• secret ကို ကုဒ်ထဲတွင် မထားပါနှင့်. ကီးကို environment variable သို့မဟုတ် secrets manager တွင် သိမ်းပါ၊ commit လုပ်မည့် ဖိုင်ထဲ တိုက်ရိုက် မရေးပါနှင့်။ ပေါက်ကြားသွားပါက ပရောဂျက် → ချိတ်ဆက်မှုများ မှ ကီးအသစ် ထုတ်ပါ။
• content_html ကို ယုံကြည်ရသော markup အဖြစ် မဟုတ်ဘဲ အကြောင်းအရာအဖြစ် သဘောထားပါ. သင့် CMS ရှိ အခြား ဆောင်းပါး ကိုယ်ထည်များကဲ့သို့ပင် ဂရုတစိုက် သိမ်းဆည်းပြီး ပြသပါ။

/ နိဂုံးချုပ်

သဘောတူညီချက် အားလုံးမှာ ဒါပါပဲ

endpoint အလုပ်လုပ်ပြီး သင့်ပရောဂျက်တွင် စာရင်းသွင်းပြီးသည်နှင့် Orova သည် သင့် website သို့ အလိုအလျောက် ထုတ်ဝေပေးသည် — WordPress အသုံးပြုသူများအတွက် လုပ်သကဲ့သို့ပင်။ ရေးပြီးသော ဆောင်းပါးတိုင်း သင့်ဆာဗာသို့ ရောက်ရှိကာ post တစ်ခု ဖြစ်လာပြီး ၎င်း၏ အများသုံး URL သည် အစီရင်ခံစာ နှင့် ခွဲခြမ်းစိတ်ဖြာမှု ထဲသို့ ပြန်ဝင်လာသဖြင့် စွမ်းဆောင်ရည်ကို ခြေရာခံနိုင်သည်။