# Get Stats (/docs/api/get-stats)



import { APIPage, APIContent, APICode } from '@/components/api-layout';
import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
import { ResponseTabs } from '@/components/response-tabs';
import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';

<APIPage>
  <APIContent>
    ## Endpoint

    <DynamicCodeBlock
      lang="bash"
      code="GET https://api.captcha.fun/v1/stats"
      codeblock={{
  allowCopy: true,
}}
    />

    ## Request Headers

    | Header    | Type   | Required | Description  |
    | --------- | ------ | -------- | ------------ |
    | `API_KEY` | string | Yes      | Your API key |

    ## Response Fields

    | Field      | Type    | Description                      |
    | ---------- | ------- | -------------------------------- |
    | `credits`  | integer | Remaining credits on the account |
    | `success`  | integer | Number of successful solves      |
    | `failures` | integer | Number of failed solves          |
  </APIContent>

  <APICode>
    ### Request Example

    <Tabs items={['curl', 'Python', 'JavaScript', 'Go', 'Java', 'C#']}>
      <Tab value="curl">
        ```bash
        curl -X GET https://api.captcha.fun/v1/stats \
          -H "API_KEY: CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
        ```
      </Tab>

      <Tab value="Python">
        ```python
        import requests

        response = requests.get(
            "https://api.captcha.fun/v1/stats",
            headers={
                "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
            }
        )

        print(response.json())
        ```
      </Tab>

      <Tab value="JavaScript">
        ```javascript
        const response = await fetch("https://api.captcha.fun/v1/stats", {
          method: "GET",
          headers: {
            "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
          }
        });

        const data = await response.json();
        console.log(data);
        ```
      </Tab>

      <Tab value="Go">
        ```go
        package main

        import (
            "encoding/json"
            "fmt"
            "net/http"
        )

        func main() {
            req, _ := http.NewRequest("GET", "https://api.captcha.fun/v1/stats", nil)
            req.Header.Set("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")

            client := &http.Client{}
            resp, _ := client.Do(req)
            defer resp.Body.Close()

            var result map[string]interface{}
            json.NewDecoder(resp.Body).Decode(&result)
            fmt.Println(result)
        }
        ```
      </Tab>

      <Tab value="Java">
        ```java
        import java.net.http.*;
        import java.net.URI;

        public class Main {
            public static void main(String[] args) throws Exception {
                HttpClient client = HttpClient.newHttpClient();
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.captcha.fun/v1/stats"))
                    .header("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
                    .GET()
                    .build();

                HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
                System.out.println(response.body());
            }
        }
        ```
      </Tab>

      <Tab value="C#">
        ```csharp
        using System.Net.Http;

        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");

        var response = await client.GetAsync("https://api.captcha.fun/v1/stats");
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine(result);
        ```
      </Tab>
    </Tabs>

    ### Response

    <ResponseTabs
      success={{
  status: 200,
  body: `{
"credits": 100000,
"success": 10000,
"failures": 20
}`
}}
      error={{
  status: 400,
  body: `{
"message": "API_KEY Header Missing"
}`
}}
    />
  </APICode>
</APIPage>


# Image to Text (/docs/api/image-to-text)



import { APIPage, APIContent } from '@/components/api-layout';
import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
import { ResponseTabs } from '@/components/response-tabs';
import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
import { VersionedAPIContent } from '@/components/versioned-api-content';
import { VersionedResponseFields } from '@/components/versioned-response-fields';
import { VersionedEndpoint, EndpointCodeBlock } from '@/components/versioned-endpoint';

