API मार्फत प्रकाशन कुनै पनि वेबसाइटमा।

/ सिंहावलोकन

यो कसरी काम गर्छ

Orova ले कुनै किवर्डका लागि लेख लेखिसकेपछि, तपाईंले दर्ता गरेको endpoint URL मा एउटा HTTP POST request पठाउँछ। Request body JSON हो र यसमा पूरै लेख हुन्छ। तपाईंको endpoint ले आफ्नो पक्षमा पोस्ट बनाउँछ र लेखको अन्तिम, सार्वजनिक URL सहित जवाफ दिन्छ। Orova ले त्यो URL लाई प्रकाशित लिङ्कका रूपमा सुरक्षित गर्छ, WordPress पोस्टमा जस्तै। WordPress नभएको साइटमा हात नलगाई प्रकाशन चाहनुहुन्छ, वा पोस्ट कसरी भण्डारण हुन्छ भन्ने पूरा नियन्त्रण आफैं राख्न चाहनुहुन्छ भने यसलाई प्रयोग गर्नुहोस्।

/ सेटअप

सेटअप — छ चरण

• 1

  आफ्नो परियोजनामा “API मार्फत जडान” खोल्नुहोस्. आफ्नो परियोजना खोल्नुहोस् (परियोजना → तपाईंको परियोजना → जडान)। WordPress कार्डको छेउमा API मार्फत जडान कार्ड छ। त्यहाँ आफ्नो endpoint को URL लेख्नुहोस्। गोप्य कुञ्जी फिल्ड ऐच्छिक हो: खाली छोड्नुभयो भने Orova ले एउटा बनाउँछ, वा तपाईंको साइटले पहिले नै प्रयोग गरिरहेको कुञ्जी टाँस्नुहोस्। सुरक्षित गरेपछि कुञ्जी कार्डमा प्रतिलिपि बटनसहित देखिन्छ। एउटा परियोजनाले एउटै लक्ष्यमा मात्र प्रकाशित गर्छ — API मार्फत जोड्दा WordPress बटन लक हुन्छ, र उल्टो पनि।

• 2

  POST स्वीकार गर्ने endpoint बनाउनुहोस्. आफ्नै साइट वा सर्भरमा JSON body भएको HTTP POST सुन्ने route बनाउनुहोस्। यही URL तपाईंले परियोजनाको जडान स्क्रिनमा फेरि टाँस्नुहुन्छ। Orova ले हरेक लेख सकेपछि यसलाई एक पटक कल गर्छ।

• 3

  हरेक request मा Bearer token प्रमाणित गर्नुहोस्. Orova बाट आउने हरेक request मा “Bearer <secret>” रूपको Authorization हेडर हुन्छ, जसले तपाईंको परियोजनामा देखाइएको ठ्याक्कै गोप्य कुञ्जी प्रयोग गर्छ। यसलाई आफूले राखेको प्रतिसँग तुलना गर्नुहोस् र मेल नखाने जुनसुकै कुरा अस्वीकार गर्नुहोस् — यसैले अरू कसैलाई तपाईंको साइटमा पोस्ट गर्नबाट रोक्छ।

• 4

  Payload बाट लेख बनाउनुहोस्. JSON body पढ्नुहोस् र आफ्नो CMS वा डेटाबेसमा पोस्ट बनाउनुहोस्: लेखका लागि title, slug र content_html, meta description का रूपमा excerpt, कभर तस्बिरका रूपमा featured_image_url, र metadata का रूपमा keyword / lang / published_at प्रयोग गर्नुहोस्।

• 5

  लेखको लाइभ URL फर्काउनुहोस्. HTTP 200 वा 201 र { "url": "https://yoursite.com/the-new-article" } JSON body सहित जवाफ दिनुहोस्। Orova ले त्यो URL लाई लेखको प्रकाशित लिङ्कका रूपमा राख्छ। तपाईंले non-2xx स्थिति फर्काउनुभयो, वा url फिल्ड छोड्नुभयो भने Orova ले प्रकाशन असफल मान्छ।

