Skip to content
On this page
Home
>Task(Token)
>FunCaptcha

FunCaptcha: solving Funcaptcha

Create the task with the createTask method and get the result with

the getTaskResult method.

The tasks type types that we support:

  • FunCaptchaTaskProxyLess is using the server's built-in proxy.
  • FunCaptchaTask this task type require your own proxies.

Create Task

Create a task with the createTask to create a task.

Task Object Structure

PropertiesTypeRequiredDescription
typeStringRequiredFunCaptchaTaskProxyLess
FunCaptchaTask
websiteURLStringRequiredWeb address of the website using funcaptcha, generally it's fixed value. (Ex: https://google.com)
websitePublicKeyStringRequiredThe domain public key, rarely updated. (Ex: E8A75615-1CBA-5DFF-8031-D16BCF234E10)
dataStringOptionalAdditional parameter that may be required by FunCaptcha implementation. Use this property to send "blob" value as a stringified JSON. See example how it may look like: {"\blob":"HERE_COMES_THE_blob_VALUE"} Learn how to get FunCaptcha blob data
userAgentStringOptionalthe user-agent you use to generate blob data. you need to use the user-agent we support (windows chrome browser)
proxyStringOptionalLearn Using proxies

Example Request

json
POST https://api.capsolver.com/createTask
Host: api.capsolver.com
Content-Type: application/json

{
    "clientKey": "YOUR_API_KEY_HERE",
    "task": {
        "type":"FunCaptchaTaskProxyLess",
        "websiteURL": "https://www.yourwebsite.com",
        "websitePublicKey": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
        "data": "{\"blob\": \"flaR60YY3tnRXv6w.l32U2KgdgEUCbyoSPI4jOxU...\"}" // Optional
    }
}

After you submit the task to us, you should receive in the response a 'Task id' if it's successfull. Please read errorCode: full list of errors if you didn't receive the task id.

Example Response

json
{
    "errorId": 0,
    "status": "idle",
    "taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}

Getting Result

Use the getTaskResult method to get the recognition results

Depending on the system load, you will get the results within the interval of 1s to 20s

Example Request

json
POST https://api.capsolver.com/getTaskResult
Host: api.capsolver.com
Content-Type: application/json

{
    "clientKey": "YOUR_API_KEY",
    "taskId": "61138bb6-19fb-11ec-a9c8-0242ac110006"
}

Example Response

json
{
    "errorId": 0,
    "solution": {
        "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
        "token": "3AHJ_q25SxXT-pmSeBXjzScW-EiocHwwpwqtk1QXlJnGnU......"
    },
    "status": "ready"
}

Use SDK Request

python
# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'

import capsolver

# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "FunCaptchaTaskProxyLess",
    "websitePublicKey": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    "websiteURL": "https://www.yourwebsite.com",
})
go
package main

import (
	"fmt"
	capsolver_go "github.com/capsolver/capsolver-go"
	"log"
)

func main() {
	// first you need to install sdk
	//go get github.com/capsolver/capsolver-go

	capSolver := capsolver_go.CapSolver{ApiKey: "..."}
	solution, err := capSolver.Solve(map[string]any{
		"type":             "FunCaptchaTaskProxyLess",
		"websiteURL":       "https://www.yourwebsite.com",
		"websitePublicKey": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
	})
	if err != nil {
		log.Fatal(err)
		return
	}
	fmt.Println(solution)
}

Sample Code

python
# pip install requests
import requests
import json
import time

# TODO: set your config
api_key = "YOUR_API_KEY"  # your api key of capsolver
public_key = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"  # publicKey of your target site
page_url = "https://www.yourwebsite.com"  # page url of your target site
blob_data = ""  # optional, some sites require blob data


def capsolver():
    payload = {
        "clientKey": api_key,
        "task": {
            "type": 'FunCaptchaTaskProxyLess',
            "websitePublicKey": public_key,
            "websiteURL": page_url,
            "data": json.dumps({"blob": blob_data}) if blob_data else ''
        }
    }
    res = requests.post("https://api.capsolver.com/createTask", json=payload)
    resp = res.json()
    task_id = resp.get("taskId")
    if not task_id:
        print("Failed to create task:", res.text)
        return
    print(f"Got taskId: {task_id} / Getting result...")

    while True:
        time.sleep(1)  # delay
        payload = {"clientKey": api_key, "taskId": task_id}
        res = requests.post("https://api.capsolver.com/getTaskResult", json=payload)
        resp = res.json()
        status = resp.get("status")
        if status == "ready":
            return resp.get("solution", {}).get('token')
        if status == "failed" or resp.get("errorId"):
            print("Solve failed! response:", res.text)
            return


token = capsolver()
print(token)
go
package main

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"time"
)

type capSolverResponse struct {
	ErrorId          int32          `json:"errorId"`
	ErrorCode        string         `json:"errorCode"`
	ErrorDescription string         `json:"errorDescription"`
	TaskId           string         `json:"taskId"`
	Status           string         `json:"status"`
	Solution         map[string]any `json:"solution"`
}

func capSolver(ctx context.Context, apiKey string, taskData map[string]any) (*capSolverResponse, error) {
	uri := "https://api.capsolver.com/createTask"
	res, err := request(ctx, uri, map[string]any{
		"clientKey": apiKey,
		"task":      taskData,
	})
	if err != nil {
		return nil, err
	}
	if res.ErrorId == 1 {
		return nil, errors.New(res.ErrorDescription)
	}

	uri = "https://api.capsolver.com/getTaskResult"
	for {
		select {
		case <-ctx.Done():
			return res, errors.New("solve timeout")
		case <-time.After(time.Second):
			break
		}
		res, err = request(ctx, uri, map[string]any{
			"clientKey": apiKey,
			"taskId":    res.TaskId,
		})
		if err != nil {
			return nil, err
		}
		if res.ErrorId == 1 {
			return nil, errors.New(res.ErrorDescription)
		}
		if res.Status == "ready" {
			return res, err
		}
	}
}