<APIPage>
  <APIContent>
    ## Create Solve

    <DynamicCodeBlock
      lang="bash"
      code="POST https://api.captcha.fun/v1/request"
      codeblock={{
  allowCopy: true,
}}
    />

    ### Request Headers

    | Header         | Type   | Required | Description                                           |
    | -------------- | ------ | -------- | ----------------------------------------------------- |
    | `API_KEY`      | string | Yes      | Your API key                                          |
    | `Content-Type` | string | Yes      | `application/json`                                    |
    | `APP_ID`       | string | No       | Optional application identifier for tracking requests |

    ### Request Body

    | Field         | Type   | Required | Description                                                                        |
    | ------------- | ------ | -------- | ---------------------------------------------------------------------------------- |
    | `kind`        | string | Yes      | Must be `image_to_text`                                                            |
    | `imageBase64` | string | Yes      | Base64-encoded PNG, JPEG, or WebP captcha image. A `data:` URI prefix is accepted. |
    | `model`       | string | No       | Model variant: `queueit`. Defaults to `queueit`.                                   |

    ### Create Solve Example

    <Tabs items={['curl', 'Python', 'JavaScript']}>
      <Tab value="curl">
        ```bash
        curl -X POST https://api.captcha.fun/v1/request \
          -H "API_KEY: CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
          -H "Content-Type: application/json" \
          -H "Accept: application/json" \
          -d '{
            "kind": "image_to_text",
            "imageBase64": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...",
            "model": "queueit"
          }'
        ```
      </Tab>

      <Tab value="Python">
        ```python
        import requests

        response = requests.post(
            "https://api.captcha.fun/v1/request",
            headers={
                "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
                "Content-Type": "application/json",
                "Accept": "application/json",
            },
            json={
                "kind": "image_to_text",
                "imageBase64": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...",
                "model": "queueit",
            },
        )

        print(response.status_code, response.json())
        ```
      </Tab>

      <Tab value="JavaScript">
        ```javascript
        const response = await fetch("https://api.captcha.fun/v1/request", {
          method: "POST",
          headers: {
            "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
            "Content-Type": "application/json",
            "Accept": "application/json"
          },
          body: JSON.stringify({
            kind: "image_to_text",
            imageBase64: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...",
            model: "queueit"
          })
        });

        console.log(response.status, await response.json());
        ```
      </Tab>
    </Tabs>

    ### Create Solve Response

    <ResponseTabs
      success={{
  status: 200,
  body: `{
"id": "550e8400-e29b-41d4-a716-446655440000",
"message": "Request submitted successfully"
}`
}}
      error={{
  status: 400,
  body: `{
"message": "Invalid request body"
}`
}}
    />

    ### Create Response Fields

    | Field     | Type          | Description                                 |
    | --------- | ------------- | ------------------------------------------- |
    | `id`      | string (UUID) | The unique identifier for the solve request |
    | `message` | string        | Status message                              |
  </APIContent>

  <APIContent>
    ## Get Solve

    <Tabs items={['v2', 'v1']} groupId="image-to-text-api-version" className="version-tabs">
      <Tab value="v2">
        <EndpointCodeBlock version="v2" />
      </Tab>

      <Tab value="v1">
        <EndpointCodeBlock version="v1" />
      </Tab>
    </Tabs>

    <VersionedEndpoint versionGroupId="image-to-text-api-version" />

    ### Path Parameters

    | Parameter | Type          | Required | Description                           |
    | --------- | ------------- | -------- | ------------------------------------- |
    | `id`      | string (UUID) | Yes      | The ID returned by `POST /v1/request` |

    ### Request Headers

    | Header    | Type   | Required | Description  |
    | --------- | ------ | -------- | ------------ |
    | `API_KEY` | string | Yes      | Your API key |

    ### Get Solve Example

    <VersionedAPIContent versionGroupId="image-to-text-api-version" solution="image-to-text" />

    ### Solve Response Fields

    <VersionedResponseFields versionGroupId="image-to-text-api-version" solution="image-to-text" />
  </APIContent>
</APIPage>


# reCAPTCHA V3 (/docs/api/recaptcha-v3)



import { APIPage, APIContent } from '@/components/api-layout';
import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
import { ResponseTabs } from '@/components/response-tabs';
import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
import { VersionedAPIContent } from '@/components/versioned-api-content';
import { VersionedResponseFields } from '@/components/versioned-response-fields';
import { VersionedEndpoint, EndpointCodeBlock } from '@/components/versioned-endpoint';

