{"id":27962,"date":"2026-11-12T01:22:28","date_gmt":"2026-11-12T01:22:28","guid":{"rendered":"https:\/\/capskip.com\/?p=27962"},"modified":"2026-11-12T01:22:28","modified_gmt":"2026-11-12T01:22:28","slug":"puppeteer-cluster-captcha","status":"publish","type":"post","link":"https:\/\/capskip.com\/zh\/puppeteer-cluster-captcha\/","title":{"rendered":"puppeteer-cluster \u9a8c\u8bc1\u7801\uff1a\u6bcf\u4e2a\u4efb\u52a1\u4e00\u4e2a token"},"content":{"rendered":"<p>To solve a puppeteer-cluster captcha, call the solver inside the task function and keep the token in a local constant. A reCAPTCHA token works once, so one token shared between tasks can pass only one form. This guide builds that script with the capskip Node.js package, which talks to the CapSkip app on your own Windows PC under a flat license, then sets three limits: <code>maxConcurrency<\/code>, the cluster timeout and <code>retryLimit<\/code>. The single-page version is on the <a href=\"https:\/\/capskip.com\/puppeteer-captcha-solver\/\">Puppeteer CAPTCHA solver page<\/a>.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">What you need<\/h2>\n<ul>\n<li>CapSkip running on a Windows PC, reached by host and port (127.0.0.1 and 8080 by default). Server mode makes it listen on your network or public IP, so a cluster on another PC can use the same solver. The <a href=\"https:\/\/capskip.com\/setup-guide\/#connection-settings\">connection settings<\/a> switch between the two.<\/li>\n<li>Node.js 22.12 or later for Puppeteer 25.17.0 (its engines field), or Node.js 18 or later for Puppeteer 24.43.1. I ran Node 24.22.0 and 25.2.1 with the first and Node 20.11.1 and 24.22.0 with the second, not Node 18 or 22.<\/li>\n<li>puppeteer-cluster 0.25.0 (no engines field, peer range Puppeteer 24.0.0 or newer) and capskip 1.7.0 (Node 18 or later), the versions I ran.<\/li>\n<li>A page you may automate that shows a reCAPTCHA v2 checkbox.<\/li>\n<\/ul>\n<p>Check how recently the library was released. When I checked in November 2026, 0.25.0 (13 November 2025) was the latest release, master had no newer commit, and 112 issues and 16 pull requests were open. It is not archived, and the <a href=\"https:\/\/github.com\/thomasdondorf\/puppeteer-cluster\" rel=\"noopener nofollow\" target=\"_blank\">puppeteer-cluster README<\/a> shows whether that pace suits you.<\/p>\n<p>How the puppeteer-cluster captcha script was tested: not against the real CapSkip app or a real reCAPTCHA page. Every run used a mock of in.php and res.php that I wrote, plus a stand-in form site with a g-recaptcha div, a data-sitekey attribute and a hidden textarea named g-recaptcha-response. It is not the widget from Google. The rules are mine: one use per token, a token must match the sitekey of its page, and the form needs its CSRF cookie. The mock also refuses a sitekey that fails the shape rule I read in the CapSkip app source. Most runs used Chrome for Testing 156.0.8078.47 through PUPPETEER_EXECUTABLE_PATH, and the install block as written also worked with the Chrome that npm downloads (157.0.8103.50 for Puppeteer 25.17.0, 148.0.7778.97 for 24.43.1). npm 11 warns that puppeteer@25.17.0 has an install script not yet covered by allowScripts, but the download still happened. With install scripts off, the script stops with <code>Could not find Chrome<\/code>.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Build the script<\/h2>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Step 1: create the project and the settings<\/h3>\n<p>Create package.json first: with npm 11.19.1 on Windows, a folder without one got its packages in a parent folder.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># PowerShell. Make the folder and its package.json first: with no\r\n# package.json here, npm installs into the nearest parent folder that has one.\r\nmkdir captcha-cluster\r\ncd captcha-cluster\r\nnpm init -y\r\nnpm install puppeteer puppeteer-cluster capskip<\/pre>\n<\/div>\n<p>On Node.js 18 to 22.11, use <code>npm install puppeteer@24 puppeteer-cluster capskip<\/code> instead. The line above on Node 20.11.1 installed Puppeteer 25.17.0 with EBADENGINE warnings, and the script then died with <code>ERR_REQUIRE_ESM<\/code>.<\/p>\n<p>Next, start a file named cluster-solve.js. This block and the blocks in Steps 2 to 4 go into it in order, and nothing runs until the last one. The SDK reads none of the CAPSKIP variables on its own, so the script reads the host and port from them itself.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"js\" class=\"EnlighterJSRAW\">\/\/ cluster-solve.js: this block and the ones in Steps 2 to 4 go into one file.\r\nconst { Cluster } = require(&quot;puppeteer-cluster&quot;);\r\nconst { CapSkip, ApiException, ValidationException } = require(&quot;capskip&quot;);\r\n\r\nconst SOLVE_TIMEOUT = 90; \/\/ seconds the SDK waits for one token\r\nconst TASK_TIMEOUT = 150000; \/\/ milliseconds the cluster allows one whole task\r\nconst MAX_PAGES = 3; \/\/ tasks running at once, so also solves in flight\r\nconst RETRIES = 1; \/\/ extra attempts after a failed task\r\n\r\n\/\/ Local mode is 127.0.0.1. In Server mode, set CAPSKIP_HOST to your CapSkip PC.\r\nconst solver = new CapSkip({\r\n  host: process.env.CAPSKIP_HOST || &quot;127.0.0.1&quot;,\r\n  port: Number(process.env.CAPSKIP_PORT || 8080),\r\n  recaptchaTimeout: SOLVE_TIMEOUT,\r\n});\r\n\r\n\/\/ Comma separated addresses of the pages that show the widget.\r\nconst FORM_URLS = (process.env.FORM_URLS || &quot;https:\/\/example.com\/form\/1&quot;).split(&quot;,&quot;);\r\nconst outcomes = []; \/\/ one entry per task that finished without throwing<\/pre>\n<\/div>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Step 2: solve inside the task<\/h3>\n<p>Each task loads its page, reads the sitekey, asks CapSkip for a token for the address of that page, writes it into the hidden textarea and presses submit. On a real page that textarea appears once the script from Google has rendered the widget, which the solve time normally covers; I tested only a static one. If your site declares a data-callback, call it after writing the token; my stand-in has none, so I did not test that. The status 200 check suits only the stand-in; real sites often show the form again with an error at 200. The <a href=\"https:\/\/capskip.com\/recaptcha-v2-nodejs\/\">reCAPTCHA v2 in Node.js guide<\/a> covers the single-page flow.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"js\" class=\"EnlighterJSRAW\">async function submitWithToken(page, url, token) {\r\n  \/\/ Write the token into the widget's hidden textarea, then press submit.\r\n  await page.$eval(&quot;#g-recaptcha-response&quot;, (el, value) =&gt; { el.value = value; }, token);\r\n  const [response] = await Promise.all([\r\n    page.waitForNavigation({ waitUntil: &quot;domcontentloaded&quot; }),\r\n    page.click(&quot;button[type=submit]&quot;),\r\n  ]);\r\n  if (response.status() !== 200) {\r\n    throw new Error(`site answered ${response.status()} for ${url}`);\r\n  }\r\n  outcomes.push({ url, ok: true });\r\n}\r\n\r\nasync function solveForm({ page, data }) {\r\n  await page.goto(data.url, { waitUntil: &quot;domcontentloaded&quot; });\r\n  const sitekey = await page.$eval(&quot;.g-recaptcha&quot;, (el) =&gt; el.dataset.sitekey);\r\n\r\n  \/\/ The token is a local constant, so no other task can read or reuse it.\r\n  const { code: token } = await solver.recaptcha(sitekey, page.url());\r\n  await submitWithToken(page, data.url, token);\r\n}<\/pre>\n<\/div>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Step 3: retry only what a retry can fix<\/h3>\n<p><code>retryLimit<\/code> retries every error a task throws, so this wrapper checks the error type first. An ApiException saying ERROR_CAPTCHA_UNSOLVABLE means CapSkip could not solve that task, and a new one may work. Any other ApiException and any ValidationException come from your request or your limits, so the wrapper records them and ends the task. With default settings CapSkip refuses a missing or malformed sitekey at once (ERROR_GOOGLEKEY in the API docs), which ends in the wrapper; the setting that lists tasks with invalid data is off by default. The wrapper does not retry a no-slot refusal, because the cluster would retry at once into the same full queue: lower <code>maxConcurrency<\/code> instead. In the app source I read, a well-formed key that is wrong for the page is answered as unsolvable, so it is retried until <code>retryLimit<\/code> runs out.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"js\" class=\"EnlighterJSRAW\">\/\/ Decide from the error type whether a second attempt could end differently.\r\nfunction retryWouldHelp(err) {\r\n  if (err instanceof ValidationException) return false; \/\/ the arguments are wrong\r\n  if (err instanceof ApiException) return err.message.includes(&quot;ERROR_CAPTCHA_UNSOLVABLE&quot;);\r\n  return true; \/\/ timeouts, network trouble, a site that said no\r\n}\r\n\r\nasync function solveFormGuarded(job) {\r\n  try {\r\n    await solveForm(job);\r\n  } catch (err) {\r\n    if (retryWouldHelp(err)) throw err; \/\/ the cluster decides whether to retry\r\n    outcomes.push({ url: job.data.url, ok: false, error: err.message });\r\n  }\r\n}<\/pre>\n<\/div>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Step 4: launch the cluster and queue the pages<\/h3>\n<p>Chrome starts headless by default, as I saw on the command line of the launched browser.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"js\" class=\"EnlighterJSRAW\">(async () =&gt; {\r\n  const cluster = await Cluster.launch({\r\n    concurrency: Cluster.CONCURRENCY_CONTEXT, \/\/ a private cookie jar per task\r\n    maxConcurrency: MAX_PAGES,\r\n    timeout: TASK_TIMEOUT,\r\n    retryLimit: RETRIES,\r\n  });\r\n  \/\/ Without this listener a failed task gives no reason at all.\r\n  cluster.on(&quot;taskerror&quot;, (err, data, willRetry) =&gt; {\r\n    console.error(`${data.url}: ${err.message}${willRetry ? &quot; (will retry)&quot; : &quot;&quot;}`);\r\n  });\r\n\r\n  await cluster.task(solveFormGuarded);\r\n  for (const url of FORM_URLS) cluster.queue({ url });\r\n  await cluster.idle();\r\n  await cluster.close();\r\n\r\n  const accepted = outcomes.filter((o) =&gt; o.ok).length;\r\n  console.log(`${accepted} of ${FORM_URLS.length} forms accepted`);\r\n  for (const o of outcomes.filter((o) =&gt; !o.ok)) console.log(`gave up: ${o.url} ${o.error}`);\r\n  process.exitCode = accepted === FORM_URLS.length ? 0 : 1;\r\n})();<\/pre>\n<\/div>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># PowerShell, in the project folder. Name the pages, then run the script.\r\n$env:FORM_URLS = &quot;https:\/\/example.com\/form\/1,https:\/\/example.com\/form\/2&quot;\r\nnode cluster-solve.js<\/pre>\n<\/div>\n<p>Against the mock, eight forms, three pages and a 2 second mock solve gave 8 of 8 forms accepted and at most 3 solves at once. A solve took 3.8 seconds from submit to token, not 2, because the SDK polls at 0, 0.25, 0.75, 1.75 and 3.75 seconds. The other runtime setups matched, with no warning logged.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Why a puppeteer-cluster captcha token stays inside the task<\/h2>\n<p>The tempting shortcut is one variable above the task function, a shape the script leaves out.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"js\" class=\"EnlighterJSRAW\">\/\/ Do not add this. One variable shared by every task is the bug.\r\nlet sharedToken = null;\r\n\r\nasync function solveFormShared({ page, data }) {\r\n  await page.goto(data.url, { waitUntil: &quot;domcontentloaded&quot; });\r\n  const sitekey = await page.$eval(&quot;.g-recaptcha&quot;, (el) =&gt; el.dataset.sitekey);\r\n  if (!sharedToken) {\r\n    sharedToken = (await solver.recaptcha(sitekey, page.url())).code;\r\n  }\r\n  await submitWithToken(page, data.url, sharedToken);\r\n}<\/pre>\n<\/div>\n<p>In the mock, six forms gave 3 solves, 3 accepted forms and 6 refusals, retries included. The first three tasks see an empty variable and pass. Every later task reuses the token stored last, which belongs to another sitekey or is already used. The script as written made 8 solves for 8 forms with no refusal.<\/p>\n<p>The other trap is the cookie jar. The default mode, CONCURRENCY_CONTEXT, gives each task a private browser context, and CONCURRENCY_PAGE shares one. My stand-in sets a fresh CSRF cookie on every page load, so tasks that loaded earlier fail. Eight forms took 12 to 14 solves, 5 to 8 CSRF refusals and 6 or 7 accepted forms over 10 runs. A site with a stable cookie would not break.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Three limits that have to agree<\/h2>\n<p>In a puppeteer-cluster captcha script, the puppeteer-cluster <code>maxConcurrency<\/code> option caps the solves in flight, because each task makes one, and 0 means no limit. CapSkip has its own cap: the &quot;Max. Threads&quot; setting in the reCAPTCHA row of Settings, which defaults to 10. Extra tasks wait in its queue for up to &quot;Wait Timeout&quot; (250 seconds by default), and the SDK timeout includes that wait. In the mock with two solve slots and four pages, a 4 second solve took 7.8 seconds from submit to token with no wait and 12.8 with a wait for a slot, because the SDK takes a token at its first check after the solve ends, and it checks at about 3.8, 7.8 and 12.8 seconds. The queue is also short. The changelog says that since CapSkip 2.4.0 a reCAPTCHA task that arrives at a full queue is refused with a no-slot error, and in the app source I read the queue is as deep as &quot;Max. Threads&quot;. My mock applies that rule: with two solve slots, a queue of two and eight pages at once, 4 forms were accepted and 4 gave up with <code>ERROR_NO_SLOT_AVAILABLE<\/code>, while four pages were enough for 8 of 8. Keep <code>maxConcurrency<\/code> at or below &quot;Max. Threads&quot;, and remember that two clusters on one CapSkip share it. Each solve in flight also uses an IP address, and the setup guide says to give CapSkip at least as many proxies as &quot;Max. Threads&quot;.<\/p>\n<p>The puppeteer-cluster timeout has to exceed the SDK wait plus the page work. The cluster default is 30 seconds, and the SDK waits 300 for reCAPTCHA unless you set <code>recaptchaTimeout<\/code>. With the timeout option removed and a 40 second mock solve, <code>Timeout hit: 30000<\/code> appeared about 31 seconds after the script started, but the process exited at about 44, because the abandoned task kept polling. A 3 second SDK limit fired at 3.8 seconds, because the SDK looks at its deadline only between polls.<\/p>\n<p>A timeout does not stop the solve. In the mock, with a 12 second solve, four forms, two pages and one retry, a cluster timeout of 5 seconds gave 8 solves for 4 forms, up to 6 in flight against 2 pages, and 8 tokens delivered to tasks that had already failed. An SDK wait of 3 with a cluster timeout of 9 gave <code>timeout 3 exceeded<\/code> and still 8 solves. Whether a real CapSkip drops a solve that nobody polls is unmeasured here. The setup guide says a solve that outlives its &quot;Row Timeout&quot; (250 seconds for reCAPTCHA) is stopped, and in the app source I read I found no code that cancels a job when polling stops (read, not run).<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Errors, <code>retryLimit<\/code> and silent failures<\/h2>\n<p>The puppeteer-cluster <code>retryLimit<\/code> counts extra attempts: 1 means two attempts, 2 means three. A page the mock refused once as unsolvable was accepted on the retry, and with <code>retryLimit<\/code> 0 it failed and the exit code was 1.<\/p>\n<p>Without Step 3, errors that retries cannot fix are retried anyway. At <code>retryLimit<\/code> 2 a malformed sitekey took three attempts, and so did an unsupported option, which the SDK reports as a ValidationException. With the wrapper each took one. A well-formed key that the mock always reported unsolvable still took all three.<\/p>\n<p><code>cluster.execute()<\/code> skips the retry rules that <code>retryLimit<\/code> sets: on the unsolvable-once page at <code>retryLimit<\/code> 2 it rejected after one attempt, while <code>cluster.queue()<\/code> retried. A failing queued task is also silent: with no <code>taskerror<\/code> listener and no DEBUG variable, a failed run printed only the summary. Setting <code>DEBUG=puppeteer-cluster:log<\/code> printed a line per failure.<\/p>\n<table>\n<thead>\n<tr>\n<th>What you see<\/th>\n<th>Cause<\/th>\n<th>Fix<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>Timeout hit: 30000<\/code><\/td>\n<td>The cluster default ended the task while CapSkip was still solving<\/td>\n<td>Set the cluster timeout above the SDK wait<\/td>\n<\/tr>\n<tr>\n<td><code>timeout 90 exceeded<\/code><\/td>\n<td>The SDK stopped waiting for a token<\/td>\n<td>Measure solves on your PC, then raise both timeouts<\/td>\n<\/tr>\n<tr>\n<td><code>ERROR_GOOGLEKEY<\/code><\/td>\n<td>The sitekey is missing or not shaped like a reCAPTCHA key<\/td>\n<td>Check the selector that reads the sitekey; do not retry<\/td>\n<\/tr>\n<tr>\n<td><code>ERROR_NO_SLOT_AVAILABLE<\/code><\/td>\n<td>More tasks reached CapSkip than its queue holds<\/td>\n<td>Set <code>maxConcurrency<\/code> at or below &quot;Max. Threads&quot;<\/td>\n<\/tr>\n<tr>\n<td><code>ERROR_PAGEURL<\/code><\/td>\n<td>The page address is missing or is not an http or https address<\/td>\n<td>Pass the address of the loaded page; do not retry<\/td>\n<\/tr>\n<tr>\n<td><code>connect ECONNREFUSED 127.0.0.1:12999<\/code><\/td>\n<td>Nothing listens on that port<\/td>\n<td>Start CapSkip and check the host and port<\/td>\n<\/tr>\n<tr>\n<td>The site rejects most submissions (my stand-in answers 403; yours may answer 200 with an error page)<\/td>\n<td>A shared token or a shared cookie jar<\/td>\n<td>Keep the token local; use the default mode<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Using CapSkip on a server<\/h2>\n<p>A puppeteer-cluster captcha script needs only a host and a port. Local mode listens on 127.0.0.1, so the cluster must run on that PC. Server mode listens on your network or public IP, and you set CAPSKIP_HOST to that Windows PC. I tested only 127.0.0.1. Server mode starts with CapSkip allowing its port from any address, and an allow rule of your own would not narrow that, so add a Windows Firewall block rule for the addresses that should stay out.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">FAQ<\/h2>\n<details style=\"border:1px solid #e2e5ee;border-radius:10px;padding:14px 18px;margin:0 0 12px;\">\n<summary style=\"cursor:pointer;\">\n<h3 style=\"font-size:1.15rem;line-height:1.4;display:inline;margin:0;\">Does puppeteer-cluster work with the current Puppeteer?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">The script ran on Puppeteer 25.17.0 and 24.43.1. If you would rather not manage a pool yourself, the <a href=\"https:\/\/capskip.com\/crawlee-captcha\/\">Crawlee guide<\/a> covers a crawler with its own concurrency and retries.<\/p>\n<\/details>\n<details style=\"border:1px solid #e2e5ee;border-radius:10px;padding:14px 18px;margin:0 0 12px;\">\n<summary style=\"cursor:pointer;\">\n<h3 style=\"font-size:1.15rem;line-height:1.4;display:inline;margin:0;\">Can I solve every page first and run the cluster afterwards?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Not safely. The <a href=\"https:\/\/developers.google.com\/recaptcha\/docs\/verify\" rel=\"noopener nofollow\" target=\"_blank\">reCAPTCHA verification docs<\/a> say a token lives two minutes and works once, so one made before its task reaches a free page may be stale. Ask inside the task, as the script does.<\/p>\n<\/details>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">The short version<\/h2>\n<p>A puppeteer-cluster captcha script comes down to one solve per task, a token kept in a local constant, and limits that agree: <code>maxConcurrency<\/code> at or below what CapSkip solves at once, a cluster timeout longer than the SDK wait, and retries only for errors a retry can fix. CapSkip is a local <a href=\"https:\/\/capskip.com\/\">captcha solver<\/a> on a flat license, so a retry costs time on your own PC and no per-solve fee. The same package solves more than reCAPTCHA, and the <a href=\"https:\/\/capskip.com\/nodejs-captcha-solver\/\">Node.js CAPTCHA solver page<\/a> shows which types.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>\u4e00\u4e2a token \u53ea\u80fd\u7528\u4e00\u6b21\uff0c\u6240\u4ee5\u5728\u4efb\u52a1\u4e4b\u95f4\u5171\u7528\u4e00\u4e2a\u4f1a\u5931\u8d25\u3002\u8fd9\u4e2a\u811a\u672c\u5728\u6bcf\u4e2a puppeteer-cluster \u4efb\u52a1\u91cc\u5411 CapSkip \u8bf7\u6c42 token\uff0c\u5e76\u8bbe\u7f6e\u597d\u9650\u5236\uff0c\u8ba9\u91cd\u8bd5\u4e0d\u4f1a\u5806\u79ef\u3002<\/p>","protected":false},"author":1,"featured_media":27961,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"rank_math_title":"puppeteer-cluster CAPTCHA: One Solve Per Task | CapSkip","rank_math_description":"Solve a puppeteer-cluster captcha with one CapSkip solve per task. Keep each token in its page and align maxConcurrency, timeout and retryLimit. Copy it.","rank_math_focus_keyword":"puppeteer-cluster captcha","footnotes":""},"categories":[70],"tags":[],"class_list":["post-27962","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-captcha"],"_links":{"self":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/27962","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/comments?post=27962"}],"version-history":[{"count":1,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/27962\/revisions"}],"predecessor-version":[{"id":28058,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/27962\/revisions\/28058"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media\/27961"}],"wp:attachment":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media?parent=27962"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/categories?post=27962"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/tags?post=27962"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}