mcp-scraper 0.40.1 → 0.40.2

package/dist/chunk-SBLGBZZB.js

@@ -0,0 +1,647 @@
+// src/api/rates.ts
+var MC_COSTS = {
+  serp: 400,
+  serp_headless: 400,
+  serp_headful: 1400,
+  paa: 300,
+  paa_base: 5500,
+  page_scrape: 100,
+  url_map: 500,
+  yt_channel: 200,
+  yt_transcription: 200,
+  fb_ad: 700,
+  maps_search: 500,
+  maps_place: 6e3,
+  maps_review: 100,
+  fb_search: 800,
+  fb_search_result: 100,
+  fb_page_intel: 700,
+  fb_page_intel_ad: 50,
+  fb_transcribe: 33300,
+  google_ads_search: 600,
+  google_ads_intel: 200,
+  google_ads_transcribe: 33300,
+  instagram_profile: 400,
+  instagram_media: 400,
+  instagram_transcribe: 33300,
+  browser_minute: 12e3,
+  reddit_thread: 3e3,
+  reddit_comment: 200,
+  video_analysis: 666700,
+  trustpilot_reviews: 500,
+  trustpilot_review: 100,
+  g2_reviews: 500,
+  g2_review: 200,
+  diff_page: 100
+};
+function serpActualCostMc(headlessSent) {
+  return headlessSent === true ? MC_COSTS.serp_headless : MC_COSTS.serp_headful;
+}
+var MC_PER_BROWSER_MS = MC_COSTS.browser_minute / 6e4;
+function browserActiveCostMc(activeMs) {
+  return Math.round(activeMs * MC_PER_BROWSER_MS);
+}
+var BROWSER_OPEN_MIN_BALANCE_MC = 1e3;
+var MC_PER_CREDIT = 100;
+var BILLING_MC_PER_USD_NUMERATOR = 2e6;
+var BILLING_MC_PER_USD_DENOMINATOR = 3;
+var BILLING_BASIS_POINTS = 1e4;
+var USD_NANOS = 1e9;
+var SCHEDULED_RUN_BASE_CREDITS = 75;
+var SCHEDULED_RUN_BASE_MC = SCHEDULED_RUN_BASE_CREDITS * MC_PER_CREDIT;
+var SCHEDULED_AGENT_LLM_MARKUP_BPS = 15e3;
+var SCHEDULED_AGENT_LLM_MARKUP = SCHEDULED_AGENT_LLM_MARKUP_BPS / BILLING_BASIS_POINTS;
+var SCHEDULED_RUN_DEFAULT_MAX_CREDITS = 5e3;
+var CONNECTED_USAGE_RATE_POLICY_VERSION = "2026-07-23.connected-usage-v2";
+var CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS = 15e3;
+var CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC = CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS * MC_PER_CREDIT;
+var CONNECTED_FUNCTION_RUN_CREDITS = 1.5;
+var CONNECTED_PROXY_REQUEST_CREDITS = 1.5;
+var CONNECTED_COMPUTE_CREDITS_PER_SECOND = 3;
+var CONNECTED_FUNCTION_RUN_MC = CONNECTED_FUNCTION_RUN_CREDITS * MC_PER_CREDIT;
+var CONNECTED_PROXY_REQUEST_MC = CONNECTED_PROXY_REQUEST_CREDITS * MC_PER_CREDIT;
+var CONNECTED_COMPUTE_MC_PER_SECOND = CONNECTED_COMPUTE_CREDITS_PER_SECOND * MC_PER_CREDIT;
+var CONNECTED_USAGE_RATE_POLICY = {
+  schemaVersion: 2,
+  ratePolicyVersion: CONNECTED_USAGE_RATE_POLICY_VERSION,
+  effectiveAt: "2026-07-23T00:00:00.000Z",
+  provider: "nango",
+  entitlement: "paid_plan_add_on",
+  connection: {
+    billingMode: "flat_recurring_credits",
+    amountCredits: CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
+    interval: "month",
+    unit: "active_connection",
+    proration: "none"
+  },
+  usage: {
+    billingMode: "credits",
+    settlementMode: "authoritative_receipt",
+    rounding: "aggregate_then_ceil_to_mc",
+    functionRun: {
+      credits: CONNECTED_FUNCTION_RUN_CREDITS,
+      mc: CONNECTED_FUNCTION_RUN_MC,
+      unit: "per_function_run"
+    },
+    proxyRequest: {
+      credits: CONNECTED_PROXY_REQUEST_CREDITS,
+      mc: CONNECTED_PROXY_REQUEST_MC,
+      unit: "per_proxy_request"
+    },
+    compute: {
+      creditsPerSecond: CONNECTED_COMPUTE_CREDITS_PER_SECOND,
+      mcPerSecond: CONNECTED_COMPUTE_MC_PER_SECOND,
+      sourceUnit: "millisecond",
+      unit: "per_compute_second",
+      formula: "ceil(computeMilliseconds * mcPerSecond / 1000)"
+    }
+  }
+};
+function nonNegativeSafeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative safe integer`);
+  }
+  return BigInt(value);
+}
+function safeMc(value) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("connected usage charge exceeds the safe integer range");
+  return Number(value);
+}
+function calculateConnectedUsageCharge(usage) {
+  const functionRuns = nonNegativeSafeInteger(usage.functionRuns, "functionRuns");
+  const proxyRequests = nonNegativeSafeInteger(usage.proxyRequests, "proxyRequests");
+  const computeMilliseconds = nonNegativeSafeInteger(usage.computeMilliseconds, "computeMilliseconds");
+  const functionRunMc = functionRuns * BigInt(CONNECTED_FUNCTION_RUN_MC);
+  const proxyRequestMc = proxyRequests * BigInt(CONNECTED_PROXY_REQUEST_MC);
+  const computeNumerator = computeMilliseconds * BigInt(CONNECTED_COMPUTE_MC_PER_SECOND);
+  const computeMc = computeNumerator === 0n ? 0n : (computeNumerator + 999n) / 1000n;
+  const amountMc = functionRunMc + proxyRequestMc + computeMc;
+  return {
+    functionRunMc: safeMc(functionRunMc),
+    proxyRequestMc: safeMc(proxyRequestMc),
+    computeMc: safeMc(computeMc),
+    amountMc: safeMc(amountMc),
+    credits: safeMc(amountMc) / MC_PER_CREDIT
+  };
+}
+var SCHEDULED_ACTIONS_RATE_POLICY = {
+  billingMode: "credits",
+  entitlement: "paid_plan_included",
+  separateSubscriptionRequired: false,
+  chargeEvent: "started_occurrence",
+  runBaseCredits: SCHEDULED_RUN_BASE_CREDITS,
+  runBaseMc: SCHEDULED_RUN_BASE_MC,
+  llmCostMultiplier: SCHEDULED_AGENT_LLM_MARKUP,
+  llmCostMultiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS,
+  modes: {
+    connection_sync: {
+      runBaseCredits: SCHEDULED_RUN_BASE_CREDITS,
+      modelCostBilling: "none",
+      modelCostMultiplier: 0
+    },
+    agent: {
+      runBaseCredits: SCHEDULED_RUN_BASE_CREDITS,
+      modelCostBilling: "actual_reported_cost",
+      modelCostProvider: "openrouter",
+      modelCostMultiplier: SCHEDULED_AGENT_LLM_MARKUP,
+      modelCostMultiplierBps: SCHEDULED_AGENT_LLM_MARKUP_BPS
+    }
+  }
+};
+function vendorCostUsdToMc(costUsd, markupBps) {
+  if (!Number.isFinite(costUsd) || costUsd < 0) throw new Error("costUsd must be a finite non-negative number");
+  if (!Number.isInteger(markupBps) || markupBps < 0) throw new Error("markupBps must be a non-negative integer");
+  const rawCostNanos = BigInt(Math.round(costUsd * USD_NANOS));
+  const numerator = rawCostNanos * BigInt(markupBps) * BigInt(BILLING_MC_PER_USD_NUMERATOR);
+  const denominator = BigInt(USD_NANOS) * BigInt(BILLING_BASIS_POINTS) * BigInt(BILLING_MC_PER_USD_DENOMINATOR);
+  const mc = numerator === 0n ? 0n : (numerator + denominator - 1n) / denominator;
+  if (mc > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error("calculated mc exceeds the safe integer range");
+  return Number(mc);
+}
+var CREDIT_COST_CATALOG = [
+  {
+    key: "serp",
+    label: "SERP search",
+    aliases: ["search_serp", "serp", "google search", "organic results"],
+    credits: mcToCredits(MC_COSTS.serp_headless),
+    unit: "per search (headless); escalates to headful only when needed",
+    notes: `Returns AI Overview, PAA snippet, videos, forums, and local pack. Billed ${mcToCredits(MC_COSTS.serp_headless)} credits when served headless (the common case), ${mcToCredits(MC_COSTS.serp_headful)} credits if an anti-bot escalation forces headful mode (overestimate refunded). Optional SERP Intelligence page snapshots add ${mcToCredits(MC_COSTS.page_scrape)} credit per attempted URL.`
+  },
+  {
+    key: "paa",
+    label: "PAA harvest",
+    aliases: ["harvest_paa", "paa", "people also ask", "questions"],
+    credits: mcToCredits(MC_COSTS.paa),
+    unit: `per question (+${mcToCredits(MC_COSTS.paa_base)} credit base)`,
+    notes: `Full SERP feature extraction. Billed ${mcToCredits(MC_COSTS.paa_base)} credit base + ${mcToCredits(MC_COSTS.paa)} per question actually returned (unused estimate refunded).`
+  },
+  {
+    key: "page_scrape",
+    label: "Page crawl / extract",
+    aliases: ["extract_url", "extract_site", "page scrape", "url scrape", "single page", "site crawl"],
+    credits: mcToCredits(MC_COSTS.page_scrape),
+    unit: "per page",
+    notes: "Applies to both single-URL extraction and per-page site crawls."
+  },
+  {
+    key: "url_map",
+    label: "Site URL mapping",
+    aliases: ["map_site_urls", "url map", "site map", "crawl urls"],
+    credits: mcToCredits(MC_COSTS.url_map),
+    unit: "per mapping operation",
+    notes: "Flat rate for the full /map-urls call regardless of URL count discovered."
+  },
+  {
+    key: "yt_channel",
+    label: "YouTube search / channel harvest",
+    aliases: ["youtube_harvest", "youtube search", "youtube channel", "yt_channel"],
+    credits: mcToCredits(MC_COSTS.yt_channel),
+    unit: "per call"
+  },
+  {
+    key: "yt_transcription",
+    label: "YouTube transcription",
+    aliases: ["youtube_transcribe", "youtube transcript", "transcription", "yt_transcription"],
+    credits: mcToCredits(2e4),
+    unit: "base + 2/min of video",
+    notes: "Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits)."
+  },
+  {
+    key: "fb_ad",
+    label: "Facebook search / ad lookup",
+    aliases: ["facebook_page_intel", "facebook_ad_search", "facebook_ad", "facebook ads", "fb ads"],
+    credits: mcToCredits(MC_COSTS.fb_ad),
+    unit: "per call"
+  },
+  {
+    key: "maps_search",
+    label: "Maps business search",
+    aliases: ["maps_search", "google maps search", "gmb search", "gbp search", "business profiles"],
+    credits: mcToCredits(MC_COSTS.maps_search),
+    unit: "per search",
+    notes: "Returns up to 50 Google Maps business/profile candidates. Use maps_place_intel to hydrate selected businesses."
+  },
+  {
+    key: "maps_place",
+    label: "Maps business lookup",
+    aliases: ["maps_place_intel", "google maps", "maps place", "place intel"],
+    credits: mcToCredits(MC_COSTS.maps_place),
+    unit: "per business",
+    notes: "Base lookup. Reviews billed separately per card at maps_review rate."
+  },
+  {
+    key: "maps_review",
+    label: "Maps review",
+    aliases: ["maps_reviews", "google reviews", "review cards", "reviews"],
+    credits: mcToCredits(MC_COSTS.maps_review),
+    unit: "per review card",
+    notes: "Charged after extraction when includeReviews is true."
+  },
+  {
+    key: "fb_search",
+    label: "Facebook ad library search",
+    aliases: ["facebook_search", "fb_search", "fb ad search"],
+    credits: mcToCredits(MC_COSTS.fb_search),
+    unit: "per search",
+    notes: "Browser automation to search Facebook Ads Library by keyword."
+  },
+  {
+    key: "google_ads_search",
+    label: "Google Ads Transparency search",
+    aliases: ["google_ads_search", "google ads search", "ads transparency search"],
+    credits: mcToCredits(MC_COSTS.google_ads_search),
+    unit: "per search",
+    notes: "Browser automation to find advertisers in Google Ads Transparency Center by domain or name."
+  },
+  {
+    key: "google_ads_intel",
+    label: "Google Ads Transparency advertiser intel",
+    aliases: ["google_ads_page_intel", "google ads intel", "ads transparency intel"],
+    credits: mcToCredits(MC_COSTS.google_ads_intel),
+    unit: "per call",
+    notes: "Lists and hydrates an advertiser's creatives with image URLs and video references."
+  },
+  {
+    key: "google_ads_transcribe",
+    label: "Google ad video transcription",
+    aliases: ["google_ads_transcribe", "google ad transcript"],
+    credits: mcToCredits(2e4),
+    unit: "base + 2/min of video",
+    notes: "Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits)."
+  },
+  {
+    key: "fb_transcribe",
+    label: "Facebook video / ad transcription",
+    aliases: ["facebook_transcribe", "facebook_video_transcribe", "fb_transcribe", "fb ad transcript"],
+    credits: mcToCredits(2e4),
+    unit: "base + 2/min of video",
+    notes: "Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits)."
+  },
+  {
+    key: "instagram_profile",
+    label: "Instagram profile content discovery",
+    aliases: ["instagram_profile_content", "instagram profile", "instagram content list", "ig profile"],
+    credits: mcToCredits(MC_COSTS.instagram_profile),
+    unit: "per profile scan",
+    notes: "Browser extraction of public Instagram profile grid links. Complete history may require a logged-in profile."
+  },
+  {
+    key: "instagram_media",
+    label: "Instagram media download",
+    aliases: ["instagram_media_download", "instagram reel download", "instagram post download", "ig media"],
+    credits: mcToCredits(MC_COSTS.instagram_media),
+    unit: "per post or reel",
+    notes: "Extracts post text, image URLs, and reel audio/video tracks, with local downloads when the server can write files."
+  },
+  {
+    key: "instagram_transcribe",
+    label: "Instagram media transcription",
+    aliases: ["instagram transcript", "instagram reel transcript", "ig transcribe"],
+    credits: mcToCredits(2e4),
+    unit: "base + 2/min of video",
+    notes: "Whisper transcription of selected Instagram audio/video media. Flat 200-credit base plus 2 credits per minute of video, reconciled to the real video length after transcription (e.g. a 10-minute video is about 220 credits)."
+  },
+  {
+    key: "browser_minute",
+    label: "Interactive browser session",
+    aliases: ["browser_open", "browser agent", "browser_agent", "live browser", "browse", "browser control", "interactive browser"],
+    credits: mcToCredits(MC_COSTS.browser_minute),
+    unit: "per minute of use",
+    notes: "Metered per minute of use for the whole time the browser session is open. Close the session to stop the meter; abandoned sessions are auto-closed after a short idle window."
+  },
+  {
+    key: "reddit_thread",
+    label: "Reddit thread base lookup",
+    aliases: ["reddit", "reddit_thread", "reddit comments", "subreddit", "reddit post"],
+    credits: mcToCredits(MC_COSTS.reddit_thread),
+    unit: "per thread",
+    notes: "Base lookup for the post itself. Comments billed separately per comment at reddit_comment rate. Refunded if the thread cannot be retrieved."
+  },
+  {
+    key: "reddit_comment",
+    label: "Reddit comment",
+    aliases: ["reddit_comment", "reddit comments"],
+    credits: mcToCredits(MC_COSTS.reddit_comment),
+    unit: "per comment",
+    notes: "Charged per comment actually extracted, billed down automatically if the balance runs out mid-thread."
+  },
+  {
+    key: "video_analysis",
+    label: "Video breakdown (frame-by-frame + transcript)",
+    aliases: ["video_frame_analysis", "video breakdown", "video analysis", "analyze video"],
+    credits: mcToCredits(MC_COSTS.video_analysis),
+    unit: "per 120 frames (max 480)",
+    notes: "Full multi-lens video breakdown: samples frames across a video (up to 30 minutes), analyzes each with vision AI, transcribes the audio, then produces summary, pacing/energy, words-per-minute, topic outline, key points, hook analysis, visual style, and a how-to-replicate recipe with a quality-control pass. $1 per 120 frames requested (max 480 = $4); billed down automatically if the video cannot use the requested frames, and refunded fully if the run fails."
+  },
+  {
+    key: "trustpilot_reviews",
+    label: "Trustpilot review harvest",
+    aliases: ["trustpilot_reviews", "trustpilot", "trustpilot reviews"],
+    credits: mcToCredits(MC_COSTS.trustpilot_reviews),
+    unit: "per call",
+    notes: "Base lookup. Reviews billed separately per card at trustpilot_review rate. Refunded if no reviews are found."
+  },
+  {
+    key: "trustpilot_review",
+    label: "Trustpilot review card",
+    aliases: ["trustpilot_review", "trustpilot card"],
+    credits: mcToCredits(MC_COSTS.trustpilot_review),
+    unit: "per review card",
+    notes: "Charged per review actually extracted, billed down automatically if the balance runs out mid-page."
+  },
+  {
+    key: "g2_reviews",
+    label: "G2 review harvest",
+    aliases: ["g2_reviews", "g2", "g2 reviews"],
+    credits: mcToCredits(MC_COSTS.g2_reviews),
+    unit: "per call",
+    notes: "Base lookup. Reviews billed separately per card at g2_review rate. Refunded if no reviews are found."
+  },
+  {
+    key: "g2_review",
+    label: "G2 review card",
+    aliases: ["g2_review", "g2 card"],
+    credits: mcToCredits(MC_COSTS.g2_review),
+    unit: "per review card",
+    notes: "Charged per review actually extracted (each card carries up to 3 Q&A sections), billed down automatically if the balance runs out mid-page."
+  },
+  {
+    key: "diff_page",
+    label: "Page change check",
+    aliases: ["diff_page", "page diff", "change detection"],
+    credits: mcToCredits(MC_COSTS.diff_page),
+    unit: "per check",
+    notes: "Same cost as a single page extract \u2014 one scrape is performed per check, then compared against your last stored snapshot for that URL."
+  }
+];
+var CONCURRENCY_PRICE_ID = "price_1Ta1NRS8aAcsk3TGwsRnYbix";
+function tierBillingInterval(tier) {
+  return tier.billing_interval ?? "month";
+}
+function tierAmountChargedUsd(tier) {
+  return tier.billed_usd ?? tier.monthly_usd;
+}
+function tierCreditsPerInterval(tier) {
+  return tier.credits_mc / MC_PER_CREDIT;
+}
+var SUBSCRIPTION_TIERS = {
+  "price_1TmiHRS8aAcsk3TGwmSNfNIa": { tier: "starter", label: "Starter", price_id: "price_1TmiHRS8aAcsk3TGwmSNfNIa", monthly_usd: 12, credits_mc: 8e6, concurrency: 3, intro_coupon: "mcp-starter-1dollar-intro-12" },
+  "price_1TrgihS8aAcsk3TG5cglrq4D": { tier: "growth", label: "Growth", price_id: "price_1TrgihS8aAcsk3TG5cglrq4D", monthly_usd: 40, credits_mc: 26666700, concurrency: 10, intro_coupon: null },
+  "price_1TrgihS8aAcsk3TG4HnG4gbY": { tier: "scale", label: "Scale", price_id: "price_1TrgihS8aAcsk3TG4HnG4gbY", monthly_usd: 100, credits_mc: 8e7, concurrency: 20, intro_coupon: null },
+  "price_1TwqIVS8aAcsk3TG0FE3ddDM": { tier: "sonic", label: "Sonic Annual", price_id: "price_1TwqIVS8aAcsk3TG0FE3ddDM", monthly_usd: 25, billed_usd: 300, credits_mc: 25e7, concurrency: 3, intro_coupon: null, billing_interval: "year", credits_never_expire: true, private_offer: true },
+  "price_1TwqIWS8aAcsk3TGbGbtlLak": { tier: "sonic-memory", label: "Sonic Annual + Memory Pro", price_id: "price_1TwqIWS8aAcsk3TGbGbtlLak", monthly_usd: 34.5, billed_usd: 414, credits_mc: 25e7, concurrency: 3, intro_coupon: null, billing_interval: "year", credits_never_expire: true, includes_memory: true, private_offer: true }
+};
+var SUBSCRIPTION_TIER_BY_KEY = Object.fromEntries(
+  Object.values(SUBSCRIPTION_TIERS).map((t) => [t.tier, t])
+);
+var PRIVATE_OFFERS = {
+  sonic: {
+    slug: "sonic",
+    label: "Sonic annual partner offer",
+    headline: "A full year of MCP Scraper, with Credits that never expire.",
+    tier_keys: ["sonic", "sonic-memory"]
+  }
+};
+function offerClaimPathForTier(tierKey) {
+  const offer = Object.values(PRIVATE_OFFERS).find((o) => o.tier_keys.includes(tierKey));
+  return offer ? `/${offer.slug}/claim` : null;
+}
+function offerForTier(tierKey) {
+  if (!tierKey) return null;
+  return Object.values(PRIVATE_OFFERS).find((o) => o.tier_keys.includes(tierKey)) ?? null;
+}
+function tierChangeLeavesPrivateOffer(fromTier, toTier) {
+  const from = offerForTier(fromTier);
+  if (!from) return false;
+  return !from.tier_keys.includes(toTier);
+}
+function getSubscriptionPlanView(tierKey) {
+  if (!tierKey) return null;
+  const tier = SUBSCRIPTION_TIER_BY_KEY[tierKey];
+  if (!tier) return null;
+  return {
+    tier: tier.tier,
+    label: tier.label,
+    amount_usd: tierAmountChargedUsd(tier),
+    interval: tierBillingInterval(tier),
+    monthly_equivalent_usd: tier.monthly_usd,
+    credits_per_interval: tierCreditsPerInterval(tier),
+    concurrency: tier.concurrency,
+    credits_never_expire: !!tier.credits_never_expire,
+    includes_memory: !!tier.includes_memory,
+    private_offer: !!tier.private_offer,
+    offer_claim_path: offerClaimPathForTier(tier.tier)
+  };
+}
+function getPrivateOfferPayload(slug) {
+  const offer = PRIVATE_OFFERS[slug];
+  if (!offer) return null;
+  const options = offer.tier_keys.map((key) => SUBSCRIPTION_TIER_BY_KEY[key]).filter((t) => !!t).map((t) => ({
+    tier: t.tier,
+    label: t.label,
+    amount_usd: tierAmountChargedUsd(t),
+    interval: tierBillingInterval(t),
+    monthly_equivalent_usd: t.monthly_usd,
+    credits: tierCreditsPerInterval(t),
+    credits_never_expire: !!t.credits_never_expire,
+    includes_memory: !!t.includes_memory,
+    concurrency: t.concurrency
+  }));
+  if (!options.length) return null;
+  return { slug: offer.slug, label: offer.label, headline: offer.headline, options };
+}
+function getPublicRatesPayload() {
+  const starter = SUBSCRIPTION_TIER_BY_KEY.starter;
+  const costs = CREDIT_COST_CATALOG.map(({ aliases, ...cost }) => ({
+    ...cost,
+    ...cost.notes ? { notes: cost.notes.replace(/ via fal\.ai/g, "") } : {}
+  }));
+  return {
+    creditsPerDollarStarter: Math.round(mcToCredits(starter.credits_mc) / starter.monthly_usd),
+    costs,
+    scheduling: SCHEDULED_ACTIONS_RATE_POLICY,
+    connectedAccounts: CONNECTED_USAGE_RATE_POLICY
+  };
+}
+var CONCURRENCY_SLOT_PRICE_USD = 5;
+var CONCURRENCY_SLOT_PRICE_CURRENCY = "usd";
+var CONCURRENCY_SLOT_PRICE_INTERVAL = "month";
+var CONCURRENCY_SLOT_PRICE_LABEL = "$5/month";
+var CONCURRENCY_SLOT_TERMINAL_COMMAND = "npx -y -p mcp-scraper@latest mcp-scraper-cli billing concurrency checkout";
+function concurrencySlotBillingInfo() {
+  const billingUrl = process.env.CONCURRENCY_BILLING_URL ?? "https://mcpscraper.dev/billing";
+  return {
+    product: "Extra concurrency slot",
+    price_label: CONCURRENCY_SLOT_PRICE_LABEL,
+    unit_amount_usd: CONCURRENCY_SLOT_PRICE_USD,
+    currency: CONCURRENCY_SLOT_PRICE_CURRENCY,
+    interval: CONCURRENCY_SLOT_PRICE_INTERVAL,
+    billing_url: billingUrl,
+    terminal_command: CONCURRENCY_SLOT_TERMINAL_COMMAND,
+    terminal_command_with_api_key_env: `MCP_SCRAPER_API_KEY=sk_live_your_key ${CONCURRENCY_SLOT_TERMINAL_COMMAND}`
+  };
+}
+function mcToCredits(mc) {
+  return mc / MC_PER_CREDIT;
+}
+function insufficientBalanceResponse(balanceMc, requiredMc) {
+  const topupUrl = process.env.TOPUP_URL ?? "https://mcpscraper.dev/billing";
+  const balanceCredits = mcToCredits(balanceMc);
+  const requiredCredits = mcToCredits(requiredMc);
+  return {
+    error: "insufficient_balance",
+    error_code: "insufficient_balance",
+    message: `Insufficient credits. Balance: ${balanceCredits} credits. This call requires ${requiredCredits} credits. Top up at ${topupUrl}`,
+    balance_credits: balanceCredits,
+    required_credits: requiredCredits,
+    topup_url: topupUrl
+  };
+}
+var MEMORY_FREE_QUOTA_BYTES = 1e7 * 1;
+var MEMORY_PLANS = {
+  "price_1TnMSTS8aAcsk3TGBgiwuvqL": { plan: "pro", label: "Pro", price_id: "price_1TnMSTS8aAcsk3TGBgiwuvqL", interval: "month", monthly_usd: 19, quota_bytes: 5e9 },
+  "price_1TnMSTS8aAcsk3TGWBVU2agY": { plan: "pro", label: "Pro", price_id: "price_1TnMSTS8aAcsk3TGWBVU2agY", interval: "year", monthly_usd: 19, quota_bytes: 5e9 }
+};
+var MEMORY_PLAN_QUOTA = { free: MEMORY_FREE_QUOTA_BYTES, pro: 5e9, team: 5e10 };
+var MEMORY_MARGIN_MULTIPLE = 3;
+var MEMORY_PRO_COST_BUDGET_USD = 19 / MEMORY_MARGIN_MULTIPLE;
+var LedgerOperation = {
+  TOPUP: "topup",
+  SUBSCRIPTION: "subscription",
+  SIGNUP_GRANT: "signup_grant",
+  MONTHLY_REFRESH: "monthly_free_refresh",
+  PAA: "paa",
+  PAA_REFUND: "paa_refund",
+  SERP: "serp",
+  SERP_REFUND: "serp_refund",
+  REFUND: "refund",
+  TRANSCRIPTION: "transcription",
+  TRANSCRIPTION_HOLD: "transcription_hold",
+  TRANSCRIPTION_REFUND: "transcription_refund",
+  YT_CHANNEL: "yt_channel",
+  FB_AD: "fb_ad",
+  MAPS_SEARCH: "maps_search",
+  DIRECTORY_WORKFLOW_HOLD: "directory_workflow_hold",
+  DIRECTORY_WORKFLOW_REFUND: "directory_workflow_refund",
+  MAPS_PLACE: "maps_place",
+  MAPS_REVIEW: "maps_review",
+  MAPS_REVIEW_REFUND: "maps_review_refund",
+  EXTRACT_SITE: "extract_site",
+  EXTRACT_SITE_REFUND: "extract_site_refund",
+  EXTRACT_URL: "page_scrape",
+  URL_MAP: "url_map",
+  EXTRACT_SITE_HOLD: "extract_site_hold",
+  YT_CHANNEL_REFUND: "yt_channel_refund",
+  FB_AD_REFUND: "fb_ad_refund",
+  URL_MAP_REFUND: "url_map_refund",
+  FB_SEARCH: "fb_search",
+  FB_TRANSCRIBE: "fb_transcribe",
+  FB_SEARCH_REFUND: "fb_search_refund",
+  FB_SEARCH_RESULT: "fb_search_result",
+  FB_SEARCH_RESULT_REFUND: "fb_search_result_refund",
+  FB_PAGE_INTEL: "fb_page_intel",
+  FB_PAGE_INTEL_REFUND: "fb_page_intel_refund",
+  FB_PAGE_INTEL_AD: "fb_page_intel_ad",
+  FB_PAGE_INTEL_AD_REFUND: "fb_page_intel_ad_refund",
+  FB_TRANSCRIBE_REFUND: "fb_transcribe_refund",
+  GOOGLE_ADS_SEARCH: "google_ads_search",
+  GOOGLE_ADS_SEARCH_REFUND: "google_ads_search_refund",
+  GOOGLE_ADS_INTEL: "google_ads_intel",
+  GOOGLE_ADS_INTEL_REFUND: "google_ads_intel_refund",
+  GOOGLE_ADS_TRANSCRIBE: "google_ads_transcribe",
+  GOOGLE_ADS_TRANSCRIBE_REFUND: "google_ads_transcribe_refund",
+  INSTAGRAM_PROFILE: "instagram_profile",
+  INSTAGRAM_PROFILE_REFUND: "instagram_profile_refund",
+  INSTAGRAM_MEDIA: "instagram_media",
+  INSTAGRAM_MEDIA_REFUND: "instagram_media_refund",
+  INSTAGRAM_TRANSCRIBE: "instagram_transcribe",
+  INSTAGRAM_TRANSCRIBE_REFUND: "instagram_transcribe_refund",
+  BROWSER_SESSION: "browser_session",
+  REDDIT_THREAD: "reddit_thread",
+  REDDIT_THREAD_REFUND: "reddit_thread_refund",
+  REDDIT_COMMENT: "reddit_comment",
+  REDDIT_COMMENT_REFUND: "reddit_comment_refund",
+  VIDEO_ANALYSIS: "video_analysis",
+  VIDEO_ANALYSIS_REFUND: "video_analysis_refund",
+  VIDEO_ANALYSIS_ADJUST: "video_analysis_adjust",
+  VIDEO_ANALYSIS_LLM: "video_analysis_llm",
+  MEMORY_AI: "memory_ai",
+  MEMORY_AI_REFUND: "memory_ai_refund",
+  TRUSTPILOT_REVIEWS: "trustpilot_reviews",
+  TRUSTPILOT_REVIEWS_REFUND: "trustpilot_reviews_refund",
+  TRUSTPILOT_REVIEW: "trustpilot_review",
+  TRUSTPILOT_REVIEW_REFUND: "trustpilot_review_refund",
+  G2_REVIEWS: "g2_reviews",
+  G2_REVIEWS_REFUND: "g2_reviews_refund",
+  G2_REVIEW: "g2_review",
+  G2_REVIEW_REFUND: "g2_review_refund",
+  DIFF_PAGE: "diff_page",
+  DIFF_PAGE_REFUND: "diff_page_refund",
+  SITE_AUDIT_LLM: "site_audit_llm",
+  SCHEDULED_RUN: "scheduled_run",
+  CONNECTED_USAGE: "connected_usage",
+  CONNECTED_ACCOUNT_FEE: "connected_account_fee",
+  ADMIN_GRANT: "admin_grant",
+  ADMIN_REVOKE: "admin_revoke"
+};
+var MEMORY_AI_MARGIN_MULTIPLE = 3;
+var SITE_AUDIT_LLM_MARGIN_MULTIPLE = 1.5;
+var VIDEO_ANALYSIS_LLM_MARGIN_MULTIPLE = 1.5;
+var MEDIA_TRANSCRIBE_FLAT_MC = 2e4;
+var MEDIA_TRANSCRIBE_PER_MIN_MC = 200;
+function mediaTranscribeChargeMc(durationSecs) {
+  const mins = Math.max(1, Math.ceil((durationSecs || 60) / 60));
+  return MEDIA_TRANSCRIBE_FLAT_MC + MEDIA_TRANSCRIBE_PER_MIN_MC * mins;
+}
+var MEDIA_TRANSCRIBE_HOLD_MC = MEDIA_TRANSCRIBE_FLAT_MC + MEDIA_TRANSCRIBE_PER_MIN_MC * 30;
+var MC_PER_USD = SUBSCRIPTION_TIERS["price_1TmiHRS8aAcsk3TGwmSNfNIa"].credits_mc / SUBSCRIPTION_TIERS["price_1TmiHRS8aAcsk3TGwmSNfNIa"].monthly_usd;
+
+export {
+  MC_COSTS,
+  serpActualCostMc,
+  browserActiveCostMc,
+  BROWSER_OPEN_MIN_BALANCE_MC,
+  MC_PER_CREDIT,
+  USD_NANOS,
+  SCHEDULED_RUN_BASE_CREDITS,
+  SCHEDULED_RUN_BASE_MC,
+  SCHEDULED_AGENT_LLM_MARKUP_BPS,
+  SCHEDULED_AGENT_LLM_MARKUP,
+  SCHEDULED_RUN_DEFAULT_MAX_CREDITS,
+  CONNECTED_USAGE_RATE_POLICY_VERSION,
+  CONNECTED_ACTIVE_CONNECTION_MONTHLY_CREDITS,
+  CONNECTED_ACTIVE_CONNECTION_MONTHLY_MC,
+  CONNECTED_FUNCTION_RUN_CREDITS,
+  CONNECTED_PROXY_REQUEST_CREDITS,
+  CONNECTED_COMPUTE_CREDITS_PER_SECOND,
+  CONNECTED_FUNCTION_RUN_MC,
+  CONNECTED_USAGE_RATE_POLICY,
+  calculateConnectedUsageCharge,
+  vendorCostUsdToMc,
+  CREDIT_COST_CATALOG,
+  CONCURRENCY_PRICE_ID,
+  tierBillingInterval,
+  tierAmountChargedUsd,
+  tierCreditsPerInterval,
+  SUBSCRIPTION_TIERS,
+  SUBSCRIPTION_TIER_BY_KEY,
+  offerClaimPathForTier,
+  offerForTier,
+  tierChangeLeavesPrivateOffer,
+  getSubscriptionPlanView,
+  getPrivateOfferPayload,
+  getPublicRatesPayload,
+  concurrencySlotBillingInfo,
+  mcToCredits,
+  insufficientBalanceResponse,
+  MEMORY_PLANS,
+  MEMORY_PLAN_QUOTA,
+  LedgerOperation,
+  MEMORY_AI_MARGIN_MULTIPLE,
+  SITE_AUDIT_LLM_MARGIN_MULTIPLE,
+  VIDEO_ANALYSIS_LLM_MARGIN_MULTIPLE,
+  mediaTranscribeChargeMc,
+  MEDIA_TRANSCRIBE_HOLD_MC,
+  MC_PER_USD
+};
+//# sourceMappingURL=chunk-SBLGBZZB.js.map