<APIPage>
  <APIContent>
    ## Create Solve

    <DynamicCodeBlock
      lang="bash"
      code="POST https://api.captcha.fun/v1/request"
      codeblock={{
  allowCopy: true,
}}
    />

    ### Request Headers

    | Header         | Type   | Required | Description                                           |
    | -------------- | ------ | -------- | ----------------------------------------------------- |
    | `API_KEY`      | string | Yes      | Your API key                                          |
    | `Content-Type` | string | Yes      | `application/json`                                    |
    | `APP_ID`       | string | No       | Optional application identifier for tracking requests |

    ### Request Body

    | Field     | Type   | Required | Description                                                                         |
    | --------- | ------ | -------- | ----------------------------------------------------------------------------------- |
    | `kind`    | string | Yes      | `recap_v3`, `recap_v3_enterprise`, `recap_v3_proxy`, or `recap_v3_enterprise_proxy` |
    | `url`     | string | Yes      | The URL where the reCAPTCHA challenge is located                                    |
    | `siteKey` | string | Yes      | The reCAPTCHA site key                                                              |
    | `action`  | string | No       | The action parameter for reCAPTCHA v3                                               |
    | `proxy`   | string | No       | Proxy to use for proxy solve kinds                                                  |

    ### Create Solve Example

    <Tabs items={['curl', 'Python', 'JavaScript']}>
      <Tab value="curl">
        ```bash
        curl -X POST https://api.captcha.fun/v1/request \
          -H "API_KEY: CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
          -H "Content-Type: application/json" \
          -H "Accept: application/json" \
          -d '{
            "kind": "recap_v3_enterprise",
            "url": "https://google.com",
            "siteKey": "6Lel38UnAAAAAMRwKj9qLH2Ws4Tf2uTDQCyfgR6b",
            "action": "login"
          }'
        ```
      </Tab>

      <Tab value="Python">
        ```python
        import requests

        response = requests.post(
            "https://api.captcha.fun/v1/request",
            headers={
                "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
                "Content-Type": "application/json",
                "Accept": "application/json",
            },
            json={
                "kind": "recap_v3_enterprise",
                "url": "https://google.com",
                "siteKey": "6Lel38UnAAAAAMRwKj9qLH2Ws4Tf2uTDQCyfgR6b",
                "action": "login",
            },
        )

        print(response.status_code, response.json())
        ```
      </Tab>

      <Tab value="JavaScript">
        ```javascript
        const response = await fetch("https://api.captcha.fun/v1/request", {
          method: "POST",
          headers: {
            "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
            "Content-Type": "application/json",
            "Accept": "application/json"
          },
          body: JSON.stringify({
            kind: "recap_v3_enterprise",
            url: "https://google.com",
            siteKey: "6Lel38UnAAAAAMRwKj9qLH2Ws4Tf2uTDQCyfgR6b",
            action: "login"
          })
        });

        console.log(response.status, await response.json());
        ```
      </Tab>
    </Tabs>

    ### Create Solve Response

    <ResponseTabs
      success={{
  status: 200,
  body: `{
"id": "550e8400-e29b-41d4-a716-446655440000",
"message": "Request submitted successfully"
}`
}}
      error={{
  status: 400,
  body: `{
"message": "Invalid request body"
}`
}}
    />

    ### Create Response Fields

    | Field     | Type          | Description                                 |
    | --------- | ------------- | ------------------------------------------- |
    | `id`      | string (UUID) | The unique identifier for the solve request |
    | `message` | string        | Status message                              |
  </APIContent>

  <APIContent>
    ## Get Solve

    <Tabs items={['v2', 'v1']} groupId="recaptcha-api-version" className="version-tabs">
      <Tab value="v2">
        <EndpointCodeBlock version="v2" />
      </Tab>

      <Tab value="v1">
        <EndpointCodeBlock version="v1" />
      </Tab>
    </Tabs>

    <VersionedEndpoint versionGroupId="recaptcha-api-version" />

    ### Path Parameters

    | Parameter | Type          | Required | Description                           |
    | --------- | ------------- | -------- | ------------------------------------- |
    | `id`      | string (UUID) | Yes      | The ID returned by `POST /v1/request` |

    ### Request Headers

    | Header    | Type   | Required | Description  |
    | --------- | ------ | -------- | ------------ |
    | `API_KEY` | string | Yes      | Your API key |

    ### Get Solve Example

    <VersionedAPIContent versionGroupId="recaptcha-api-version" solution="recaptcha" />

    ### Solve Response Fields

    <VersionedResponseFields versionGroupId="recaptcha-api-version" solution="recaptcha" />
  </APIContent>
