{"id":26050,"date":"2026-09-24T10:47:38","date_gmt":"2026-09-24T10:47:38","guid":{"rendered":"https:\/\/capskip.com\/?p=26050"},"modified":"2026-09-24T10:47:38","modified_gmt":"2026-09-24T10:47:38","slug":"friendly-captcha-csharp","status":"publish","type":"post","link":"https:\/\/capskip.com\/zh\/friendly-captcha-csharp\/","title":{"rendered":"\u5982\u4f55\u5728 C# \u4e2d\u8bc6\u522b Friendly Captcha\uff08v1 \u4e0e v2 \u5c0f\u7ec4\u4ef6\uff09"},"content":{"rendered":"<p>To solve Friendly Captcha in C#, call FriendlyCaptchaAsync with the sitekey, the page URL and the widget version, then post the token into the form field that version expects. The version is the whole job. Friendly Captcha ships two different protocols under one name, and they share one sitekey namespace, so nothing in the key tells you which one a site runs. Solve the wrong one and you get a well-formed token that the site rejects without saying why. CapSkip added Friendly Captcha in version 1.4.0. This guide covers telling the two apart, the call, and the submit.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">What you need<\/h2>\n<ul>\n<li>CapSkip 1.4.0 or later running on a Windows machine. Friendly Captcha support arrived in that release, alongside CaptchaFox and Capy Puzzle.<\/li>\n<li>Version 1.3.0 or later of the CapSkip .NET package, which is the release that added FriendlyCaptchaAsync. It targets .NET Standard 2.0, so .NET Framework 4.6.1 and up, .NET Core 2.0 and up, and .NET 6 and later all work. The samples use top-level statements, so run them on .NET 6 or later.<\/li>\n<li>Three values from the target page: the sitekey on the widget element, the URL of the page itself, and the address of the widget script the page loads. Step 1 shows where each one lives.<\/li>\n<li>An address for the solver. Local mode answers on 127.0.0.1 for that device only; Server mode listens on your network address or public IP so another box can call it over the API. Both live under <a href=\"https:\/\/capskip.com\/setup-guide\/#connection-settings\">connection settings<\/a>, and Step 4 covers which one you want.<\/li>\n<\/ul>\n<div data-no-translation>\n<pre data-enlighter-language=\"bash\" class=\"EnlighterJSRAW\"># dotnet add package CapSkip\r\ndotnet add package CapSkip<\/pre>\n<\/div>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 1: tell Friendly Captcha v1 from v2<\/h2>\n<p>Both versions render the same element, a div with the class frc-captcha and a data-sitekey attribute. So the element tells you where the sitekey is and nothing about the protocol. The script tag that loads the widget is what gives it away, because v1 and v2 are different packages with different file names.<\/p>\n<table>\n<thead>\n<tr>\n<th>What to compare<\/th>\n<th>Version 1<\/th>\n<th>Version 2<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Package the page loads<\/td>\n<td>friendly-challenge<\/td>\n<td>@friendlycaptcha\/sdk<\/td>\n<\/tr>\n<tr>\n<td>Script file<\/td>\n<td>widget.module.min.js, with widget.min.js as the fallback<\/td>\n<td>site.min.js, with site.compat.min.js as the fallback<\/td>\n<\/tr>\n<tr>\n<td>Form field the token goes in<\/td>\n<td>frc-captcha-solution<\/td>\n<td>frc-captcha-response<\/td>\n<\/tr>\n<tr>\n<td>What a token looks like<\/td>\n<td>Four parts separated by dots, a few hundred characters long<\/td>\n<td>One opaque string that starts with AQQA and a dot, roughly six kilobytes<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>View the page source, search for frc-captcha to find the element, then read the script tags that load it. Friendly Captcha documents the same check on <a href=\"https:\/\/developer.friendlycaptcha.com\/docs\/v2\/versions\" rel=\"nofollow noopener\" target=\"_blank\">its own page about the two versions<\/a>. If the site self-hosts the widget, the package name can disappear from the URL, so go by the file name instead. Do not guess from the age of the site: both versions are live, and Friendly Captcha says it will keep maintaining v1 for several years.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 2: the FriendlyCaptchaAsync call<\/h2>\n<p>One method, three arguments: the sitekey, the page URL, and an options dictionary. Pass the version you found in Step 1.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"csharp\" class=\"EnlighterJSRAW\">\/\/ dotnet add package CapSkip\r\nusing CapSkip;\r\n\r\nvar solver = new CapSkipClient(host: &quot;127.0.0.1&quot;, port: 8080);\r\n\r\n\/\/ Tell the solver which protocol the site runs.\r\nvar result = await solver.FriendlyCaptchaAsync(\r\n    &quot;YOUR_SITEKEY&quot;,\r\n    &quot;https:\/\/example.com\/signup&quot;,\r\n    new Dictionary&lt;string, object?&gt; { [&quot;version&quot;] = &quot;v2&quot; });\r\n\r\nConsole.WriteLine(result.Token);   \/\/ goes in frc-captcha-response<\/pre>\n<\/div>\n<p>The version option takes v1 or v2, and a bare 1 or 2 works too. The SDK refuses any other value with a ValidationException before a request is made. That is deliberate: a guess would come back as a valid-looking token that the site throws away, which is worse than an error. A null version is not refused, though. It is dropped, and the solver falls back to v1 as described below.<\/p>\n<p>Read the Token property. The Code property carries the same string, but Token is named for the field it goes into. The user agent stays null here, since only Turnstile and CaptchaFox report one.<\/p>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Letting the script address decide the version<\/h3>\n<p>If your code already has the address of the widget script, pass that instead and CapSkip reads the version off the build the site actually loads, which is the most reliable signal there is. The solver checks in a fixed order and stops at the first answer: the version option, then the script address, then a default of v1.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"csharp\" class=\"EnlighterJSRAW\">\/\/ Instead of the call above: copy the src straight off the page's module script tag.\r\nvar result = await solver.FriendlyCaptchaAsync(\r\n    &quot;YOUR_SITEKEY&quot;,\r\n    &quot;https:\/\/example.com\/signup&quot;,\r\n    new Dictionary&lt;string, object?&gt;\r\n    {\r\n        [&quot;module_script&quot;] =\r\n            &quot;https:\/\/cdn.jsdelivr.net\/npm\/@friendlycaptcha\/sdk@0.1.6\/site.min.js&quot;,\r\n    });<\/pre>\n<\/div>\n<p>The nomodule_script option does the same job with the fallback script, if that is the one you have. Watch the last step of that order, though. With neither a version nor a script address, the solver assumes v1, so a v2 site solved with a bare sitekey fails exactly the way this whole guide warns about.<\/p>\n<h3 style=\"font-size:1.3rem;line-height:1.4;\">Sites on the EU endpoint<\/h3>\n<p>Friendly Captcha sells a data residency option that serves puzzles from Germany only. A v2 widget on that service carries a data-api-endpoint attribute, usually set to eu, and when you see it, pass the same value as the api_server option. That option takes global, the default, eu, or a full URL. Both endpoints will mint a token for the same sitekey, so getting this wrong is caught only by the site&#8217;s own verification, which is the silent kind of failure again.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 3: post the token into the right field<\/h2>\n<p>The field name is the second thing that catches people, usually right after a working v1 integration gets pointed at a v2 site. The widget writes its token into a hidden input, and your request has to put it in the same place.<\/p>\n<div data-no-translation>\n<pre data-enlighter-language=\"csharp\" class=\"EnlighterJSRAW\">\/\/ version holds what you passed in Step 2; http is your HttpClient.\r\n\/\/ v1 reads frc-captcha-solution, v2 reads frc-captcha-response.\r\nvar isV2 = version is &quot;v2&quot; or &quot;V2&quot; or &quot;2&quot;;\r\nvar field = isV2 ? &quot;frc-captcha-response&quot; : &quot;frc-captcha-solution&quot;;\r\n\r\nvar body = new FormUrlEncodedContent(new Dictionary&lt;string, string&gt;\r\n{\r\n    [&quot;email&quot;] = &quot;someone@example.com&quot;,\r\n    [field] = result.Token!,\r\n});\r\n\r\nvar response = await http.PostAsync(&quot;https:\/\/example.com\/signup&quot;, body);<\/pre>\n<\/div>\n<p>Two details on top of that. A site can rename the field with an attribute on the widget element, data-form-field-name on v2 and data-solution-field-name on v1, so check for it and use its value if it is there. And some integrations send the token in a JSON body rather than a form post, so open DevTools, submit the form once by hand, and mirror exactly what the page sends.<\/p>\n<p>Size matters with v2. A token of about six kilobytes is fine in a POST body, but it can overrun a server&#8217;s query string limit or be cut off by a narrow database column, and a truncated token fails verification like a wrong one. Keep it whole and send it once. Friendly Captcha&#8217;s verification rejects a response that has expired or has already been used, in both versions, so a token is good for one submit and should go out promptly.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Step 4: timeouts, and where the solver runs<\/h2>\n<p>Friendly Captcha is proof of work, but it is not the millisecond kind. The service decides how much work each request is worth at the moment it is made, and it raises that figure for addresses it has already seen a lot of. CapSkip also solves every v2 widget in a real browser. So the method runs on the longer reCAPTCHA polling timeout, not the default one.<\/p>\n<table>\n<thead>\n<tr>\n<th>Constructor option<\/th>\n<th>Default<\/th>\n<th>What it covers<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>recaptchaTimeout<\/td>\n<td>300 seconds<\/td>\n<td>Friendly Captcha, CaptchaFox, reCAPTCHA and GeeTest polling<\/td>\n<\/tr>\n<tr>\n<td>defaultTimeout<\/td>\n<td>120 seconds<\/td>\n<td>Image, ALTCHA and Capy polling<\/td>\n<\/tr>\n<tr>\n<td>pollingInterval<\/td>\n<td>5 seconds maximum<\/td>\n<td>Polling starts at 0.25 seconds and backs off to this<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>If solves get slower over a long run, that rising difficulty is the likely reason, and more addresses are the fix. The method accepts a per-request proxy, and a proxy pool configured in CapSkip spreads the load for you. Both are worth having sooner here than for most types.<\/p>\n<p>The samples use 127.0.0.1 because that is right when your code and the solver share a machine. Once the calling code runs anywhere else, such as a container, a build agent or a VPS, loopback points at the wrong box and the first solve throws a NetworkException. Switch CapSkip to Server mode and it listens on your network address or public IP instead, so any of those can reach it over the API. Use a static public IP if the route crosses the internet, with a firewall rule for the addresses you expect. It is still your hardware, and it is still unmetered.<\/p>\n<p>The client does not read environment variables by itself. Read CAPSKIP_HOST in your own code and pass it to the constructor, as the full example does, so one build works on your desk and on a server.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Full working example<\/h2>\n<div data-no-translation>\n<pre data-enlighter-language=\"csharp\" class=\"EnlighterJSRAW\">\/\/ dotnet add package CapSkip\r\nusing System.Text.RegularExpressions;\r\nusing CapSkip;\r\n\r\nvar pageUrl = &quot;https:\/\/example.com\/signup&quot;;\r\nvar http = new HttpClient();\r\nvar solver = new CapSkipClient(\r\n    host: Environment.GetEnvironmentVariable(&quot;CAPSKIP_HOST&quot;) ?? &quot;127.0.0.1&quot;,\r\n    port: 8080);\r\n\r\n\/\/ Read the sitekey off the widget element, in either attribute order.\r\nvar html = await http.GetStringAsync(pageUrl);\r\nvar widget = Regex.Match(html,\r\n    &quot;&lt;[^&gt;]*class=\\&quot;(?:[^\\&quot;]*\\\\s)?frc-captcha(?:\\\\s[^\\&quot;]*)?\\&quot;[^&gt;]*&gt;&quot;).Value;\r\nvar sitekey = Regex.Match(widget, &quot;data-sitekey=\\&quot;([^\\&quot;]+)\\&quot;&quot;).Groups[1].Value;\r\n\r\n\/\/ The package name in the script URL decides the version.\r\nvar v2 = html.Contains(&quot;@friendlycaptcha\/sdk&quot;);\r\nvar v1 = html.Contains(&quot;friendly-challenge&quot;);\r\nif (v1 == v2)\r\n    throw new InvalidOperationException(&quot;Read the script tag and set the version by hand.&quot;);\r\nvar version = v2 ? &quot;v2&quot; : &quot;v1&quot;;\r\n\r\ntry\r\n{\r\n    var result = await solver.FriendlyCaptchaAsync(sitekey, pageUrl,\r\n        new Dictionary&lt;string, object?&gt; { [&quot;version&quot;] = version });\r\n\r\n    \/\/ A site can rename the field on the widget element.\r\n    var renamed = Regex.Match(widget,\r\n        &quot;data-(?:form|solution)-field-name=\\&quot;([^\\&quot;]+)\\&quot;&quot;).Groups[1].Value;\r\n    var field = renamed.Length &gt; 0 ? renamed\r\n        : v2 ? &quot;frc-captcha-response&quot; : &quot;frc-captcha-solution&quot;;\r\n    var body = new FormUrlEncodedContent(new Dictionary&lt;string, string&gt;\r\n    {\r\n        [&quot;email&quot;] = &quot;someone@example.com&quot;,\r\n        [field] = result.Token!,\r\n    });\r\n\r\n    \/\/ Post wherever the form's action attribute points.\r\n    var response = await http.PostAsync(pageUrl, body);\r\n    Console.WriteLine($&quot;{(int)response.StatusCode} with a {version} token&quot;);\r\n}\r\ncatch (CapSkip.ValidationException ex)\r\n{\r\n    \/\/ An empty sitekey or an unknown version, refused before any request.\r\n    Console.WriteLine($&quot;not sent: {ex.Message}&quot;);\r\n}\r\ncatch (CapSkip.TimeoutException)\r\n{\r\n    Console.WriteLine(&quot;gave up waiting; recaptchaTimeout is 300 seconds&quot;);\r\n}<\/pre>\n<\/div>\n<p>The version is decided once and used twice, for the solve and for the field name, so the two can never disagree. When the regex finds nothing, the widget was usually built from JavaScript rather than written into the HTML, and you need to read the sitekey from the rendered page or from the script that creates it. The raw endpoint behind this method, with every parameter it accepts, is documented in <a href=\"https:\/\/capskip.com\/api-docs\/#friendlycaptcha\">the API reference<\/a>, and every other method the package exposes is listed on <a href=\"https:\/\/capskip.com\/csharp-captcha-solver\/\">the C# CAPTCHA solver page<\/a>.<\/p>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">Common errors and what they mean<\/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>The site rejects a token that CapSkip returned as solved<\/td>\n<td>The wrong version was solved, often the v1 default applied to a v2 site<\/td>\n<td>Read the script tag and pass the version, or pass the script address<\/td>\n<\/tr>\n<tr>\n<td>The site rejects the token although the version is right<\/td>\n<td>It went into the other version&#8217;s field, or the site renamed the field<\/td>\n<td>Use the field for that version, or the name in data-form-field-name on v2 or data-solution-field-name on v1<\/td>\n<\/tr>\n<tr>\n<td>The site rejects the token and the widget has data-api-endpoint set<\/td>\n<td>The site runs on a regional endpoint and the solve used the default one<\/td>\n<td>Pass the attribute&#8217;s value as the api_server option<\/td>\n<\/tr>\n<tr>\n<td>A ValidationException before anything is sent<\/td>\n<td>The sitekey or page URL was empty, the version was not v1, v2, 1 or 2, or the options held a key the method does not take<\/td>\n<td>Check the regex found the element, fix the version value, and drop the unknown option<\/td>\n<\/tr>\n<tr>\n<td>No frc-captcha element in the HTML you downloaded<\/td>\n<td>The page creates the widget from JavaScript<\/td>\n<td>Read the sitekey from the rendered page or from the script that builds it<\/td>\n<\/tr>\n<tr>\n<td>A token that worked once fails on the second submit<\/td>\n<td>Friendly Captcha accepts each response once, and responses expire<\/td>\n<td>Solve fresh for every submit, and submit straight away<\/td>\n<\/tr>\n<tr>\n<td>Solves that get slower as a long run goes on<\/td>\n<td>The service raises the work for an address it has seen a lot of<\/td>\n<td>Spread the solves across a proxy pool<\/td>\n<\/tr>\n<tr>\n<td>A NetworkException on the first solve<\/td>\n<td>CapSkip is not running, or the host and port are wrong<\/td>\n<td>Start CapSkip, then check whether it should be in Local mode or Server mode<\/td>\n<\/tr>\n<tr>\n<td>The build fails on an ambiguous TimeoutException<\/td>\n<td>CapSkip and System both define that short name<\/td>\n<td>Write CapSkip.TimeoutException in full, or catch CapSkipError<\/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;\">Do I need a browser on my side to solve Friendly Captcha in C#?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">No. Your code needs an HttpClient and nothing else. CapSkip does the work on the machine it runs on, and for v2 that means running the widget in a real browser there, which is part of why the method uses the longer timeout. Your side sends a sitekey, a URL and a version, and gets back a string to post, so it runs happily inside a worker service or a scheduled job.<\/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;\">How is this different from solving ALTCHA?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Both are proof of work, and that is where the likeness ends. With ALTCHA you hand over the challenge or the endpoint it comes from, the hashing takes milliseconds, and the method runs on the 120 second default timeout. With Friendly Captcha the service sets the difficulty per request and raises it for busy addresses, v2 solves in a browser, and the method runs on the 300 second timeout. ALTCHA also has one field name where Friendly Captcha has two. The ALTCHA side is covered in <a href=\"https:\/\/capskip.com\/altcha-csharp\/\">the C# ALTCHA guide<\/a>.<\/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 a .NET app on a hosted platform reach the solver?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Yes. Switch CapSkip to Server mode under connection settings so it listens on a network address instead of loopback, read that address from CAPSKIP_HOST in your code, and pass it to the client. A container host, a VPS, a CI agent and a managed app service all connect the same way, over the same HTTP API. Use a static public IP with a firewall rule if the route crosses the internet. The solver stays on hardware you own, so nothing about the licence or the solve count changes.<\/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 a batch of tokens ahead of time?<\/h3>\n<\/summary>\n<p style=\"margin:12px 0 0;\">Not usefully. Each response is accepted once and expires, and Friendly Captcha reports both cases back to the site as failures. A stockpile turns into a pile of rejections. Solve when you are about to submit, and let concurrency do the work instead: the client is async, so a Task.WhenAll over several solves runs them side by side.<\/p>\n<\/details>\n<h2 style=\"font-size:1.6rem;line-height:1.35;\">The short version<\/h2>\n<p>To solve Friendly Captcha in C#, find the widget script, decide v1 or v2 from it, and pass that version to FriendlyCaptchaAsync with the sitekey and page URL. Put the token in frc-captcha-solution for v1 or frc-captcha-response for v2, unless the site renamed the field, and send it once, straight away. Match the EU endpoint if the widget uses it, expect solves to take seconds rather than milliseconds, and switch to Server mode as soon as the calling code leaves the solver&#8217;s machine.<\/p>\n<ul>\n<li>How the type works and what the solver covers: <a href=\"https:\/\/capskip.com\/friendly-captcha-solver\/\">the Friendly Captcha solver page<\/a>.<\/li>\n<li>Every other method the .NET package exposes: <a href=\"https:\/\/capskip.com\/csharp-captcha-solver\/\">the C# and .NET solver page<\/a>.<\/li>\n<\/ul>\n<p>One last thing that shapes how you retry. When a token comes back rejected, the honest fix is almost always a fresh solve with the right version, and with a <a href=\"https:\/\/capskip.com\/\">local captcha solver<\/a> that retry costs a few seconds on a machine you already own rather than another line on somebody&#8217;s invoice.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Friendly Captcha ships two protocols under one name and one sitekey namespace, and solving the wrong one gets you a token the site quietly rejects. Here is how to tell them apart in C#, the call, and the field each token goes in.<\/p>","protected":false},"author":1,"featured_media":26049,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"rank_math_title":"Solve Friendly Captcha in C# (.NET SDK) | CapSkip","rank_math_description":"To solve friendly captcha in c# you need the widget version first: v1 and v2 share sitekeys but not tokens. Read the script tag, then post the token back.","rank_math_focus_keyword":"solve friendly captcha in c#","footnotes":""},"categories":[70],"tags":[],"class_list":["post-26050","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\/26050","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=26050"}],"version-history":[{"count":1,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/26050\/revisions"}],"predecessor-version":[{"id":26053,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/posts\/26050\/revisions\/26053"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media\/26049"}],"wp:attachment":[{"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/media?parent=26050"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/categories?post=26050"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/capskip.com\/zh\/wp-json\/wp\/v2\/tags?post=26050"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}