API ద్వారా ప్రచురణ ఏ వెబ్‌సైట్‌లోనైనా.

/ అవలోకనం

ఇది ఎలా పని చేస్తుంది

Orova ఒక కీవర్డ్ కోసం ఆర్టికల్ రాయడం పూర్తి చేసినప్పుడు, మీరు నమోదు చేసిన endpoint URLకు ఒకే HTTP POST అభ్యర్థనను పంపుతుంది. అభ్యర్థన body JSON మరియు మొత్తం ఆర్టికల్‌ను కలిగి ఉంటుంది. మీ endpoint మీ వైపు పోస్ట్‌ను సృష్టించి, ఆర్టికల్ యొక్క తుది, పబ్లిక్ URLతో ప్రతిస్పందిస్తుంది. Orova ఆ URLను ప్రచురించిన లింక్‌గా సేవ్ చేస్తుంది, WordPress పోస్ట్‌కు చేసినట్లే. WordPress కాని సైట్‌లో చేతి ప్రమేయం లేకుండా ప్రచురించాలనుకున్నప్పుడు, లేదా పోస్ట్‌లు ఎలా నిల్వ చేయబడతాయో పూర్తి నియంత్రణ ఉంచుకోవాలనుకున్నప్పుడు దీన్ని ఉపయోగించండి.

/ సెటప్

సెటప్ — ఆరు దశలు

• 1

  మీ ప్రాజెక్ట్‌లో “Connect via API”ని ఆన్ చేయండి. మీ ప్రాజెక్ట్‌ను తెరవండి (Projects → మీ ప్రాజెక్ట్ → Connections). WordPress కార్డ్ పక్కన Connect via API కార్డ్ ఉంది. అక్కడ మీ endpoint URLను నమోదు చేయండి. సీక్రెట్ కీ ఫీల్డ్ ఐచ్ఛికం: ఖాళీగా వదిలితే Orova ఒకటి రూపొందిస్తుంది, లేదా మీ సైట్ ఇప్పటికే ఉపయోగిస్తున్న కీని పేస్ట్ చేయండి. సేవ్ చేసిన తర్వాత, కీ Copy బటన్‌తో కార్డ్‌పై చూపబడుతుంది. ఒక ప్రాజెక్ట్ ఒకే లక్ష్యానికి మాత్రమే ప్రచురిస్తుంది — API ద్వారా కనెక్ట్ చేస్తే WordPress బటన్ లాక్ అవుతుంది, వ్యతిరేకంగా కూడా.

• 2

  POST స్వీకరించే endpointను నిర్మించండి. మీ స్వంత సైట్ లేదా సర్వర్‌లో, JSON bodyతో HTTP POST కోసం వినే routeను సృష్టించండి. ఇది ప్రాజెక్ట్ Connections స్క్రీన్‌లో మీరు తిరిగి పేస్ట్ చేసే URL. Orova పూర్తి చేసే ప్రతి ఆర్టికల్‌కు దాన్ని ఒకసారి కాల్ చేస్తుంది.

• 3

  ప్రతి అభ్యర్థనపై Bearer tokenను ధృవీకరించండి. Orova నుండి ప్రతి అభ్యర్థన “Bearer <secret>” రూపంలో Authorization హెడర్‌ను కలిగి ఉంటుంది, మీ ప్రాజెక్ట్‌లో చూపిన ఖచ్చితమైన సీక్రెట్ కీని ఉపయోగిస్తూ. దాన్ని మీరు నిల్వ చేసిన కాపీతో పోల్చి, సరిపోలని దేనినైనా తిరస్కరించండి — ఇదే మీ సైట్‌కు మరెవరూ పోస్ట్ చేయకుండా ఆపుతుంది.

• 4

  Payload నుండి ఆర్టికల్‌ను సృష్టించండి. JSON bodyని చదివి మీ CMS లేదా డేటాబేస్‌లో పోస్ట్‌ను సృష్టించండి: ఆర్టికల్ కోసం title, slug మరియు content_html, meta descriptionగా excerpt, కవర్ చిత్రంగా featured_image_url, మరియు మెటాడేటాగా keyword / lang / published_at ఉపయోగించండి.