</APIPage>


# Report Failure (/docs/api/report-failure)



import { APIPage, APIContent, APICode } from '@/components/api-layout';
import { Tab, Tabs } from 'fumadocs-ui/components/tabs';
import { ResponseTabs } from '@/components/response-tabs';
import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';

<APIPage>
  <APIContent>
    ## Endpoint

    <DynamicCodeBlock
      lang="bash"
      code="POST https://api.captcha.fun/v1/report/{id}"
      codeblock={{
  allowCopy: true,
}}
    />

    ## Path Parameters

    | Parameter | Type          | Required | Description                           |
    | --------- | ------------- | -------- | ------------------------------------- |
    | `id`      | string (UUID) | Yes      | The ID of the solve request to report |

    ## Request Headers

    | Header    | Type   | Required | Description  |
    | --------- | ------ | -------- | ------------ |
    | `API_KEY` | string | Yes      | Your API key |

    ## Response Fields

    | Field     | Type   | Description    |
    | --------- | ------ | -------------- |
    | `message` | string | Status message |
  </APIContent>

  <APICode>
    ### Request Example

    <Tabs items={['curl', 'Python', 'JavaScript', 'Go', 'Java', 'C#']}>
      <Tab value="curl">
        ```bash
        curl -X POST https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000 \
          -H "API_KEY: CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" \
          -H "Accept: application/json"
        ```
      </Tab>

      <Tab value="Python">
        ```python
        import requests

        response = requests.post(
            "https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000",
            headers={
                "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
                "Accept": "application/json"
            }
        )

        print(response.status_code, response.json())
        ```
      </Tab>

      <Tab value="JavaScript">
        ```javascript
        const response = await fetch(
          "https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000",
          {
            method: "POST",
            headers: {
              "API_KEY": "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
              "Accept": "application/json"
            }
          }
        );

        const data = await response.json();
        console.log(response.status, data);
        ```
      </Tab>

      <Tab value="Go">
        ```go
        package main

        import (
            "encoding/json"
            "fmt"
            "net/http"
        )

        func main() {
            req, _ := http.NewRequest("POST", "https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000", nil)
            req.Header.Set("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
            req.Header.Set("Accept", "application/json")

            client := &http.Client{}
            resp, _ := client.Do(req)
            defer resp.Body.Close()

            var result map[string]interface{}
            json.NewDecoder(resp.Body).Decode(&result)
            fmt.Println(resp.StatusCode, result)
        }
        ```
      </Tab>

      <Tab value="Java">
        ```java
        import java.net.http.*;
        import java.net.URI;

        public class Main {
            public static void main(String[] args) throws Exception {
                HttpClient client = HttpClient.newHttpClient();
                HttpRequest request = HttpRequest.newBuilder()
                    .uri(URI.create("https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000"))
                    .header("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX")
                    .header("Accept", "application/json")
                    .POST(HttpRequest.BodyPublishers.noBody())
                    .build();

                HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
                System.out.println(response.statusCode() + " " + response.body());
            }
        }
        ```
      </Tab>

      <Tab value="C#">
        ```csharp
        using System.Net.Http;

        var client = new HttpClient();
        client.DefaultRequestHeaders.Add("API_KEY", "CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
        client.DefaultRequestHeaders.Add("Accept", "application/json");

        var response = await client.PostAsync("https://api.captcha.fun/v1/report/550e8400-e29b-41d4-a716-446655440000", null);
        var result = await response.Content.ReadAsStringAsync();

        Console.WriteLine($"{(int)response.StatusCode} {result}");
        ```
      </Tab>
    </Tabs>

    ### Response

    <ResponseTabs
      success={{
  status: 200,
  body: `{
"message": "Report submitted successfully"
}`
}}
      error={{
  status: 400,
  body: `{
"message": "Invalid request ID"
}`
}}
    />
  </APICode>
</APIPage>


# Quick Start (/docs)



import { Step, Steps } from 'fumadocs-ui/components/steps';
import { Card } from 'fumadocs-ui/components/card';