• 6

  Optimize इन्जिनबाट आउने अपडेट request सम्हाल्नुहोस्. Body मा action = "update" हुँदा, target_url (वा slug) बाट भइरहेको पोस्ट खोज्नुहोस् र यसको title, content_html र excerpt उही ठाउँमा अधिलेखन गर्नुहोस् — URL नबदल्नुहोस्। उही पोस्टतिर देखाउने { "url": ... } सहित 200 जवाफ दिनुहोस्। यो अझै नसम्हाल्ने endpoint हरूमा Orova ले अप्टिमाइजेसन असफल भएको रिपोर्ट मात्र गर्छ; नयाँ लेख प्रकाशन पहिलेजस्तै चलिरहन्छ।

/ सम्झौता

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 फिल्ड

प्रकाशन (नयाँ लेख) request का फिल्डहरू। मेटाउने र अपडेट request ले तलका आफ्नै खण्डमा देखाइएका साना body सहित उही endpoint पुनः प्रयोग गर्छन्।

पठाउनु केही नभएका ऐच्छिक फिल्ड body बाट पूरै हटाइन्छन् — Orova ले कहिल्यै null पठाउँदैन, त्यसैले तिनलाई सावधानीपूर्वक पढ्नुहोस्। status पनि ऐच्छिक हो: "draft" ले लेखलाई ड्राफ्टका रूपमा बनाउँछ, जबकि "publish" वा status नै नभए तुरुन्तै प्रकाशित गर्छ।

/ सम्झौता

तपाईंले फर्काउनुपर्ने response

पोस्ट बनाइसकेपछि HTTP 200 वा 201 स्थिति र यो JSON body सहित जवाफ दिनुहोस्:

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

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

Orova ले त्यो url लाई लेखको प्रकाशित लिङ्कका रूपमा राख्छ। तपाईंको endpoint ले कुनै non-2xx स्थिति, वा url फिल्ड भएको JSON object नभएको body फर्काए, Orova ले प्रकाशन असफल मान्छ र लेखलाई सोहीअनुसार चिन्ह लगाउँछ ताकि तपाईं फेरि प्रयास गर्न सक्नुहोस्। 60 सेकेन्ड भित्र जवाफ दिनुहोस् — त्यसपछि Orova ले request टाइमआउट गर्छ (यो प्रकाशन, अपडेट र मेटाउने सबैमा लागू हुन्छ)।

/ उदाहरण

कोड उदाहरण

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);

/ सम्झौता — अपडेट

लेख अपडेट (Optimize)

Orova को Optimize इन्जिन ले पहिले नै लाइभ भइसकेका लेख पुनर्लेखन गर्छ — ताजा तथ्य, राम्रो शीर्षक, गाभिएको सामग्री — त्यसपछि भइरहेको पोस्टलाई उही ठाउँमा, 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 जवाफ दिनुहोस्। कुनै non-2xx स्थिति, वा url नभएको body ले Orova लाई त्यो अप्टिमाइजेसन असफल भनी चिन्ह लगाउन लगाउँछ (यसले कहिल्यै दोहोरो पोस्ट बनाउँदैन)। यो अझै लागू नगरेका endpoint ले नयाँ लेख पहिलेजस्तै प्रकाशित गरिरहन्छन् — Optimize स्क्रिन प्रयोग गर्दा मात्र update लागू गर्नुपर्छ।

29 अगस्टदेखि update body मा id (target_url भन्दा पहिले यसैमा मिलाउनुहोस्), नयाँ कभर तस्बिरका लागि featured_image_url, र "publish" वा "draft" भएको status पनि हुन सक्छ। तीनै ऐच्छिक हुन्; खाली हुँदा body बाट हटाइन्छन्, कहिल्यै null का रूपमा पठाइँदैनन्।