func request(ctx context.Context, uri string, payload interface{}) (*capSolverResponse, error) {
	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequestWithContext(ctx, "POST", uri, bytes.NewReader(payloadBytes))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	responseData, err := io.ReadAll(resp.Body)
	if err != nil {
		return nil, err
	}
	capResponse := &capSolverResponse{}
	err = json.Unmarshal(responseData, capResponse)
	if err != nil {
		return nil, err
	}
	return capResponse, nil
}

func main() {
	apikey := "YOUR_API_KEY"
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*120)
	defer cancel()

	res, err := capSolver(ctx, apikey, map[string]any{
		"type":             "FunCaptchaTaskProxyLess",
		"websiteURL":       "https://www.yourwebsite.com",
		"websitePublicKey": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
	})
	if err != nil {
		panic(err)
	}
	fmt.Println(res.Solution["token"])
}
javascript
// npm install axios
const axios = require('axios');

const api_key = "YOUR_API_KEY";
const public_key = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
const page_url = "https://www.yourwebsite.com";
let blob_data = "";  // optional, some sites require blob data

async function capsolver() {
  const payload = {
    clientKey: api_key,
    task: {
      type: 'FunCaptchaTaskProxyLess',
      websitePublicKey: public_key,
      websiteURL: page_url,
      data: blob_data ? JSON.stringify({ blob: blob_data }) : ''
    }
  };

  try {
    const res = await axios.post("https://api.capsolver.com/createTask", payload);
    const task_id = res.data.taskId;
    if (!task_id) {
      console.log("Failed to create task:", res.data);
      return;
    }
    console.log("Got taskId:", task_id);

    while (true) {
      await new Promise(resolve => setTimeout(resolve, 1000)); // Delay for 1 second

      const getResultPayload = {clientKey: api_key, taskId: task_id};
      const resp = await axios.post("https://api.capsolver.com/getTaskResult", getResultPayload);
      const status = resp.data.status;

      if (status === "ready") {
        return resp.data.solution.token;
      }
      if (status === "failed" || resp.data.errorId) {
        console.log("Solve failed! response:", resp.data);
        return;
      }
    }
  } catch (error) {
    console.error("Error:", error);
  }
}

capsolver().then(token => {
  console.log(token);
});
java
package org.example.capsolver;
import org.json.JSONObject;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;


public class FunCaptcha {
    public static String API_KEY = "YOUR_API_KEY";
    public static String SITE_URL = "https://www.yourwebsite.com"; 
    public static String PublicKey = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
    public static String Data = "";

    public static void capsolver() throws IOException, InterruptedException {
        JSONObject param = new JSONObject();
        Map<String, Object> task = new HashMap<>();
        task.put("type", "FunCaptchaTaskProxyLess");
        task.put("websiteURL", SITE_URL);
        task.put("websitePublicKey", PublicKey);
        if (!Data.equals("")){
            JSONObject blob = new JSONObject();
            blob.put("blob", Data);
            Data = blob.toString();
        }
        task.put("data", Data);

        param.put("clientKey", API_KEY);
        param.put("task", task);
        String taskId = createTask(param);

        if (Objects.equals(taskId, "")) {
            System.out.println("Failed to create task");
            return;
        }
        System.out.println("Got taskId: "+taskId+" / Getting result...");
        while (true){
            Thread.sleep(1000);
            String token = getTaskResult(taskId);
            if (Objects.equals(token, null)) {
                continue;
            }
            System.out.println(token);
            break;
        }
    }


    public static String requestPost(String url, JSONObject param) throws IOException {
        URL ipapi = new URL(url);
        HttpURLConnection c = (HttpURLConnection) ipapi.openConnection();
        c.setRequestMethod("POST");
        c.setDoOutput(true);

        OutputStream os = null;
        os = c.getOutputStream();
        os.write(param.toString().getBytes("UTF-8"));

        c.connect();
        BufferedReader reader = new BufferedReader(
                new InputStreamReader(c.getInputStream())
        );
        String line;
        StringBuilder sb = new StringBuilder();
        while ((line = reader.readLine()) != null)
        { sb.append(line); }

        return sb.toString();
    }

    public static String createTask(JSONObject param) throws IOException {
        String parsedJsonStr = requestPost("https://api.capsolver.com/createTask", param);
        JSONObject responseJson = new JSONObject(parsedJsonStr);
        return responseJson.get("taskId").toString();
    }

    public static String getTaskResult(String taskId) throws IOException {
        JSONObject param = new JSONObject();
        param.put("clientKey", API_KEY);
        param.put("taskId", taskId);
        String parsedJsonStr = requestPost("https://api.capsolver.com/getTaskResult", param);
        JSONObject responseJson = new JSONObject(parsedJsonStr);

        String status = responseJson.getString("status");
        if (status.equals("ready")) {
            JSONObject solution = responseJson.getJSONObject("solution");
            return solution.getString("token");
        }
        if (status.equals("failed") || responseJson.getInt("errorId")!=0) {
            System.out.println("Solve failed! response: "+parsedJsonStr);
            return "error";
        }
        return null;
    }
}