• 5

  ఆర్టికల్ యొక్క లైవ్ URLను తిరిగి ఇవ్వండి. HTTP 200 లేదా 201 మరియు { "url": "https://yoursite.com/the-new-article" } JSON bodyతో ప్రతిస్పందించండి. Orova ఆ URLను ఆర్టికల్ ప్రచురించిన లింక్‌గా నిల్వ చేస్తుంది. మీరు 2xx కాని స్థితిని తిరిగి ఇస్తే, లేదా url ఫీల్డ్‌ను వదిలేస్తే, Orova ప్రచురణ విఫలమైనట్లు పరిగణిస్తుంది.

• 6

  Optimize ఇంజిన్ నుండి అప్‌డేట్ అభ్యర్థనలను నిర్వహించండి. body action = "update" కలిగి ఉన్నప్పుడు, target_url (లేదా slug) ద్వారా ఉన్న పోస్ట్‌ను కనుగొని దాని title, content_html మరియు excerptను అక్కడే ఓవర్‌రైట్ చేయండి — URLను మార్చకుండా ఉంచండి. అదే పోస్ట్‌కు సూచించే { "url": ... }తో 200 ప్రతిస్పందించండి. దీన్ని ఇంకా నిర్వహించని endpointలు Orova ఆప్టిమైజేషన్ విఫలమైనట్లు నివేదించేలా చేస్తాయి; కొత్త ఆర్టికల్ ప్రచురణ మునుపటిలాగే పని చేస్తుంది.

/ ఒప్పందం

Orova పంపే అభ్యర్థన

ప్రతి పూర్తయిన ఆర్టికల్ ఇలా రూపొందించిన ఒక అభ్యర్థనగా వస్తుంది:

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 ఫీల్డ్‌లు

ప్రచురణ (కొత్త ఆర్టికల్) అభ్యర్థన యొక్క ఫీల్డ్‌లు. తొలగింపు మరియు అప్‌డేట్ అభ్యర్థనలు అదే endpointను దిగువ వాటి స్వంత విభాగాలలో చూపిన చిన్న bodyలతో తిరిగి ఉపయోగిస్తాయి.

పంపడానికి ఏమీ లేనప్పుడు ఐచ్ఛిక ఫీల్డ్‌లు body నుండి పూర్తిగా వదిలివేయబడతాయి — Orova ఎప్పుడూ null పంపదు, కాబట్టి వాటిని జాగ్రత్తగా చదవండి. status కూడా ఐచ్ఛికం: "draft" ఆర్టికల్‌ను డ్రాఫ్ట్‌గా సృష్టిస్తుంది, అయితే "publish" లేదా status లేకపోతే వెంటనే ప్రచురిస్తుంది.

/ ఒప్పందం

మీరు తిరిగి ఇవ్వాల్సిన ప్రతిస్పందన

మీరు పోస్ట్‌ను సృష్టించిన తర్వాత, HTTP 200 లేదా 201 స్థితి మరియు ఈ JSON bodyతో ప్రత్యుత్తరం ఇవ్వండి:

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

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

Orova ఆ urlను ఆర్టికల్ ప్రచురించిన లింక్‌గా నిల్వ చేస్తుంది. మీ endpoint ఏదైనా 2xx కాని స్థితిని, లేదా url ఫీల్డ్ ఉన్న JSON object కాని bodyని తిరిగి ఇస్తే, Orova ప్రచురణ విఫలమైనట్లు పరిగణించి, మీరు మళ్లీ ప్రయత్నించగలిగేలా ఆర్టికల్‌ను తదనుగుణంగా గుర్తిస్తుంది. 60 సెకన్లు లోపు ప్రత్యుత్తరం ఇవ్వండి — ఆ తర్వాత Orova అభ్యర్థనను టైమ్ అవుట్ చేస్తుంది (ఇది ప్రచురణ, అప్‌డేట్ మరియు తొలగింపు అన్నింటికీ వర్తిస్తుంది).

/ ఉదాహరణ

కోడ్ ఉదాహరణ