<Steps>
  <Step>
    ## Create Account

    To get started, you'll need to create an account on the captcha.fun dashboard.

    1. Visit [dash.captcha.fun](https://dash.captcha.fun/)
    2. Click **Sign Up** to create a new account
    3. Verify your email address to complete registration
  </Step>

  <Step>
    ## Add Credits

    Before you can start solving captchas, you'll need to deposit funds into your account.

    1. Go to [Billing & Credits](https://dash.captcha.fun/dashboard/billing?tab=credits)
    2. Choose your preferred payment method (Stripe or Crypto)
    3. Select the amount of credits you want to purchase
    4. Complete the checkout process
  </Step>

  <Step>
    ## Get Your API Key

    Once your account is set up, you'll need to grab your API key.

    1. Navigate to your [Dashboard](https://dash.captcha.fun/dashboard)
    2. Locate your API key in the dashboard
    3. Copy your API key - it will be in the format: `CAPFUN-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX`
  </Step>

  <Step>
    ## Create Your First Solve Request

    Now you're ready to start solving captchas! Head over to the API documentation to learn how to create your first solve request.

    <Card title="reCAPTCHA V3" description="Create a solve request and retrieve the solved token" href="/docs/api/recaptcha-v3" />
  </Step>
</Steps>


# What is Captcha.fun (/docs/who-we-are)



import { Card, Cards } from 'fumadocs-ui/components/card';
import { Callout } from 'fumadocs-ui/components/callout';

We built Captcha.fun because the world is changing. AI is transforming how we gather information, automate workflows, and build web solutions at scale. But CAPTCHAs keep getting in the way. We saw developers and businesses hitting walls, their automation blocked by verification challenges that weren't designed for this new reality. So we built something to help. Our mission is to create a service that scales with you, whether you're a solo developer or an enterprise processing millions of requests. We handle whatever demand comes our way, reliably and fast, so you can focus on building what matters.

## Our Technology

We obsess over infrastructure because we know that at scale, every component in the stack counts. We've built our technology to handle tens of millions of solves per day reliably. It's optimized for speed and designed to scale from the ground up. Every decision we make comes from our own experience in the field as scrapers, researchers, and developers. We build what we need, and that's what we give you.

## Current Solutions

We currently offer support for the following CAPTCHA types:

<Cards>
  <Card title="reCAPTCHA v3" />

  <Card title="reCAPTCHA v3 Enterprise" />
</Cards>

## Speed Advantage

<Callout title="Speed That Actually Matters" type="info">
  We average **1 to 2 seconds** for v3 challenges. That's not a marketing number, it's what you'll actually experience.
</Callout>

## Infrastructure

We've built our infrastructure to handle whatever you throw at it. High availability, low latency, and ready to scale with you. When your project grows, we want to be the one thing you don't have to worry about.

## Coming Soon

We're actively expanding. On the horizon:

<Cards>
  <Card title="Cloudflare Turnstile" description="Support for Cloudflare's privacy focused CAPTCHA alternative" />

  <Card title="reCAPTCHA v2" description="Checkbox and invisible v2 challenge support" />
</Cards>

## Why Choose Us

* **We're fast**: genuinely, measurably fast
* **We're reliable**: because downtime costs you money and trust
* **We're developers too**: we build what we'd want to use
* **We're here for you**: real support from people who understand your problems

## Legal & Compliance

<Callout type="warn">
  Unlawful use of our services is strictly prohibited. Any misuse or violation of our Terms of Service may result in immediate account termination. Users bear full responsibility for ensuring their activities comply with all applicable laws and regulations.
</Callout>

## Developer Experience

We wrote the docs we wish existed when we were integrating APIs at 2am. Clear examples, straightforward endpoints, and everything you need to get running in minutes. If something's confusing, tell us and we'll fix it.

## Support & Reliability

When something goes wrong, we're on it. We know your business depends on this working, and we take that seriously. Reach out, and you'll hear back from real people who actually want to help.

## Our Vision

We're just getting started, and honestly, we're excited about where this is going. More CAPTCHA types, faster solves, better reliability. We're working on it all. Our goal isn't just to be another option in the market. We want to build something developers genuinely love using. If you have ideas on how we can be better, we're listening.