BotDeflector: résoudre BotDeflector

# pip install --upgrade capsolver
# export CAPSOLVER_API_KEY='...'
 
import capsolver
 
# capsolver.api_key = "..."
solution = capsolver.solve({
    "type": "AntiBotdeflectorTaskProxyLess",
    "websiteURL": "https://exaple.com/",
    "domain":"exaple.com",
    "flowToken":"eyJhbGciOiJI1...",
})

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
    //export CAPSOLVER_API_KEY='...' or
    //capSolver := CapSolver{ApiKey:"..."}
 
    capSolver := capsolver_go.CapSolver{}
    solution, err := capSolver.Solve(map[string]any{
        "type": "AntiBotdeflectorTaskProxyLess",
        "websiteURL": "https://exaple.com/",
        "domain":"exaple.com",
        "flowToken":"eyJhbGciOiJI1...",
    })
    if err != nil {
        log.Fatal(err)
        return
    }
    fmt.Println(solution)
}

# pip install requests
import requests
import time
 
api_key = "YOUR_API_KEY"  # your api key of capsolver
 
def capsolver():
payload = {
    "clientKey": api_key,
    "task": {
        "type": "AntiBotdeflectorTaskProxyLess",
        "websiteURL": "https://exaple.com/",
        "domain":"exaple.com",
        "flowToken":"eyJhbGciOiJI1...",
    }
}
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)

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": "AntiBotdeflectorTaskProxyLess",
        "websiteURL": "https://exaple.com/",
        "domain":"exaple.com",
        "flowToken":"eyJhbGciOiJI1...",
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(res.Solution["token"])
}

// npm install axios
const axios = require('axios');
 
const api_key = "YOUR_API_KEY";
 
async function capsolver() {
    const payload = {
        clientKey: api_key,
        task: {
            type: 'AntiBotdeflectorTaskProxyLess',
            websiteURL: "https://exaple.com/",
            domain: "exaple.com",
            flowToken: "eyJhbGciOiJI1...",
        }
    };
 
    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);
});

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 BotDeflector {
    public static String API_KEY = "YOUR_API_KEY";
    public static String SITE_URL = "https://exaple.com/";
    public static String DOMAIN = "exaple.com";
    public static String FLOW_TOKEN = "eyJhbGciOiJI1...";
 
    public static void capsolver() throws IOException, InterruptedException {
        JSONObject param = new JSONObject();
        Map<String, Object> task = new HashMap<>();
        task.put("type", "AntiBotdeflectorTaskProxyLess");
        task.put("websiteURL", SITE_URL);
        task.put("domain", DOMAIN);
        task.put("flowToken", FLOW_TOKEN);
        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.get("token").toString();
        }
        if (status.equals("failed") || responseJson.getInt("errorId")!=0) {
            System.out.println("Solve failed! response:"+parsedJsonStr);
            return "error";
        }
        return null;
    }
}