Rank Tracking

// Define keywords to track
const keywordsToTrack = [
  {
    keyword: "project management software",
    location_name: "United States",
    iso_code: "US",
    device: "desktop",
    depth: 100  // Get top 100 results
  },
  {
    keyword: "best crm software",
    location_name: "United States",
    iso_code: "US",
    device: "desktop",
    depth: 100
  },
  {
    keyword: "task management app",
    location_name: "United Kingdom",
    iso_code: "GB",
    device: "mobile",
    depth: 50
  }
];

// Your domain to track
const TARGET_DOMAIN = "yourdomain.com";

const API_KEY = process.env.SERPWATCH_API_KEY;
const BASE_URL = "https://engine.v2.serpwatch.io";

// Prepare batch request
const batchRequests = keywordsToTrack.map(kw => ({
  keyword: kw.keyword,
  location_name: kw.location_name,
  iso_code: kw.iso_code,
  device: kw.device,
  depth: kw.depth,
  language_code: "en",
  postback_url: "https://yourapp.com/webhook/serp"  // Optional
}));

// Submit batch
const response = await fetch(
  `${BASE_URL}/api/v2/serp/crawl/google/batch`,
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify(batchRequests)
  }
);

const tasks = await response.json();
console.log(`Submitted ${tasks.length} tasks`);

// Store task IDs for later retrieval
const taskIds = tasks.map(task => task.id);

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function waitForTask(taskId, maxWait = 120000) {
  const startTime = Date.now();

  while (Date.now() - startTime < maxWait) {
    const response = await fetch(
      `${BASE_URL}/api/v2/serp/crawl/${taskId}`,
      { headers: { "Authorization": `Bearer ${API_KEY}` } }
    );
    const result = await response.json();

    if (result.status === "success" || result.status === "completed") {
      return result;
    } else if (result.status === "error") {
      throw new Error(`Task failed: ${result.error_message}`);
    }

    await sleep(3000);  // Wait 3 seconds between polls
  }

  throw new Error(`Task ${taskId} timed out`);
}

// Collect all results
const allResults = [];
for (const taskId of taskIds) {
  try {
    const result = await waitForTask(taskId);
    allResults.push(result);
    console.log(`Got results for: ${result.keyword}`);
  } catch (e) {
    console.error(`Error for task ${taskId}:`, e.message);
  }
}

function findDomainRank(result, targetDomain) {
  /**
   * Find the ranking position for a domain in SERP results.
   * Returns object with position, url, title or null if not found
   */
  // Get organic results from the left array
  const leftResults = result.result?.left || [];
  const organic = leftResults.filter(r => r.type === "organic");

  for (const item of organic) {
    const url = item.url || "";
    const domain = new URL(url).hostname.toLowerCase().replace("www.", "");
    // Check if target domain matches (handles subdomains)
    if (domain.includes(targetDomain.toLowerCase()) ||
        domain.endsWith(targetDomain.toLowerCase())) {
      return {
        position: parseInt(item.position),
        url: url,
        title: item.title || "",
        domain: domain
      };
    }
  }

  return null;  // Domain not found in results
}

// Process all results
const rankings = allResults.map(result => {
  const keyword = result.keyword;
  const rankInfo = findDomainRank(result, TARGET_DOMAIN);

  return {
    keyword,
    location: result.location_name || "",
    device: result.device || "",
    position: rankInfo?.position || null,
    url: rankInfo?.url || null,
    found: rankInfo !== null
  };
});

// Display results
console.log("\n=== Ranking Report ===");
for (const r of rankings) {
  const status = r.found ? `#${r.position}` : "Not in top 100";
  console.log(`${r.keyword}: ${status}`);
}