{"id":27964,"date":"2026-11-14T03:34:32","date_gmt":"2026-11-14T03:34:32","guid":{"rendered":"https:\/\/capskip.com\/?p=27964"},"modified":"2026-11-14T03:34:32","modified_gmt":"2026-11-14T03:34:32","slug":"dramatiq-captcha-task","status":"publish","type":"post","link":"https:\/\/capskip.com\/zh\/dramatiq-captcha-task\/","title":{"rendered":"Dramatiq \u9a8c\u8bc1\u7801\u4efb\u52a1\uff1a\u6b63\u786e\u8bbe\u7f6e\u91cd\u8bd5\u548c\u65f6\u95f4\u9650\u5236"},"content":{"rendered":"<p>A dramatiq captcha actor goes wrong in three places, and all three come from how Dramatiq counts. Its time options are in milliseconds, its time limit cannot interrupt a socket that is waiting, and its retry rule counts every exception that leaves the actor. This guide puts the page fetch, the CapSkip solve and the form submission in one actor, then measures where the limit stops it and which failures deserve a retry. It runs on Windows with the StubBroker, so you need no Redis or RabbitMQ.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">What you need<\/h2>\n<ul>\n<li>A Windows PC running CapSkip with the reCAPTCHA solver on. The sample solves reCAPTCHA v2; the same shape fits the other types on the <a href=\"https:\/\/capskip.com\/python-captcha-solver\/\">Python CAPTCHA solver page<\/a>.<\/li>\n<li>Python 3.10 or later, the minimum that dramatiq 2.2.1 and capskip 1.7.0 declare. I ran everything on Python 3.11.7 and 3.14.0 with requests 2.34.2, and not on 3.10.<\/li>\n<li>No message broker. The StubBroker keeps the queue inside one process. I used neither Redis nor RabbitMQ, so nothing here describes a real broker unless a sentence says it came from the source.<\/li>\n<li>An address for CapSkip. On the same PC, the default 127.0.0.1 is enough. A worker on another PC needs Server mode, which makes CapSkip listen on your network or public IP, and you switch it on in the <a href=\"https:\/\/capskip.com\/setup-guide\/#connection-settings\">connection settings of the setup guide<\/a>.<\/li>\n<\/ul>\n<p>Testing: I wrote a mock CapSkip and a mock sign-up form, set the solve times of the mock myself, and used no real app or reCAPTCHA site. Every timing below is a mock timing. It shows how Dramatiq and the SDK behave around a solve, not how long a solve takes, and a failure the mock produces is my rule, not CapSkip behavior.<\/p>\n<p>Install the three packages into a fresh virtual environment:<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># Windows, in PowerShell or cmd\npython -m venv .venv\n.venv\\Scripts\\python -m pip install dramatiq capskip requests<\/pre>\n<\/div>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 1: the broker, and an SDK that can time out<\/h2>\n<p>Put this block at the top of tasks.py. The StubBroker line is the only broker-specific part; a real queue would build a RedisBroker or a RabbitmqBroker there. The patch exists because capskip 1.7.0 calls requests.post and requests.get with no timeout; I read api.py in the installed package. If CapSkip accepts a connection and never answers, the call waits as long as the operating system allows, and the time limit of Dramatiq can&#8217;t help. The patch swaps the requests reference inside capskip.api, an internal part of the SDK, and the block fails loudly at import if that reference disappears. The SDK ignores CAPSKIP_HOST, CAPSKIP_PORT and CAPSKIP_API_KEY unless your code reads them, so the block reads them and hands them to the constructor.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"python\" class=\"EnlighterJSRAW\"># tasks.py, part 1: put this at the top of tasks.py\nimport functools\nimport os\nimport types\n\nimport capskip.api\nimport dramatiq\nimport requests\nfrom capskip import ApiException, CapSkip, NetworkException, TimeoutException\nfrom dramatiq.brokers.stub import StubBroker\nfrom dramatiq.middleware import TimeLimitExceeded\n\n# The StubBroker keeps the queue inside this process, so it needs no Redis\n# or RabbitMQ. In production, build a RedisBroker or a RabbitmqBroker here\n# and pass it to dramatiq.set_broker the same way.\nbroker = StubBroker()\ndramatiq.set_broker(broker)\n\n# capskip 1.7.0 calls requests.post and requests.get with no timeout, and\n# time_limit cannot interrupt a socket that is waiting. Give every SDK call\n# 5 seconds to connect and 30 seconds of silence on a read.\nif not hasattr(capskip.api, &quot;requests&quot;):\n    raise RuntimeError(&quot;capskip changed how it makes HTTP calls: recheck this patch&quot;)\ncapskip.api.requests = types.SimpleNamespace(\n    RequestException=requests.RequestException,\n    post=functools.partial(requests.post, timeout=(5, 30)),\n    get=functools.partial(requests.get, timeout=(5, 30)),\n)\n\n# The SDK does not read these variables itself; this code passes them in.\nsolver = CapSkip(\n    apiKey=os.environ.get(&quot;CAPSKIP_API_KEY&quot;, &quot;capskip&quot;),\n    host=os.environ.get(&quot;CAPSKIP_HOST&quot;, &quot;127.0.0.1&quot;),\n    port=int(os.environ.get(&quot;CAPSKIP_PORT&quot;, &quot;8080&quot;)),\n)<\/pre>\n<\/div>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 2: the actor, with every time in milliseconds<\/h2>\n<p>The dramatiq captcha actor loads the page for its cookies, solves, and submits the form in one attempt. A CapSkip result is read once and a token goes stale after about two minutes (<a href=\"https:\/\/capskip.com\/recaptcha-token-expiration\/\">how long a reCAPTCHA token stays valid<\/a>), so a retry must start from the page.<\/p>\n<p>Every time option is in milliseconds: min_backoff here is 15 seconds and time_limit is 8 minutes. The 8 minutes is arithmetic: 300 seconds of SDK polling, a sleep of up to 5, and four HTTP calls that can each wait 5 seconds to connect and 30 seconds of silence on a read, about 445 seconds when CapSkip goes quiet.<\/p>\n<p>worth_retrying runs after every failed attempt. A failed solve arrives as an ApiException containing ERROR_CAPTCHA_UNSOLVABLE (<a href=\"https:\/\/capskip.com\/error-captcha-unsolvable\/\">what that error means<\/a>) and may work next time, as may an unreachable CapSkip, the timeout of the SDK, the limit of Dramatiq, and a 403, 408, 429 or 5xx answer from the form. A missing or malformed sitekey or page URL is refused when the task is submitted, with an ERROR_ code that does not contain UNSOLVABLE, and a wrong API key is refused the same way, so those end the message; so does a 4xx answer from the form other than the three above, which would come again, and so does a bug in your code. A well-formed but wrong sitekey may still arrive as ERROR_CAPTCHA_UNSOLVABLE and use all three retries; I could not test that against the real app.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"python\" class=\"EnlighterJSRAW\"># tasks.py, part 2: add this below part 1\nMAX_RETRIES = 3\n\n\ndef worth_retrying(retries_so_far, exc):\n    # Dramatiq calls this after every failed attempt. While retry_when is\n    # set, max_retries is ignored, so the count lives here.\n    if retries_so_far &gt;= MAX_RETRIES:\n        return False\n    if isinstance(exc, ApiException):\n        # CapSkip reports a solve that failed this way. A refused sitekey,\n        # page URL or API key would be refused again.\n        return &quot;ERROR_CAPTCHA_UNSOLVABLE&quot; in str(exc)\n    if isinstance(exc, requests.HTTPError):\n        # 403 and 429 can mean a refused or expired token, 5xx a site hiccup;\n        # a 404 or 400 would be answered the same way next time.\n        status = exc.response.status_code if exc.response is not None else 0\n        return status in (403, 408, 429) or status &gt;= 500\n    transient = (NetworkException, TimeoutException, TimeLimitExceeded, requests.RequestException)\n    return isinstance(exc, transient)\n\n\n@dramatiq.actor(\n    queue_name=&quot;captcha&quot;,\n    retry_when=worth_retrying,\n    min_backoff=15_000,  # milliseconds, not seconds\n    max_backoff=120_000,\n    time_limit=480_000,  # milliseconds as well: 8 minutes\n)\ndef sign_up(sitekey, page_url, email):\n    with requests.Session() as session:\n        session.get(page_url, timeout=(5, 30))  # picks up the page's cookies\n        # Solve inside the attempt, right before the form submission: a result is\n        # read once, and a token ages.\n        token = solver.recaptcha(sitekey=sitekey, url=page_url)[&quot;code&quot;]\n        reply = session.post(\n            page_url,\n            data={&quot;email&quot;: email, &quot;g-recaptcha-response&quot;: token},\n            headers={&quot;Referer&quot;: page_url},\n            timeout=(5, 30),\n        )\n        reply.raise_for_status()<\/pre>\n<\/div>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 3: run it with real worker threads and no broker<\/h2>\n<p>This script starts four Dramatiq worker threads in one process, sends a message and waits for the queue to drain. Save it as run_local.py next to tasks.py, replace YOUR_SITEKEY with the sitekey of a page you may automate, and pass the address of that page in PAGE_URL when you run it.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"python\" class=\"EnlighterJSRAW\"># run_local.py: real worker threads, no Redis or RabbitMQ\nimport os\n\nfrom dramatiq import Worker\n\nfrom tasks import broker, sign_up\n\n# The dramatiq command emits this event for you. It starts the thread\n# behind time_limit, so a script has to emit it itself.\nbroker.emit_after(&quot;process_boot&quot;)\nworker = Worker(broker, worker_threads=4)\nworker.start()\ntry:\n    sign_up.send(\n        &quot;YOUR_SITEKEY&quot;,\n        os.environ.get(&quot;PAGE_URL&quot;, &quot;https:\/\/example.com\/signup&quot;),\n        &quot;you@example.com&quot;,\n    )\n    # fail_fast=False: do not re-raise an actor's exception out of join\n    broker.join(&quot;captcha&quot;, fail_fast=False)\n    worker.join()\nfinally:\n    worker.stop()\nprint(&quot;dead-lettered messages:&quot;, len(broker.dead_letters))<\/pre>\n<\/div>\n<p>From the folder that holds tasks.py, in PowerShell:<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># PowerShell\n$env:PAGE_URL = &quot;https:\/\/your-page\/signup&quot;\n.venv\\Scripts\\python run_local.py<\/pre>\n<\/div>\n<p>In cmd, run set PAGE_URL=https:\/\/your-page\/signup and then the same python command.<\/p>\n<p>The emit_after line starts the watcher thread behind time_limit. The dramatiq command does that for you and a script must do it itself; without it a 2 second limit on a 6 second solve let the actor run 7.8 to 7.9 seconds. The join method of the broker in Dramatiq 2 also re-raises the exception of a dead-lettered message unless you pass fail_fast=False. Against the mock, one message ran, the form accepted one submission and the script printed 0 dead-lettered messages.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">What time_limit can and cannot interrupt<\/h2>\n<p>The TimeLimit middleware wakes a watcher thread once a second. For a message past its limit, the watcher asks CPython to raise TimeLimitExceeded in the worker thread, and it arrives the next time that thread runs Python code. A sleeping thread, or one waiting on a socket, is running none. The <a href=\"https:\/\/dramatiq.io\/guide.html\" rel=\"noopener nofollow\" target=\"_blank\">Dramatiq user guide<\/a> gives the default of 10 minutes, which already clears the arithmetic in Step 2.<\/p>\n<p>The SDK sleeps between status polls, up to 5 seconds, so a limit that fires mid-sleep takes effect only when the sleep ends (first two rows below). A silent CapSkip is worse (rows three and four). With the SDK as shipped the actor ran on until the stuck call returned, and only the Step 1 patch bounded it, at the 30 second read timeout. So time_limit holds only if every blocking call has a timeout of its own.<\/p>\n<p>TimeLimitExceeded derives from BaseException, so a handler for Exception does not catch it. A handler for BaseException does, and Dramatiq then counts a success (last row). Catch CapSkipError to log a failed solve.<\/p>\n<table>\n<thead>\n<tr>\n<th>Mock setup<\/th>\n<th>What happened<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>CapSkip never finishes, limit 3 s<\/td>\n<td>Stopped at 3.8 s or at 7.8 s, depending on where the one second tick of the watcher fell against the SDK sleeps (five to one in the runs I did across two Pythons)<\/td>\n<\/tr>\n<tr>\n<td>CapSkip never finishes, limit 8 s<\/td>\n<td>Stopped at about 12.9 s on both Pythons<\/td>\n<\/tr>\n<tr>\n<td>Status call silent for 25 s, no patch, limit 3 s<\/td>\n<td>Limit logged 3 to 4 s in, actor ran on to 25.0 s and never used the token in that reply<\/td>\n<\/tr>\n<tr>\n<td>Status call silent for 45 s, Step 1 patch, limit 3 s<\/td>\n<td>Stopped at 30.0 s<\/td>\n<\/tr>\n<tr>\n<td>Limit written as 330 (seconds habit), 6 s solve<\/td>\n<td>Each attempt stopped within 2 s; four solves wasted, then a dead letter<\/td>\n<\/tr>\n<tr>\n<td>Handler for BaseException around the solve<\/td>\n<td>Message counted as a success, no retry, no dead letter<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Which failures Dramatiq retries<\/h2>\n<p>The Retries middleware is on by default and its defaults are generous for a CAPTCHA. I read them from a running broker: 20 retries, a minimum backoff of 15 seconds, which makes the first retry wait 15 to 30 seconds, and a cap of 7 days. An actor with no options would retry a refused sitekey up to 20 times.<\/p>\n<p>The max_retries option counts retries, not attempts, and every exception that leaves the actor counts, TimeLimitExceeded included. Passing retry_when takes over completely, which is why worth_retrying keeps its own count. The actor option &quot;throws&quot; skips retries by class and logs an info line, but ApiException covers both a failed solve and a refused key, so the sample uses retry_when. When worth_retrying says no, the log still reads &quot;Retries exceeded for message&quot;; read the exception line above it.<\/p>\n<p>Each delay is min_backoff times 2 to the power of the retries so far, times a random factor from 1 to 2 and, if that passes max_backoff, drawn again between half and all of max_backoff. With 300 and 2000 the ranges are 300 to 600, 600 to 1200 and 1000 to 2000 milliseconds, and the delays I saw were 453, 896 and 1599 on Python 3.11 and 477, 1028 and 1219 on 3.14. Every retry is a fresh solve, and the abandoned attempt leaves a task in CapSkip that nobody reads: in the 330 row, four tasks were submitted and no token was read.<\/p>\n<table>\n<thead>\n<tr>\n<th>Mock setup<\/th>\n<th>What happened<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Sample actor, every solve fails<\/td>\n<td>4 solves, 3 retry lines, then &quot;Retries exceeded&quot; and a dead letter<\/td>\n<\/tr>\n<tr>\n<td>Sample actor, mock refuses the sitekey with an ERROR_ code (the mock&#8217;s rule)<\/td>\n<td>1 solve, no retry, dead-lettered<\/td>\n<\/tr>\n<tr>\n<td>Sample actor, form answers 404, 405 or 400 to every submission<\/td>\n<td>1 solve each time, no retry, dead-lettered<\/td>\n<\/tr>\n<tr>\n<td>Plain actor, max_retries of 3, raising the refused-key error<\/td>\n<td>4 runs of a request that could never work<\/td>\n<\/tr>\n<tr>\n<td>Site answers 403 to the first form submission<\/td>\n<td>2 solves, second token accepted<\/td>\n<\/tr>\n<tr>\n<td>Plain actor, throws set to ValidationException, raising it<\/td>\n<td>1 run, an info line, dead-lettered<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Workers on Windows: threads, stops and Server mode<\/h2>\n<p>The dramatiq command loads the module you name, so the broker line in tasks.py decides what a worker consumes. With the StubBroker a started worker just idles, since each process has its own queue; I used it only to check the command. By default it starts one process per logical processor with 8 threads each. This PC has 24, and the default printed 24 lines saying &quot;Worker process is ready for action&quot;: 192 threads that can each start a solve. CapSkip is set to run 10 reCAPTCHA solves at once by default (the Max. Threads setting; I did not run the app, so check your own value), and a task waiting inside CapSkip still uses up the time limit of the actor. Start with one process and ten threads:<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># From the folder that holds tasks.py: one process, ten threads\n.venv\\Scripts\\dramatiq tasks --processes 1 --threads 10<\/pre>\n<\/div>\n<p>Plan for the stop. I started the command with a slow mock solve and sent Ctrl+Break to it. The command exited under 2 seconds later with code 21. Six stops on the two Pythons gave the same result, two of them after the solve had finished, and the four unfinished solves were never read. The main process forwards the signal to its workers with os.kill, and <a href=\"https:\/\/docs.python.org\/3\/library\/os.html#os.kill\" rel=\"noopener nofollow\" target=\"_blank\">CPython documents<\/a> that on Windows os.kill ends a process outright for any signal number except the two console events, using the number as the exit code. 21 is that number. I did not test Ctrl+C or a service stop, so treat every stop as a kill of the running solve.<\/p>\n<p>Dramatiq acknowledges a message only after its actor finishes. In the source of the Redis broker, the unacknowledged messages of a dead worker go back onto the queue once its heartbeat is 60 seconds stale, the default. I read that and did not run it. Either way the message starts over from the page.<\/p>\n<p>For workers on another PC, switch CapSkip to Server mode, then set CAPSKIP_HOST (and CAPSKIP_API_KEY if API key validation is on) in the environment of the dramatiq command. Turning on Server mode opens the CapSkip port to any address, so block every machine that is not one of your workers with a Windows Firewall block rule. The solves still happen on your own Windows machine and cost nothing per solve.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Common Dramatiq CAPTCHA errors<\/h2>\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>&quot;Retries exceeded&quot; after one attempt<\/td>\n<td>worth_retrying refused a malformed sitekey, page URL or API key, or a 4xx answer from the form<\/td>\n<td>Read the exception above it, fix the input<\/td>\n<\/tr>\n<tr>\n<td>NetworkException on every attempt<\/td>\n<td>CapSkip is closed, or on 127.0.0.1 with the worker on another PC<\/td>\n<td>Start it, or use Server mode; see the <a href=\"https:\/\/capskip.com\/api-docs\/\">API documentation<\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\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;\">Is the StubBroker enough to test a Dramatiq CAPTCHA actor?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">For the logic of the actor itself, yes: retries, backoff, time limits and dead letters all ran here with real worker threads. It cannot show what a broker adds, such as redelivery after a worker dies.<\/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 workers on another machine reach CapSkip?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Yes, through Server mode. Run CapSkip on a Windows machine with a reachable address and set CAPSKIP_HOST in the environment of the workers. The actor is unchanged.<\/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;\">Does Dramatiq differ from Celery for this?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Dramatiq has one time limit, in milliseconds, whose error is a BaseException, and a retry rule that is a function you write. Late acknowledgement and prefetch are covered in the guide to <a href=\"https:\/\/capskip.com\/celery-captcha-task\/\">solving CAPTCHAs in a Celery task<\/a>.<\/p>\n<\/details>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">The short version<\/h2>\n<p>For a dramatiq captcha actor, keep the fetch, the solve and the form submission in one attempt, write every time in milliseconds, and give the HTTP calls of the SDK a timeout so time_limit can reach the thread. Retry a failed solve, a silent CapSkip or a refused form, and expect a Windows stop to kill a running solve. With a <a href=\"https:\/\/capskip.com\/\">local captcha solver<\/a> on your own hardware, a retry or a killed solve costs time and nothing more.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Dramatiq \u7684\u65f6\u95f4\u4ee5\u6beb\u79d2\u8ba1\uff0c\u5b83\u7684\u65f6\u95f4\u9650\u5236\u65e0\u6cd5\u6253\u65ad\u4e00\u4e2a\u6b63\u5728\u7b49\u5f85\u7684 socket\u3002\u8fd9\u91cc\u662f\u4e00\u4e2a\u91cd\u8bd5\u548c\u9650\u5236\u90fd\u7ba1\u7528\u7684 CapSkip actor\uff0c\u5728 Windows \u4e0a\u4e0d\u7528 broker \u6d4b\u8bd5\u8fc7\u3002<\/p>","protected":false},"author":1,"featured_media":27963,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"rank_math_title":"Dramatiq CAPTCHA Task: Retries and Time Limits | CapSkip","rank_math_description":"A dramatiq captcha actor on Windows: why time_limit fires late, which errors deserve a retry, and how to test it with no broker. Copy the actor.","rank_math_focus_keyword":"dramatiq captcha","footnotes":""},"categories":[70],"tags":[],"class_list":["post-27964","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\/27964","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=27964"}],"version-history":[{"count":1,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/27964\/revisions"}],"predecessor-version":[{"id":28147,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/27964\/revisions\/28147"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media\/27963"}],"wp:attachment":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media?parent=27964"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/categories?post=27964"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/tags?post=27964"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}