Express‌తో Node.jsలో కనీస స్వీకరణ endpoint. అవే దశలు — tokenను ధృవీకరించండి, action (update / delete) ఆధారంగా విభజించండి, పోస్ట్‌ను సృష్టించండి లేదా మార్చండి, URLను తిరిగి ఇవ్వండి — ఏ భాష లేదా ఫ్రేమ్‌వర్క్‌లోనైనా వర్తిస్తాయి.

// 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ను మార్చకుండా ఓవర్‌రైట్ చేస్తుంది. అభ్యర్థన అదే 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 కాని స్థితి, లేదా 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 కంటే ఎక్కువైన దేనినైనా తిరస్కరించండి. ఫైల్‌ను నిల్వ చేసి, ఆ తర్వాత చిత్రం యొక్క సంపూర్ణ URLతో సమాధానం ఇవ్వండి: సాపేక్ష మార్గం ఆర్టికల్ వేరే చోట రెండర్ అయిన వెంటనే దాన్ని పాడు చేస్తుంది. ఈ action Visual Editor కోసం మాత్రమే అవసరం.

/ ఒప్పందం — తొలగింపు

ఆర్టికల్‌లను తొలగించడం

వినియోగదారు Orova లోపల ప్రచురించిన ఆర్టికల్‌ను తొలగించినప్పుడు (Write లేదా Reports స్క్రీన్ నుండి), Orova మీ సైట్‌ను కూడా దాన్ని తొలగించమని అడుగుతుంది. అభ్యర్థన అదే 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కు చెబుతుంది. సాధారణ ప్రచురణ అభ్యర్థనలలో ఎప్పుడూ action ఫీల్డ్ ఉండదు, కాబట్టి ఉన్న endpointలు మార్పు లేకుండా పని చేస్తూనే ఉంటాయి — delete అమలు చేయడం ఐచ్ఛికం కానీ సిఫార్సు చేయబడింది.

/ భద్రత

భద్రతా గమనికలు

• ఎల్లప్పుడూ Bearer tokenను ధృవీకరించండి. మీ endpoint ఒక పబ్లిక్ URL — ఎవరైనా దాన్ని కాల్ చేయవచ్చు. అభ్యర్థన నిజంగా Orova నుండి వచ్చిందని నిరూపించేది Authorization హెడర్ మాత్రమే, కాబట్టి token మీరు నిల్వ చేసిన సీక్రెట్‌తో ఖచ్చితంగా సరిపోలని ప్రతి అభ్యర్థనను తిరస్కరించండి.
• Endpointను HTTPS ద్వారా అందించండి. సీక్రెట్ హెడర్‌లో ప్రయాణిస్తుంది. HTTPS దాన్ని ప్రయాణంలో చదవకుండా కాపాడుతుంది.
• సీక్రెట్‌ను మీ కోడ్ నుండి దూరంగా ఉంచండి. దాన్ని environment variable లేదా secrets managerలో నిల్వ చేయండి, మీరు commit చేసే ఫైల్‌లో ఎప్పుడూ hard-code చేయవద్దు. అది ఎప్పుడైనా బయటపడితే, Project → Connections నుండి కొత్తది రూపొందించండి.
• content_htmlను కంటెంట్‌గా పరిగణించండి, విశ్వసనీయ మార్కప్‌గా కాదు. మీ CMSలో ఏ ఆర్టికల్ bodyనైనా ఎంత జాగ్రత్తగా నిల్వ చేసి రెండర్ చేస్తారో దీన్ని కూడా అలాగే చేయండి.

/ ముగింపు

ఒప్పందం మొత్తం ఇదే

Endpoint లైవ్‌లో ఉండి మీ ప్రాజెక్ట్‌లో నమోదు చేయబడిన తర్వాత, Orova మీ సైట్‌కు ఆటోమేటిక్‌గా ప్రచురిస్తుంది — WordPress వినియోగదారులకు చేసినట్లే. అది పూర్తి చేసే ప్రతి ఆర్టికల్ మీ సర్వర్‌కు చేరి, పోస్ట్‌గా మారుతుంది, మరియు దాని పబ్లిక్ URL Reports మరియు Analysisకి తిరిగి వస్తుంది, కాబట్టి అది ఎలా పని చేస్తుందో మీరు ట్రాక్ చేయవచ్చు.