Rust crate for Capsolver API

The easiest way to quickly integrate Capsolver into your rust code to automate solving of any type of captcha.

• Installation
• Configuration
• Example Usage
• Contribution
• Licence

Installation

To install, use one of them:

Using cargo

cargo add capsolver

Using Cargo.toml

[dependencies]
capsolver = "0.4.1"

Warning

This requires an asynchronous runtime e.g tokio

Configuration

Import the crate like this:

use capsolver::{Capsolver, Token, Recognition, Config};

Note

Importing Token or Recognition is optional

Capsolver includes both of them

A Config can be created like:

let config = Config::new(ClientKey, ApiUrl, Interval)

//Or simply create from env
let config = Config::from_env()?;

Note

ClientKey is required and it's your client key from [Capsolver Dashboard]

ApiUrl is optional and its default value is Capsolver API

Interval is also optional and it is the interval in ms at which it'll check for task results. Default value 3000

A client can be created like this:

//Use any of them as per your needs

let token = Token::new(config);

let recognition = Recognition::new(config);

let capsolver = Capsolver::new(config);

Note

Token is for the token APIs

Recognition is meant for recognition APIs only

Capsolver includes both of them

Example Usage

Checking your Capsolver balance:

let res = capsolver.get_balance().await?;

println!("Balance: {},\nPackages: {:?}", res.balance, res.packages);

Using ImageToText recognition API:

let task = capsolver
  .recognition()
  .image_to_text("Base64 image string", None, None, None)
  .await?;
let solution = task["solution"]["text"].as_str()?;

println!("Solution: {}", solution);

Using FunCapctha token API:

use capsolver::{OnlyToken};

let task = capsolver
  .token()
  .fun_captcha("websiteURL", "websitePublicKey", None, None, None)
  .await?;
let task_id = task["taskId"].as_str()?;
let soltion: OnlyToken = capsolver
  .get_task_result(task_id)
  .await?;

println!("Solution: {}", solution.token);

Note Refer to Capsolver Docs for the options that are passed in the above functions

Note The return type of get_task_result() of Token task results can be better if you cast the following types individually according to the this

Better Types

• HCaptchaToken
  • HCaptcha
• OnlyToken
  • FunCaptcha
  • MtCaptcha
  • CyberSi Ara
• GeeTestV3Token
  • GeeTestV3
• GeeTestV4Token
  • GeeTestV4
• ReCaptchaToken
  • ReCaptchaV3
  • ReCaptchaV4
• DataDomeToken
  • DataDome
• AwsWafToken
  • AwsWaf
• CloudFlareToken
  • CloudFlare (Turnstile)
  • CloudFlare (Challenge)

Note This list only applies to token task results

Example:

use capsolver::{OnlyToken, HCaptchaToken, AwsWafToken};

//This example assumes that you already have task id for each of them
let fun_captcha_task_id = TaskId;
let h_captcha_task_id = TaskId;
let aws_waf_task_id = TaskId;

let fun_captcha_solution: OnlyToken = capsolver
  .get_task_result(fun_captcha_task_id)
  .await?;
let h_captcha_solution: HCaptchaToken = capsolver
  .get_task_result(fun_captcha_task_id)
  .await?;
let aws_waf_solution: AwsWafToken = capsolver
  .get_task_result(fun_captcha_task_id)
  .await?;

println!("Funcaptcha: {}", fun_captcha_solution.token);
println!("HCaptcha: {}", h_captcha_solution.captcha_key);
println!("AwsWaf: {}", aws_waf_solution.cookie);

That's the best I can explain :D

Contribution

They're welcome :D

Licence

This project is licensed under the MIT License