/ सम्झौता — Visual Editor

लेख पढ्ने (अनिवार्य)

Orova ले तपाईंको साइटमा पहिले नै भएका लेख पढ्नुपर्छ — दोहोरिने विषयबाट बच्न, आन्तरिक लिङ्क थप्न र पुराना पोस्ट अप्टिमाइज गर्न। उही 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 ले कुन लेख पहिले नै छन् जान्न (दोहोरो रोक्न, आन्तरिक लिङ्क थप्न र पूरै साइट विश्लेषण गर्न) list कल गर्छ र अप्टिमाइज गर्दा लेख पढ्न get कल गर्छ। तपाईंको साइटले यी दुई action को जवाफ दिएन भने नयाँ लेखमा आन्तरिक लिङ्क हुँदैन र पुराना लेख अप्टिमाइज गर्न सकिँदैन।

/ सम्झौता — Visual Editor

तस्बिर अपलोड (Visual Editor)

तपाईंले Visual Editor मा तस्बिर राख्दा Orova ले त्यसलाई JSON body भित्र base64 का रूपमा उही endpoint URL मा पठाउँछ — 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), हटाउनुहोस् वा अप्रकाशित गर्नुहोस्, त्यसपछि 200 र { "deleted": true } सहित जवाफ दिनुहोस् — खाली 204 पनि चल्छ। पोस्ट अब छैन भने 404 जवाफ दिनुहोस्, Orova ले यसलाई पहिले नै मेटिएको मान्छ। { "deleted": false } फर्काउनुले Orova लाई पोस्ट हटाइएन भनी बताउँछ। सामान्य प्रकाशन request मा कहिल्यै action फिल्ड हुँदैन, त्यसैले भइरहेका endpoint जस्ताको तस्तै चलिरहन्छन् — delete लागू गर्नु ऐच्छिक हो तर सिफारिस गरिन्छ।

/ सुरक्षा

सुरक्षा टिप्पणी

• सधैं Bearer token प्रमाणित गर्नुहोस्. तपाईंको endpoint सार्वजनिक URL हो — जोसुकैले यसलाई कल गर्न सक्छ। Request साँच्चै Orova बाट आएको प्रमाणित गर्ने एक मात्र कुरा Authorization हेडर हो, त्यसैले token तपाईंले राखेको गोप्य कुञ्जीसँग ठ्याक्कै मेल नखाने हरेक request अस्वीकार गर्नुहोस्।
• Endpoint लाई HTTPS मार्फत चलाउनुहोस्. गोप्य कुञ्जी हेडरमा जान्छ। HTTPS ले यसलाई बाटोमा पढिनबाट जोगाउँछ।
• गोप्य कुञ्जीलाई कोडबाहिर राख्नुहोस्. यसलाई environment variable वा secrets manager मा राख्नुहोस्, commit गर्ने फाइलमा कहिल्यै hard-code नगर्नुहोस्। कहिल्यै खुलासा भयो भने परियोजना → जडानबाट नयाँ बनाउनुहोस्।
• content_html लाई भरपर्दो markup होइन, सामग्रीका रूपमा लिनुहोस्. आफ्नो CMS मा कुनै पनि लेखको body जस्तै सावधानीपूर्वक भण्डारण र प्रदर्शन गर्नुहोस्।

/ समापन

पूरा सम्झौता यत्ति हो

Endpoint लाइभ भई तपाईंको परियोजनामा दर्ता भएपछि, Orova ले तपाईंको साइटमा स्वतः प्रकाशित गर्छ — WordPress प्रयोगकर्ताका लागि जस्तै। यसले सकेको हरेक लेख तपाईंको सर्भरमा पुग्छ, पोस्ट बन्छ, र यसको सार्वजनिक URL रिपोर्ट र विश्लेषणमा फर्किन्छ ताकि तपाईं यसको प्रदर्शन ट्र्याक गर्न सक्नुहोस्।