├── .gitignore
├── README.md
├── antibot_example.py
├── anticaptchaofficial
    ├── __init__.py
    ├── amazonproxyless.py
    ├── amazonproxyon.py
    ├── antibotcookietask.py
    ├── antigatetask.py
    ├── antinetworking.py
    ├── friendlycaptchaproxyless.py
    ├── friendlycaptchaproxyon.py
    ├── funcaptchaproxyless.py
    ├── funcaptchaproxyon.py
    ├── geetestproxyless.py
    ├── geetestproxyon.py
    ├── hcaptchaproxyless.py
    ├── hcaptchaproxyon.py
    ├── imagecaptcha.py
    ├── imagetocoordinates.py
    ├── prosopoproxyless.py
    ├── prosopoproxyon.py
    ├── recaptchav2enterpriseproxyless.py
    ├── recaptchav2enterpriseproxyon.py
    ├── recaptchav2proxyless.py
    ├── recaptchav2proxyon.py
    ├── recaptchav3enterpriseproxyless.py
    ├── recaptchav3proxyless.py
    ├── turnstileproxyless.py
    └── turnstileproxyon.py
├── antigate_2fa_delay_example.py
├── antigate_proxyless_example.py
├── captcha.jpeg
├── check_balance_example.py
├── coordinates.png
├── funcaptcha_proxyless_example.py
├── funcaptcha_proxyon_example.py
├── geetest_proxyless_example.py
├── geetest_proxyon_example.py
├── hcaptcha_proxyless_example.py
├── hcaptcha_proxyon_example.py
├── image_captcha_body_example.py
├── image_captcha_example.py
├── image_coordinates_example.py
├── recaptcha_v2_enterprise_proxyless_example.py
├── recaptcha_v2_enterprise_proxyon_example.py
├── recaptcha_v2_proxyless_example.py
├── recaptcha_v2_proxyon_example.py
└── recaptcha_v3_proxyless_example.py


/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | .idea/anticaptcha-python.iml
 3 | 
 4 | .idea/inspectionProfiles/profiles_settings.xml
 5 | 
 6 | .idea/misc.xml
 7 | 
 8 | .idea/modules.xml
 9 | 
10 | .idea/vcs.xml
11 | 
12 | .idea/workspace.xml
13 | 
14 | upload.txt
15 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | anticaptchaofficial
  2 | ===================
  3 | 
  4 | Official https://anti-captcha.com/ library for solving images with text, Recaptcha v2/v3 Enterprise or non-Enterprise, Funcaptcha Arcoselabs, GeeTest and others.
  5 | Anti-Captcha is the most popular and reliable captcha solving service, working since 2007.
  6 | Prices for solving captchas start from $0.0005 per token.
  7 | 
  8 | #### How to solve:
  9 | - [Image captcha](#solve-image-captcha)
 10 | - [Recaptcha v2](#how-to-solve-recaptcha-v2)
 11 | - [Recaptcha V3](#how-to-solve-recaptcha-v3)
 12 | - [Hcaptcha](#solve-hcaptcha)
 13 | - [FunCaptcha Arkoselabs](#solve-funcaptcha-arkoselabs)
 14 | - [Geetest V3](#solve-geetest-v3)
 15 | - [Geetest V4](#solve-geetest-v4)
 16 | - [Turnstile](#solve-turnstile)
 17 | - [Antigate templates](#antigate-template-tasks)
 18 | - [Image to coordinates](#image-to-coordinates)
 19 | - [Prosopo](#prosopo-captcha)
 20 | - [Friendly Captcha](#friendly-captcha)
 21 | - [Amazon WAF](#solve-amazon-waf)
 22 | 
 23 | ### Basics
 24 | 
 25 | ```bash
 26 | pip3 install anticaptchaofficial
 27 | ```
 28 | 
 29 |  
 30 | Check API key balance before creating tasks:
 31 | ```python
 32 | balance = solver.get_balance()
 33 | if balance <= 0:
 34 |     print("too low balance!")
 35 |     return
 36 | ```
 37 | &nbsp;
 38 | <br>
 39 | Check subscription credits balance if you have one:
 40 | ```python
 41 | credits = solver.get_credits_balance()
 42 | if credits <= 0:
 43 |     print("too low credits balance!")
 44 |     return
 45 | ```
 46 | &nbsp;
 47 | 
 48 | ### [Solve image captcha with python](https://anti-captcha.com/apidoc/task-types/ImageToTextTask)
 49 | 
 50 | ```python
 51 | from anticaptchaofficial.imagecaptcha import *
 52 | 
 53 | solver = imagecaptcha()
 54 | solver.set_verbose(1)
 55 | solver.set_key("YOUR_KEY")
 56 | 
 57 | # Specify softId to earn 10% commission with your app.
 58 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
 59 | solver.set_soft_id(0)
 60 | 
 61 | captcha_text = solver.solve_and_return_solution("captcha.jpeg")
 62 | if captcha_text != 0:
 63 |     print("captcha text "+captcha_text)
 64 | else:
 65 |     print("task finished with error "+solver.error_code)
 66 | ```
 67 | Report previosly solved image captcha as incorrect:
 68 | ```python
 69 | solver.report_incorrect_image_captcha()
 70 | ```
 71 | ___
 72 | &nbsp;
 73 | 
 74 | ### How to solve Recaptcha V2
 75 | 
 76 | Example how to create [Recaptcha V2](https://anti-captcha.com/apidoc/task-types/RecaptchaV2TaskProxyless) task and receive g-response:
 77 | 
 78 | ```python
 79 | from anticaptchaofficial.recaptchav2proxyless import *
 80 | 
 81 | solver = recaptchaV2Proxyless()
 82 | solver.set_verbose(1)
 83 | solver.set_key("YOUR_API_KEY")
 84 | solver.set_website_url("https://website.com")
 85 | solver.set_website_key("SITE_KEY")
 86 | 
 87 | # Set True if it is Recaptcha V2-invisible
 88 | #solver.set_is_invisible(True)
 89 | 
 90 | # Set data-s value for google.com pages
 91 | #solver.set_data_s('a_long_string_here')
 92 | 
 93 | # Specify softId to earn 10% commission with your app.
 94 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
 95 | solver.set_soft_id(0)
 96 | 
 97 | g_response = solver.solve_and_return_solution()
 98 | if g_response != 0:
 99 |     print "g-response: "+g_response
100 | else:
101 |     print "task finished with error "+solver.error_code
102 | ```
103 | Report previosly solved Recaptcha V2/V3/Enterprise as incorrect:
104 | ```python
105 | solver.report_incorrect_recaptcha()
106 | ```
107 | Report it as correct to improve your quality:
108 | ```python
109 | solver.report_correct_recaptcha()
110 | ```
111 | ___
112 | 
113 | 
114 | ### How to solve Recaptcha V3
115 | 
116 | Example how to create [Recaptcha V3](https://anti-captcha.com/apidoc/task-types/RecaptchaV3TaskProxyless) task and receive g-response:
117 | 
118 | ```python
119 | from anticaptchaofficial.recaptchav3proxyless import *
120 | 
121 | solver = recaptchaV2Proxyless()
122 | solver.set_verbose(1)
123 | solver.set_key("YOUR_API_KEY")
124 | solver.set_website_url("https://website.com")
125 | solver.set_website_key("SITE_KEY")
126 | solver.set_page_action("home_page")
127 | solver.set_min_score(0.9)
128 | 
129 | # Specify softId to earn 10% commission with your app.
130 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
131 | solver.set_soft_id(0)
132 | 
133 | g_response = solver.solve_and_return_solution()
134 | if g_response != 0:
135 |     print "g-response: "+g_response
136 | else:
137 |     print "task finished with error "+solver.error_code
138 | ```
139 | ___
140 | 
141 | &nbsp;
142 | ### Solve Hcaptcha
143 | 
144 | Solve [HCaptcha](https://anti-captcha.com/apidoc/task-types/HCaptchaTask) and receive its token:
145 | 
146 | ```python
147 | from anticaptchaofficial.hcaptchaproxyless import *
148 | 
149 | solver = hCaptchaProxyless()
150 | solver.set_verbose(1)
151 | solver.set_key("YOUR_KEY")
152 | solver.set_website_url("https://website.com")
153 | solver.set_website_key("SITE_KEY")
154 | solver.set_user_agent("YOUR FULL USER AGENT HERE")
155 | 
156 | # tell API that Hcaptcha is invisible
157 | #solver.set_is_invisible(1)
158 | 
159 | # Specify softId to earn 10% commission with your app.
160 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
161 | solver.set_soft_id(0)
162 | 
163 | g_response = solver.solve_and_return_solution()
164 | if g_response != 0:
165 |     print("g-response: "+g_response)
166 |     # use this user-agent to make requests to your target website
167 |     print("user-agent: "+solver.get_user_agent())
168 |     print("respkey, if any: ", solver.get_respkey())
169 | else:
170 |     print("task finished with error "+solver.error_code)
171 | ```
172 | Report previosly solved Hcaptcha as incorrect:
173 | ```python
174 | solver.report_incorrect_hcaptcha()
175 | ```
176 | ___
177 | &nbsp;
178 | 
179 | ### Solve FunCaptcha Arkoselabs
180 | Solve [Funcaptcha](https://anti-captcha.com/apidoc/task-types/FunCaptchaTaskProxyless) (Arkoselabs) and receive the token:
181 | 
182 | ```python
183 | from anticaptchaofficial.funcaptchaproxyless import *
184 | 
185 | solver = funcaptchaProxyless()
186 | solver.set_verbose(1)
187 | solver.set_key("YOUR_KEY")
188 | solver.set_website_url("https://website.com")
189 | solver.set_website_key("XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX")
190 | 
191 | token = solver.solve_and_return_solution()
192 | if token != 0:
193 |     print("result token: "+token)
194 | else:
195 |     print("task finished with error "+solver.error_code)
196 | ```
197 | ___
198 | 
199 | &nbsp;
200 | 
201 | ### Solve GeeTest v3
202 | 
203 | Solve [GeeTest](https://anti-captcha.com/apidoc/task-types/GeeTestTask) captcha and receive its token:
204 | 
205 | ```python
206 | from anticaptchaofficial.geetestproxyless import *
207 | 
208 | solver = geetestProxyless()
209 | solver.set_verbose(1)
210 | solver.set_key("YOUR_API_KEY")
211 | solver.set_website_url("https://address.com")
212 | solver.set_gt_key("CONSTANT_GT_KEY")
213 | solver.set_challenge_key("VARIABLE_CHALLENGE_KEY")
214 | token = solver.solve_and_return_solution()
215 | if token != 0:
216 |     print("result tokens: ")
217 |     print(token)
218 | else:
219 |     print("task finished with error "+solver.error_code)
220 | ```
221 | ___
222 | 
223 | &nbsp;
224 | 
225 | ### Solve Geetest v4
226 | 
227 | Solve [GeeTest v4](https://anti-captcha.com/apidoc/task-types/GeeTestTask) captcha and receive its token:
228 | 
229 | ```python
230 | from anticaptchaofficial.geetestproxyless import *
231 | 
232 | solver = geetestProxyless()
233 | solver.set_verbose(1)
234 | solver.set_key("YOUR_API_KEY")
235 | solver.set_website_url("https://address.com")
236 | solver.set_version(4)
237 | solver.set_init_parameters({"riskType": "slide"})
238 | token = solver.solve_and_return_solution()
239 | if token != 0:
240 |     print("result tokens: ")
241 |     print(token)
242 | else:
243 |     print("task finished with error "+solver.error_code)
244 | ```
245 | ___
246 | 
247 | &nbsp;
248 | 
249 | ### Solve Turnstile
250 | 
251 | Example how to solve [Turnstile](https://anti-captcha.com/apidoc/task-types/TurnstileTaskProxyless) task and receive a token:
252 | 
253 | ```python
254 | from anticaptchaofficial.turnstileproxyless import *
255 | 
256 | solver = turnstileProxyless()
257 | solver.set_verbose(1)
258 | solver.set_key("YOUR_API_KEY")
259 | solver.set_website_url("https://website.com")
260 | solver.set_website_key("SITE_KEY")
261 | 
262 | # Optionally specify page action
263 | solver.set_action("login")
264 | 
265 | # Optionally specify cData and chlPageData tokens for Cloudflare pages
266 | #solver.set_cdata("cdata_token")
267 | #solver.set_chlpagedata("chlpagedata_token")
268 | 
269 | # Specify softId to earn 10% commission with your app.
270 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
271 | solver.set_soft_id(0)
272 | 
273 | token = solver.solve_and_return_solution()
274 | if token != 0:
275 |     print "token: "+token
276 | else:
277 |     print "task finished with error "+solver.error_code
278 | ```
279 | ____
280 | 
281 | &nbsp;
282 | 
283 | ### Antigate template tasks
284 | 
285 | Solve [AntiGate](https://anti-captcha.com/apidoc/task-types/AntiGateTask) task:
286 | 
287 | ```python
288 | from anticaptchaofficial.antigatetask import *
289 | 
290 | solver = antigateTask()
291 | solver.set_verbose(1)
292 | solver.set_key("YOUR_KEY")
293 | solver.set_website_url("http://antigate.com/logintest.php")
294 | solver.set_template_name("Sign-in and wait for control text")
295 | solver.set_variables({
296 |     "login_input_css": "#login",
297 |     "login_input_value": "test login",
298 |     "password_input_css": "#password",
299 |     "password_input_value": "test password",
300 |     "control_text": "You have been logged successfully"
301 | })
302 | 
303 | result  = solver.solve_and_return_solution()
304 | if result != 0:
305 |     cookies, localStorage, fingerprint, url, domain = result["cookies"], result["localStorage"], result["fingerprint"], result["url"], result["domain"]
306 |     print("cookies: ", cookies)
307 |     print("localStorage: ", localStorage)
308 |     print("fingerprint: ", fingerprint)
309 |     print("url: "+url)
310 |     print("domain: "+domain)
311 | else:
312 |     print("task finished with error "+solver.error_code)
313 | ```
314 | ___
315 | 
316 | &nbsp;
317 | 
318 | Solve [AntiBotCookieTask](https://anti-captcha.com/apidoc/task-types/AntiBotCookieTask) task to bypass Cloudflare, Datadome and others:
319 | 
320 | ```python
321 | from anticaptchaofficial.antibotcookietask import *
322 | 
323 | solver = antibotcookieTask()
324 | solver.set_verbose(1)
325 | solver.set_key("YOUR_KEY")
326 | solver.set_website_url("https://www.somewebsite.com/")
327 | solver.set_proxy_address("1.2.3.4")
328 | solver.set_proxy_port(3128)
329 | solver.set_proxy_login("login")
330 | solver.set_proxy_password("password")
331 | 
332 | result = solver.solve_and_return_solution()
333 | if result == 0:
334 |     print("could not solve task")
335 |     exit()
336 | 
337 | print(result)
338 | 
339 | cookies, localStorage, fingerprint = result["cookies"], result["localStorage"], result["fingerprint"]
340 | 
341 | if len(cookies) == 0:
342 |     print("empty cookies, try again")
343 |     exit()
344 | 
345 | cookie_string = '; '.join([f'{key}={value}' for key, value in cookies.items()])
346 | user_agent = fingerprint['self.navigator.userAgent']
347 | print(f"use these cookies for requests: {cookie_string}")
348 | print(f"use this user-agent for requests: {user_agent}")
349 | 
350 | s = requests.Session()
351 | proxies = {
352 |   "http": "http://login:password@1.2.3.4:3128",
353 |   "https": "http://login:password@1.2.3.4:3128"
354 | }
355 | s.proxies = proxies
356 | 
357 | content = s.get("https://www.somewebsite.com/", headers={
358 |     "Cookie": cookie_string,
359 |     "User-Agent": user_agent
360 | }).text
361 | print(content)
362 | ```
363 | ___
364 | 
365 | &nbsp;
366 | 
367 | ### Image to coordinates
368 | 
369 | Get [object coordinates](https://anti-captcha.com/apidoc/task-types/ImageCoordinatesTask) in an image:
370 | 
371 | ```python
372 | from anticaptchaofficial.imagetocoordinates import *
373 | 
374 | solver = imagetocoordinates()
375 | solver.set_verbose(1)
376 | solver.set_key("YOUR_KEY")
377 | solver.set_mode("points")
378 | solver.set_comment("Select in specified order")
379 | 
380 | # Specify softId to earn 10% commission with your app.
381 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
382 | solver.set_soft_id(0)
383 | 
384 | coordinates = solver.solve_and_return_solution("coordinates.png")
385 | if coordinates != 0:
386 |     print("coordinates: ", captcha_text)
387 | else:
388 |     print("task finished with error "+solver.error_code)
389 | ```
390 | Report previosly solved captcha as incorrect:
391 | ```python
392 | solver.report_incorrect_image_captcha()
393 | ```
394 | ___
395 | 
396 | &nbsp;
397 | 
398 | ### Prosopo captcha
399 | 
400 | Example how to create [Prosopo](https://anti-captcha.com/apidoc/task-types/ProsopoTaskProxyless) captcha and receive a token:
401 | 
402 | ```python
403 | from anticaptchaofficial.prosopoproxyless import *
404 | 
405 | solver = prosopoProxyless()
406 | solver.set_verbose(1)
407 | solver.set_key("YOUR_API_KEY")
408 | solver.set_website_url("https://website.com")
409 | solver.set_website_key("SITE_KEY")
410 | 
411 | # Specify softId to earn 10% commission with your app.
412 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
413 | solver.set_soft_id(0)
414 | 
415 | token = solver.solve_and_return_solution()
416 | if token != 0:
417 |     print "token: "+token
418 | else:
419 |     print "task finished with error "+solver.error_code
420 | ```
421 | ___
422 | 
423 | &nbsp;
424 | 
425 | ### Friendly captcha
426 | 
427 | Example how to create [Friendly Captcha](https://anti-captcha.com/apidoc/task-types/FriendlyCaptchaTaskProxyless) task and receive a token:
428 | 
429 | ```python
430 | from anticaptchaofficial.friendlycaptchaproxyless import *
431 | 
432 | solver = friendlyCaptchaProxyless()
433 | solver.set_verbose(1)
434 | solver.set_key("YOUR_API_KEY")
435 | solver.set_website_url("https://website.com")
436 | solver.set_website_key("SITE_KEY")
437 | 
438 | # Specify softId to earn 10% commission with your app.
439 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
440 | solver.set_soft_id(0)
441 | 
442 | token = solver.solve_and_return_solution()
443 | if token != 0:
444 |     print "token: "+token
445 | else:
446 |     print "task finished with error "+solver.error_code
447 | ```
448 | ___
449 | 
450 | &nbsp;
451 | 
452 | ### Solve Amazon WAF
453 | 
454 | Example how to solve [Amazon WAF](https://anti-captcha.com/apidoc/task-types/AmazonTaskProxyless) task and receive an aws-was-token:
455 | 
456 | ```python
457 | from anticaptchaofficial.amazonproxyless import *
458 | 
459 | solver = amazonProxyless()
460 | solver.set_verbose(1)
461 | solver.set_key("YOUR_API_KEY")
462 | solver.set_website_url("https://website.com")
463 | solver.set_website_key("key_value_from_window.gokuProps_object")
464 | solver.set_iv("iv_value_from_window.gokuProps_object")
465 | solver.set_context("context_value_from_window.gokuProps_object")
466 | 
467 | # Optional script URLs
468 | solver.set_captcha_script("https://e9b10f157f38.9a96e8b4.us-gov-west-1.captcha.awswaf.com/e9b10f157f38/76cbcde1c834/2a564e323e7b/captcha.js")
469 | solver.set_challenge_script("https://e9b10f157f38.9a96e8b4.us-gov-west-1.token.awswaf.com/e9b10f157f38/76cbcde1c834/2a564e323e7b/challenge.js")
470 | 
471 | # Specify softId to earn 10% commission with your app.
472 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
473 | solver.set_soft_id(0)
474 | 
475 | token = solver.solve_and_return_solution()
476 | if token != 0:
477 |     print "token: "+token
478 | else:
479 |     print "task finished with error "+solver.error_code
480 | ```
481 | ____
482 | 
483 | 
484 | Check out [examples](https://github.com/anti-captcha/anticaptcha-python) for other captcha types
485 | 
486 | ---
487 | Useful links:
488 | - [Как решить рекапчу автоматически](https://anti-captcha.com/ru/apidoc/task-types/RecaptchaV2TaskProxyless)
489 | - [Обход капчи](https://anti-captcha.com/ru/apidoc/task-types/ImageToTextTask)
490 | - [Cómo resolver un recaptcha automáticamente](https://anti-captcha.com/es/apidoc/task-types/RecaptchaV2TaskProxyless)
491 | - [Como resolver um recaptcha automaticamente](https://anti-captcha.com/pt/apidoc/task-types/RecaptchaV2TaskProxyless)


--------------------------------------------------------------------------------
/antibot_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antibotcookietask import *
 2 | import requests
 3 | 
 4 | solver = antibotcookieTask()
 5 | solver.set_verbose(1)
 6 | solver.set_key("API_KEY_HERE")
 7 | solver.set_website_url("https://www.somewebsite.com/")
 8 | solver.set_proxy_address("1.2.3.4")
 9 | solver.set_proxy_port(3128)
10 | solver.set_proxy_login("login")
11 | solver.set_proxy_password("password")
12 | 
13 | # Specify softId to earn 10% commission with your app.
14 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
15 | solver.set_soft_id(0)
16 | 
17 | result = solver.solve_and_return_solution()
18 | if result == 0:
19 |     print("could not solve task")
20 |     exit()
21 | 
22 | print(result)
23 | 
24 | cookies, localStorage, fingerprint = result["cookies"], result["localStorage"], result["fingerprint"]
25 | 
26 | if len(cookies) == 0:
27 |     print("empty cookies, try again")
28 |     exit()
29 | 
30 | cookie_string = '; '.join([f'{key}={value}' for key, value in cookies.items()])
31 | user_agent = fingerprint['self.navigator.userAgent']
32 | print(f"use these cookies for requests: {cookie_string}")
33 | print(f"use this user-agent for requests: {user_agent}")
34 | 
35 | s = requests.Session()
36 | proxies = {
37 |   "http": "http://login:password@1.2.3.4:3128",
38 |   "https": "http://login:password@1.2.3.4:3128"
39 | }
40 | s.proxies = proxies
41 | 
42 | content = s.get("https://www.somewebsite.com/", headers={
43 |     "Cookie": cookie_string,
44 |     "User-Agent": user_agent
45 | }).text
46 | print(content)
47 | 
48 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/__init__.py:
--------------------------------------------------------------------------------
1 | import requests
2 | 
3 | default_headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
4 | 
5 | session = requests.Session()
6 | session.headers.update(default_headers)


--------------------------------------------------------------------------------
/anticaptchaofficial/amazonproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class amazonProxyless(antiNetworking):
 6 | 
 7 |     iv = ''
 8 |     context = ''
 9 |     captcha_script = ''
10 |     challenge_script = ''
11 | 
12 |     def set_iv(self, value):
13 |         self.iv = value
14 | 
15 |     def set_context(self, value):
16 |         self.context = value
17 | 
18 |     def set_challenge_script(self, value):
19 |         self.challenge_script = value
20 | 
21 |     def set_captcha_script(self, value):
22 |         self.captcha_script = value
23 | 
24 |     def solve_and_return_solution(self):
25 |         task = {
26 |             "type": "AmazonTaskProxyless",
27 |             "websiteURL": self.website_url,
28 |             "websiteKey": self.website_key,
29 |             "iv": self.iv,
30 |             "context": self.context,
31 |             "captchaScript": self.captcha_script,
32 |             "challengeScript": self.challenge_script
33 |         }
34 |         if self.create_task({
35 |             "clientKey": self.client_key,
36 |             "task": task,
37 |             "softId": self.soft_id
38 |         }) == 1:
39 |             self.log("created task with id "+str(self.task_id))
40 |         else:
41 |             self.log("could not create task")
42 |             self.log(self.err_string)
43 |             return 0
44 |         time.sleep(3)
45 |         task_result = self.wait_for_result(300)
46 |         if task_result == 0:
47 |             return 0
48 |         else:
49 |             return task_result["solution"]["token"]
50 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/amazonproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class amazonProxyon(antiNetworking):
 6 | 
 7 |     iv = ''
 8 |     context = ''
 9 |     captcha_script = ''
10 |     challenge_script = ''
11 | 
12 |     def set_iv(self, value):
13 |         self.iv = value
14 | 
15 |     def set_context(self, value):
16 |         self.context = value
17 | 
18 |     def set_challenge_script(self, value):
19 |         self.challenge_script = value
20 | 
21 |     def set_captcha_script(self, value):
22 |         self.captcha_script = value
23 | 
24 |     def solve_and_return_solution(self):
25 |         task = {
26 |             "type": "AmazonTask",
27 |             "websiteURL": self.website_url,
28 |             "websiteKey": self.website_key,
29 |             "iv": self.iv,
30 |             "context": self.context,
31 |             "captchaScript": self.captcha_script,
32 |             "challengeScript": self.challenge_script,
33 |             "proxyType": self.proxy_type,
34 |             "proxyAddress": self.proxy_address,
35 |             "proxyPort": self.proxy_port,
36 |             "proxyLogin": self.proxy_login,
37 |             "proxyPassword": self.proxy_password
38 |         }
39 |         if self.create_task({
40 |             "clientKey": self.client_key,
41 |             "task": task,
42 |             "softId": self.soft_id
43 |         }) == 1:
44 |             self.log("created task with id "+str(self.task_id))
45 |         else:
46 |             self.log("could not create task")
47 |             self.log(self.err_string)
48 |             return 0
49 |         time.sleep(3)
50 |         task_result = self.wait_for_result(300)
51 |         if task_result == 0:
52 |             return 0
53 |         else:
54 |             return task_result["solution"]["token"]
55 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/antibotcookietask.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class antibotcookieTask(antiNetworking):
 6 | 
 7 |     provider_name = ""
 8 | 
 9 |     def solve_and_return_solution(self):
10 |         if self.create_task({
11 |             "clientKey": self.client_key,
12 |             "task": {
13 |                 "type": "AntiBotCookieTask",
14 |                 "websiteURL": self.website_url,
15 |                 "proxyAddress": self.proxy_address,
16 |                 "proxyPort": self.proxy_port,
17 |                 "proxyLogin": self.proxy_login,
18 |                 "proxyPassword": self.proxy_password
19 |             },
20 |             "softId": self.soft_id
21 |         }) == 1:
22 |             self.log("created task with id "+str(self.task_id))
23 |         else:
24 |             self.log("could not create task")
25 |             self.log(self.err_string)
26 |             return 0
27 |         #checking result
28 |         time.sleep(3)
29 |         task_result = self.wait_for_result(600)
30 |         if task_result == 0:
31 |             return 0
32 |         else:
33 |             return task_result["solution"]
34 | 
35 | 
36 | 
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/antigatetask.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class antigateTask(antiNetworking):
 6 | 
 7 |     template_name = ""
 8 |     variables = {}
 9 |     domains_of_interest = []
10 | 
11 |     def push_variable(self, task_id, name, value):
12 |         result = self.make_request("pushAntiGateVariable", {
13 |             "clientKey": self.client_key,
14 |             "taskId": self.task_id,
15 |             "name": name,
16 |             "value": value
17 |         })
18 |         if result == 0:
19 |             return 0
20 |         else:
21 |             if result["errorId"] == 0:
22 |                 return 1
23 |             else:
24 |                 return 0
25 | 
26 |     def send_antigate_task(self):
27 |         if self.create_task({
28 |             "clientKey": self.client_key,
29 |             "task": {
30 |                 "type": "AntiGateTask",
31 |                 "websiteURL": self.website_url,
32 |                 "templateName": self.template_name,
33 |                 "variables": self.variables,
34 |                 "domainsOfInterest": self.domains_of_interest,
35 |                 "proxyAddress": self.proxy_address,
36 |                 "proxyPort": self.proxy_port,
37 |                 "proxyLogin": self.proxy_login,
38 |                 "proxyPassword": self.proxy_password
39 |             },
40 |             "softId": self.soft_id
41 |         }) == 1:
42 |             self.log("created task with id "+str(self.task_id))
43 |             return self.task_id
44 |         else:
45 |             self.log("could not create task")
46 |             self.log(self.err_string)
47 |             return 0
48 | 
49 |     def solve_and_return_solution(self):
50 |         if self.create_task({
51 |             "clientKey": self.client_key,
52 |             "task": {
53 |                 "type": "AntiGateTask",
54 |                 "websiteURL": self.website_url,
55 |                 "templateName": self.template_name,
56 |                 "variables": self.variables,
57 |                 "domainsOfInterest": self.domains_of_interest,
58 |                 "proxyAddress": self.proxy_address,
59 |                 "proxyPort": self.proxy_port,
60 |                 "proxyLogin": self.proxy_login,
61 |                 "proxyPassword": self.proxy_password
62 |             },
63 |             "softId": self.soft_id
64 |         }) == 1:
65 |             self.log("created task with id "+str(self.task_id))
66 |         else:
67 |             self.log("could not create task")
68 |             self.log(self.err_string)
69 |             return 0
70 |         #checking result
71 |         time.sleep(3)
72 |         task_result = self.wait_for_result(600)
73 |         if task_result == 0:
74 |             return 0
75 |         else:
76 |             return task_result["solution"]
77 | 
78 |     def set_template_name(self, value):
79 |         self.template_name = value
80 | 
81 |     def set_variables(self, value):
82 |         self.variables = value
83 | 
84 |     def set_domains_of_interest(self, value):
85 |         self.domains_of_interest = value
86 | 
87 | 
88 | 
89 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/antinetworking.py:
--------------------------------------------------------------------------------
  1 | import requests
  2 | from requests.adapters import HTTPAdapter
  3 | import json
  4 | import urllib3
  5 | from datetime import datetime
  6 | import time
  7 | 
  8 | default_headers = {'Content-Type': 'application/json', 'Accept': 'application/json'}
  9 | 
 10 | session = requests.Session()
 11 | session.headers.update(default_headers)
 12 | 
 13 | 
 14 | class antiNetworking:
 15 | 
 16 |     client_key = ""
 17 |     soft_id = 0
 18 |     website_url = ""
 19 |     website_key = ""
 20 |     website_stoken = ""
 21 |     recaptcha_data_s = ""
 22 |     recaptcha_enterprise_payload = None
 23 |     proxy_type = "http"
 24 |     proxy_address = ""
 25 |     proxy_port = 0
 26 |     proxy_login = ""
 27 |     proxy_password = ""
 28 |     user_agent = ""
 29 |     cookies = ""
 30 |     is_invisible = 0
 31 |     is_enterprise = 0
 32 | 
 33 |     is_verbose = 0
 34 |     err_string = ""
 35 |     task_id = 0
 36 |     error_code = ""
 37 |     
 38 |     phrase = False
 39 |     case = False
 40 |     numeric = 0
 41 |     math = False
 42 |     minLength = 0
 43 |     maxLength = 0
 44 |     comment = False
 45 | 
 46 |     def get_balance(self):
 47 |         result = self.make_request("getBalance", {"clientKey": self.client_key})
 48 |         if result != 0:
 49 |             return result["balance"]
 50 |         else:
 51 |             return -1
 52 | 
 53 |     def get_credits_balance(self):
 54 |         result = self.make_request("getBalance", {"clientKey": self.client_key})
 55 |         if result != 0 and "captchaCredits" in result:
 56 |             return result["captchaCredits"]
 57 |         else:
 58 |             return -1
 59 | 
 60 |     def create_task(self, post_data):
 61 |         new_task = self.make_request("createTask", post_data)
 62 |         if new_task == 0:
 63 |             return 0
 64 |         else:
 65 |             if new_task["errorId"] == 0:
 66 |                 self.task_id = new_task["taskId"]
 67 |                 return 1
 68 |             else:
 69 |                 self.error_code = new_task["errorCode"]
 70 |                 self.err_string = "API error "+new_task["errorCode"] + ": "+new_task["errorDescription"]
 71 |                 return 0
 72 | 
 73 |     def wait_for_result(self, max_seconds=300, current_second=0):
 74 | 
 75 |         if current_second >= max_seconds:
 76 |             self.err_string = "task solution expired"
 77 |             return 0
 78 | 
 79 |         time.sleep(1)
 80 |         task_check = self.make_request("getTaskResult", {
 81 |             "clientKey": self.client_key,
 82 |             "taskId": self.task_id
 83 |         })
 84 |         if task_check == 0:
 85 |             return 0
 86 |         else:
 87 |             if task_check["errorId"] == 0:
 88 |                 if task_check["status"] == "processing":
 89 |                     self.log("task is still processing")
 90 |                     return self.wait_for_result(max_seconds, current_second+1)
 91 |                 if task_check["status"] == "ready":
 92 |                     self.log("task solved")
 93 |                     return task_check
 94 |             else:
 95 |                 self.error_code = task_check["errorCode"]
 96 |                 self.err_string = "API error "+task_check["errorCode"] + ": "+task_check["errorDescription"]
 97 |                 self.log(self.err_string)
 98 |                 return 0
 99 | 
100 |     def report_incorrect_image_captcha(self):
101 |         return self.make_request("reportIncorrectImageCaptcha", {
102 |             "clientKey": self.client_key,
103 |             "taskId": self.task_id
104 |         })
105 | 
106 |     def report_incorrect_recaptcha(self):
107 |         return self.make_request("reportIncorrectRecaptcha", {
108 |             "clientKey": self.client_key,
109 |             "taskId": self.task_id
110 |         })
111 | 
112 |     def report_correct_recaptcha(self):
113 |         return self.make_request("reportCorrectRecaptcha", {
114 |             "clientKey": self.client_key,
115 |             "taskId": self.task_id
116 |         })
117 | 
118 |     def report_incorrect_hcaptcha(self):
119 |         return self.make_request("reportIncorrectHcaptcha", {
120 |             "clientKey": self.client_key,
121 |             "taskId": self.task_id
122 |         })
123 | 
124 |     def make_request(self, method, data):
125 |         self.log("making request to "+method)
126 | 
127 |         try:
128 |             response = session.post("https://api.anti-captcha.com/"+method, data=json.dumps(data))
129 |         except requests.exceptions.HTTPError as err:
130 |             self.log("HTTPError", err.errno, err.strerror, err.args, err.filename)
131 |             self.err_string = "http_error"
132 |             for errArg in err.args:
133 |                 if "Network is unreachable" in str(errArg):
134 |                     self.err_string = "Network is unreachable"
135 |                 if "Connection refused" in str(errArg):
136 |                     self.err_string = "Connection refused"
137 |             return 0
138 |         except requests.exceptions.ConnectTimeout:
139 |             self.err_string = "Connection timeout"
140 |             return 0
141 |         except urllib3.exceptions.ConnectTimeoutError:
142 |             self.err_string = "Connection timeout"
143 |             return 0
144 |         except requests.exceptions.ReadTimeout:
145 |             self.err_string = "Read timeout"
146 |             return 0
147 |         except urllib3.exceptions.MaxRetryError as err:
148 |             self.err_string = "Connection retry error: "+err.reason
149 |             return 0
150 |         except requests.exceptions.ConnectionError:
151 |             self.err_string = "Connection refused"
152 |             return 0
153 |         return response.json()
154 | 
155 |     def set_key(self, value):
156 |         self.client_key = value
157 | 
158 |     def set_soft_id(self, value):
159 |         self.soft_id = value
160 | 
161 |     def set_website_url(self, value):
162 |         self.website_url = value
163 | 
164 |     def set_website_key(self, value):
165 |         self.website_key = value
166 | 
167 |     def set_website_stoken(self, value):
168 |         self.website_stoken = value
169 | 
170 |     def set_data_s(self, value):
171 |         self.recaptcha_data_s = value;
172 | 
173 |     def set_enterprise_payload(self, value):
174 |         self.recaptcha_enterprise_payload = value;
175 | 
176 |     def set_proxy_type(self, value):
177 |         self.proxy_type = value
178 | 
179 |     def set_proxy_address(self, value):
180 |         self.proxy_address = value
181 | 
182 |     def set_proxy_port(self, value):
183 |         self.proxy_port = value
184 | 
185 |     def set_proxy_login(self, value):
186 |         self.proxy_login = value
187 | 
188 |     def set_proxy_password(self, value):
189 |         self.proxy_password = value
190 | 
191 |     def set_user_agent(self, value):
192 |         self.user_agent = value
193 | 
194 |     def set_cookies(self, value):
195 |         self.cookies = value
196 | 
197 |     def set_is_invisible(self, value):
198 |         self.is_invisible = value
199 | 
200 |     def set_is_enterprise(self, value):
201 |         self.is_enterprise = value
202 | 
203 |     def set_verbose(self, value):
204 |         self.is_verbose = value
205 | 
206 |     def log(self, msg):
207 |         if self.is_verbose:
208 |             print(msg)
209 | 
210 |     def get_time_stamp(self):
211 |         return int((datetime.utcnow() - datetime(1970, 1, 1)).total_seconds())
212 | 
213 |     def set_phrase(self, value):
214 |         self.phrase = value
215 |         
216 |     def set_case(self, value):
217 |         self.case = value
218 |         
219 |     def set_numeric(self, value):
220 |         self.numeric = value
221 |         
222 |     def set_math(self, value):
223 |         self.math = value
224 | 
225 |     def set_minLength(self, value):
226 |         self.minLength = value  
227 | 
228 |     def set_maxLength(self, value):
229 |         self.maxLength = value
230 | 
231 |     def set_comment(self, value):
232 |         self.comment = value
233 | 
234 |     def set_poolSize(self, pool_connections, pool_maxsize=100):
235 |         adapter = HTTPAdapter(
236 |             pool_connections=pool_connections,
237 |             pool_maxsize=pool_maxsize
238 |         )
239 |         session.mount("https://", adapter)
240 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/friendlycaptchaproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class friendlyCaptchaProxyless(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "FriendlyCaptchaTaskProxyless",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key
12 |         }
13 |         if self.create_task({
14 |             "clientKey": self.client_key,
15 |             "task": task,
16 |             "softId": self.soft_id
17 |         }) == 1:
18 |             self.log("created task with id "+str(self.task_id))
19 |         else:
20 |             self.log("could not create task")
21 |             self.log(self.err_string)
22 |             return 0
23 |         time.sleep(3)
24 |         task_result = self.wait_for_result(300)
25 |         if task_result == 0:
26 |             return 0
27 |         else:
28 |             return task_result["solution"]["token"]
29 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/friendlycaptchaproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class friendlyCaptchaProxyon(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "FriendlyCaptchaTask",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key,
12 |             "proxyType": self.proxy_type,
13 |             "proxyAddress": self.proxy_address,
14 |             "proxyPort": self.proxy_port,
15 |             "proxyLogin": self.proxy_login,
16 |             "proxyPassword": self.proxy_password
17 |         }
18 |         if self.is_invisible:
19 |             task['isInvisible'] = True
20 |         if self.create_task({
21 |             "clientKey": self.client_key,
22 |             "task": task,
23 |             "softId": self.soft_id
24 |         }) == 1:
25 |             self.log("created task with id "+str(self.task_id))
26 |         else:
27 |             self.log("could not create task")
28 |             self.log(self.err_string)
29 |             return 0
30 |         #checking result
31 |         time.sleep(3)
32 |         task_result = self.wait_for_result(300)
33 |         if task_result == 0:
34 |             return 0
35 |         else:
36 |             return task_result["solution"]["token"]
37 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/funcaptchaproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class funcaptchaProxyless(antiNetworking):
 6 | 
 7 |     js_api_domain = ""
 8 |     data_blob = ""
 9 | 
10 |     def solve_and_return_solution(self):
11 |         if self.create_task({
12 |             "clientKey": self.client_key,
13 |             "task": {
14 |                 "type": "FunCaptchaTaskProxyless",
15 |                 "websiteURL": self.website_url,
16 |                 "funcaptchaApiJSSubdomain": self.js_api_domain,
17 |                 "data": self.data_blob,
18 |                 "websitePublicKey": self.website_key
19 |             },
20 |             "softId": self.soft_id
21 |         }) == 1:
22 |             self.log("created task with id "+str(self.task_id))
23 |         else:
24 |             self.log("could not create task")
25 |             self.log(self.err_string)
26 |             return 0
27 |         #checking result
28 |         time.sleep(3)
29 |         task_result = self.wait_for_result(600)
30 |         if task_result == 0:
31 |             return 0
32 |         else:
33 |             return task_result["solution"]["token"]
34 | 
35 |     def set_js_api_domain(self, value):
36 |         self.js_api_domain = value
37 | 
38 |     def set_data_blob(self, value):
39 |         self.data_blob = value
40 | 
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/funcaptchaproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class funcaptchaProxyon(antiNetworking):
 6 | 
 7 |     js_api_domain = ""
 8 |     data_blob = ""
 9 | 
10 |     def solve_and_return_solution(self):
11 |         if self.create_task({
12 |             "clientKey": self.client_key,
13 |             "task": {
14 |                 "type": "FunCaptchaTask",
15 |                 "websiteURL": self.website_url,
16 |                 "funcaptchaApiJSSubdomain": self.js_api_domain,
17 |                 "data": self.data_blob,
18 |                 "websitePublicKey": self.website_key,
19 |                 "proxyType": self.proxy_type,
20 |                 "proxyAddress": self.proxy_address,
21 |                 "proxyPort": self.proxy_port,
22 |                 "proxyLogin": self.proxy_login,
23 |                 "proxyPassword": self.proxy_password,
24 |                 "userAgent": self.user_agent
25 |             },
26 |             "softId": self.soft_id
27 |         }) == 1:
28 |             self.log("created task with id "+str(self.task_id))
29 |         else:
30 |             self.log("could not create task")
31 |             self.log(self.err_string)
32 |             return 0
33 |         #checking result
34 |         time.sleep(3)
35 |         task_result = self.wait_for_result(600)
36 |         if task_result == 0:
37 |             return 0
38 |         else:
39 |             return task_result["solution"]["token"]
40 | 
41 |     def set_js_api_domain(self, value):
42 |         self.js_api_domain = value
43 | 
44 |     def set_data_blob(self, value):
45 |         self.data_blob = value
46 | 
47 | 
48 | 
49 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/geetestproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class geetestProxyless(antiNetworking):
 6 | 
 7 |     js_api_domain = ""
 8 |     gt = ""
 9 |     challenge = ""
10 |     geetest_lib = ""
11 |     version = 3
12 |     init_parameters = {}
13 | 
14 |     def solve_and_return_solution(self):
15 |         if self.create_task({
16 |             "clientKey": self.client_key,
17 |             "task": {
18 |                 "type": "GeeTestTaskProxyless",
19 |                 "websiteURL": self.website_url,
20 |                 "gt": self.gt,
21 |                 "challenge": self.challenge,
22 |                 "geetestApiServerSubdomain": self.js_api_domain,
23 |                 "geetestGetLib": self.geetest_lib,
24 |                 "version": self.version,
25 |                 "initParameters": self.init_parameters
26 |             },
27 |             "softId": self.soft_id
28 |         }) == 1:
29 |             self.log("created task with id "+str(self.task_id))
30 |         else:
31 |             self.log("could not create task")
32 |             self.log(self.err_string)
33 |             return 0
34 |         #checking result
35 |         time.sleep(3)
36 |         task_result = self.wait_for_result(600)
37 |         if task_result == 0:
38 |             return 0
39 |         else:
40 |             return task_result["solution"]
41 | 
42 |     def set_gt_key(self, value):
43 |         self.gt = value
44 | 
45 |     def set_challenge_key(self, value):
46 |         self.challenge = value
47 | 
48 |     def set_js_api_domain(self, value):
49 |         self.js_api_domain = value
50 | 
51 |     def set_geetest_lib(self, value):
52 |         self.geetest_lib = value
53 | 
54 |     def set_version(self, value):
55 |         self.version = value
56 | 
57 |     def set_init_parameters(self, object):
58 |         self.init_parameters = object
59 | 
60 | 
61 | 
62 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/geetestproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class geetestProxyon(antiNetworking):
 6 | 
 7 |     js_api_domain = ""
 8 |     gt = ""
 9 |     challenge = ""
10 |     geetest_lib = ""
11 |     version = 3
12 |     init_parameters = {}
13 | 
14 |     def solve_and_return_solution(self):
15 |         if self.create_task({
16 |             "clientKey": self.client_key,
17 |             "task": {
18 |                 "type": "GeeTestTask",
19 |                 "websiteURL": self.website_url,
20 |                 "gt": self.gt,
21 |                 "challenge": self.challenge,
22 |                 "geetestApiServerSubdomain": self.js_api_domain,
23 |                 "geetestGetLib": self.geetest_lib,
24 |                 "version": self.version,
25 |                 "initParameters": self.init_parameters,
26 |                 "proxyType": self.proxy_type,
27 |                 "proxyAddress": self.proxy_address,
28 |                 "proxyPort": self.proxy_port,
29 |                 "proxyLogin": self.proxy_login,
30 |                 "proxyPassword": self.proxy_password,
31 |                 "userAgent": self.user_agent
32 |             },
33 |             "softId": self.soft_id
34 |         }) == 1:
35 |             self.log("created task with id "+str(self.task_id))
36 |         else:
37 |             self.log("could not create task")
38 |             self.log(self.err_string)
39 |             return 0
40 |         #checking result
41 |         time.sleep(3)
42 |         task_result = self.wait_for_result(600)
43 |         if task_result == 0:
44 |             return 0
45 |         else:
46 |             return task_result["solution"]
47 | 
48 |     def set_gt_key(self, value):
49 |         self.gt = value
50 | 
51 |     def set_challenge_key(self, value):
52 |         self.challenge = value
53 | 
54 |     def set_js_api_domain(self, value):
55 |         self.js_api_domain = value
56 | 
57 |     def set_geetest_lib(self, value):
58 |         self.geetest_lib = value
59 | 
60 |     def set_version(self, value):
61 |         self.version = value
62 | 
63 |     def set_init_parameters(self, object):
64 |         self.init_parameters = object
65 | 
66 | 
67 | 
68 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/hcaptchaproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class hCaptchaProxyless(antiNetworking):
 6 | 
 7 |     respkey = ""
 8 | 
 9 |     def get_user_agent(self):
10 |         return self.user_agent
11 | 
12 |     def get_respkey(self):
13 |         return self.respkey
14 | 
15 |     def solve_and_return_solution(self):
16 |         if self.create_task({
17 |             "clientKey": self.client_key,
18 |             "task": {
19 |                 "type": "HCaptchaTaskProxyless",
20 |                 "websiteURL": self.website_url,
21 |                 "websiteKey": self.website_key,
22 |                 "userAgent": self.user_agent,
23 |                 "isInvisible": self.is_invisible,
24 |                 "enterprisePayload": self.recaptcha_enterprise_payload
25 |             },
26 |             "softId": self.soft_id
27 |         }) == 1:
28 |             self.log("created task with id "+str(self.task_id))
29 |         else:
30 |             self.log("could not create task")
31 |             self.log(self.err_string)
32 |             return 0
33 |         #checking result
34 |         time.sleep(3)
35 |         task_result = self.wait_for_result(300)
36 |         if task_result == 0:
37 |             return 0
38 |         else:
39 |             if "userAgent" in task_result["solution"]:
40 |                 self.user_agent = task_result["solution"]["userAgent"]
41 |             if "respKey" in task_result["solution"]:
42 |                 self.respkey = task_result["solution"]["respKey"]
43 |             return task_result["solution"]["gRecaptchaResponse"]
44 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/hcaptchaproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class hCaptchaProxyon(antiNetworking):
 6 | 
 7 |     respkey = ""
 8 | 
 9 |     def get_user_agent(self):
10 |         return self.user_agent
11 | 
12 |     def get_respkey(self):
13 |         return self.respkey
14 | 
15 |     def solve_and_return_solution(self):
16 |         if self.create_task({
17 |             "clientKey": self.client_key,
18 |             "task": {
19 |                 "type": "HCaptchaTask",
20 |                 "websiteURL": self.website_url,
21 |                 "websiteKey": self.website_key,
22 |                 "proxyType": self.proxy_type,
23 |                 "proxyAddress": self.proxy_address,
24 |                 "proxyPort": self.proxy_port,
25 |                 "proxyLogin": self.proxy_login,
26 |                 "proxyPassword": self.proxy_password,
27 |                 "userAgent": self.user_agent,
28 |                 "cookies": self.cookies,
29 |                 "isInvisible": self.is_invisible,
30 |                 "enterprisePayload": self.recaptcha_enterprise_payload
31 |             },
32 |             "softId": self.soft_id
33 |         }) == 1:
34 |             self.log("created task with id "+str(self.task_id))
35 |         else:
36 |             self.log("could not create task")
37 |             self.log(self.err_string)
38 |             return 0
39 |         #checking result
40 |         time.sleep(3)
41 |         task_result = self.wait_for_result(300)
42 |         if task_result == 0:
43 |             return 0
44 |         else:
45 |             if "userAgent" in task_result["solution"]:
46 |                 self.user_agent = task_result["solution"]["userAgent"]
47 |             if "respKey" in task_result["solution"]:
48 |                 self.respkey = task_result["solution"]["respKey"]
49 |             return task_result["solution"]["gRecaptchaResponse"]
50 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/imagecaptcha.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | from base64 import b64encode
 3 | 
 4 | 
 5 | class imagecaptcha(antiNetworking):
 6 | 
 7 |     language_pool = "en"
 8 | 
 9 |     def set_language_pool(self, pool_name):
10 |         self.language_pool = pool_name
11 | 
12 |     def solve_and_return_solution(self, file_path, **kwargs):
13 |         """
14 |         :param file_path: path to captcha image on disk
15 |         :param kwargs: contains key-value pairs for updating task_data dict
16 |         """
17 |         if file_path is not None:
18 |             with open(file_path, 'rb') as img:
19 |                 img_str = img.read()
20 |                 img_str = b64encode(img_str).decode('ascii')
21 |         else:
22 |             img_str = kwargs.get('body')
23 |             if type(img_str) is bytes:
24 |                 img_str = b64encode(img_str).decode('ascii')
25 |                 kwargs.update({'body': img_str})
26 | 
27 |         if file_path is None and img_str is None:
28 |             self.log("file_path or body (in kwargs) has to be provided")
29 |             return 0
30 | 
31 |         task_data = {
32 |             "type": "ImageToTextTask",
33 |             "body": img_str,
34 |             "phrase": self.phrase,
35 |             "case": self.case,
36 |             "numeric": self.numeric,
37 |             "math": self.math,
38 |             "minLength": self.minLength,
39 |             "maxLength": self.maxLength,
40 |             "comment": self.comment,
41 |             "languagePool": self.language_pool
42 |         }
43 |         task_data.update(kwargs)
44 |         if self.create_task({
45 |             "clientKey": self.client_key,
46 |             "task": task_data,
47 |             "softId": self.soft_id
48 |         }) == 1:
49 |             self.log("created task with id "+str(self.task_id))
50 |         else:
51 |             self.log("could not create task")
52 |             self.log(self.err_string)
53 |             return 0
54 | 
55 |         task_result = self.wait_for_result(60)
56 |         if task_result == 0:
57 |             return 0
58 |         else:
59 |             return task_result["solution"]["text"]
60 | 
61 | 
62 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/imagetocoordinates.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | from base64 import b64encode
 3 | 
 4 | 
 5 | class imagetocoordinates(antiNetworking):
 6 | 
 7 |     solve_mode = "points"
 8 | 
 9 |     def solve_and_return_solution(self, file_path, **kwargs):
10 |         """
11 |         :param file_path: path to captcha image on disk
12 |         :param kwargs: contains key-value pairs for updating task_data dict
13 |         """
14 |         if file_path is not None:
15 |             with open(file_path, 'rb') as img:
16 |                 img_str = img.read()
17 |                 img_str = b64encode(img_str).decode('ascii')
18 |         else:
19 |             img_str = kwargs.get('body')
20 |             if type(img_str) is bytes:
21 |                 img_str = b64encode(img_str).decode('ascii')
22 |                 kwargs.update({'body': img_str})
23 | 
24 |         if file_path is None and img_str is None:
25 |             self.log("file_path or body (in kwargs) has to be provided")
26 |             return 0
27 | 
28 |         task_data = {
29 |             "type": "ImageToCoordinatesTask",
30 |             "body": img_str,
31 |             "mode": self.solve_mode,
32 |             "comment": self.comment
33 |         }
34 |         task_data.update(kwargs)
35 |         if self.create_task({
36 |             "clientKey": self.client_key,
37 |             "task": task_data,
38 |             "softId": self.soft_id
39 |         }) == 1:
40 |             self.log("created task with id "+str(self.task_id))
41 |         else:
42 |             self.log("could not create task")
43 |             self.log(self.err_string)
44 |             return 0
45 | 
46 |         task_result = self.wait_for_result(60)
47 |         if task_result == 0:
48 |             return 0
49 |         else:
50 |             return task_result["solution"]["coordinates"]
51 | 
52 |     def set_mode(self, value):
53 |         if value in ["points", "rectangles"]:
54 |             self.solve_mode = value
55 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/prosopoproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class prosopoProxyless(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "ProsopoTaskProxyless",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key
12 |         }
13 |         if self.create_task({
14 |             "clientKey": self.client_key,
15 |             "task": task,
16 |             "softId": self.soft_id
17 |         }) == 1:
18 |             self.log("created task with id "+str(self.task_id))
19 |         else:
20 |             self.log("could not create task")
21 |             self.log(self.err_string)
22 |             return 0
23 |         time.sleep(3)
24 |         task_result = self.wait_for_result(300)
25 |         if task_result == 0:
26 |             return 0
27 |         else:
28 |             return task_result["solution"]["token"]
29 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/prosopoproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class prosopoProxyon(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "ProsopoTask",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key,
12 |             "proxyType": self.proxy_type,
13 |             "proxyAddress": self.proxy_address,
14 |             "proxyPort": self.proxy_port,
15 |             "proxyLogin": self.proxy_login,
16 |             "proxyPassword": self.proxy_password
17 |         }
18 |         if self.is_invisible:
19 |             task['isInvisible'] = True
20 |         if self.create_task({
21 |             "clientKey": self.client_key,
22 |             "task": task,
23 |             "softId": self.soft_id
24 |         }) == 1:
25 |             self.log("created task with id "+str(self.task_id))
26 |         else:
27 |             self.log("could not create task")
28 |             self.log(self.err_string)
29 |             return 0
30 |         #checking result
31 |         time.sleep(3)
32 |         task_result = self.wait_for_result(300)
33 |         if task_result == 0:
34 |             return 0
35 |         else:
36 |             return task_result["solution"]["token"]
37 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav2enterpriseproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV2EnterpriseProxyless(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         if self.create_task({
 9 |             "clientKey": self.client_key,
10 |             "task": {
11 |                 "type": "RecaptchaV2EnterpriseTaskProxyless",
12 |                 "websiteURL": self.website_url,
13 |                 "websiteKey": self.website_key,
14 |                 "enterprisePayload": self.recaptcha_enterprise_payload
15 |             },
16 |             "softId": self.soft_id
17 |         }) == 1:
18 |             self.log("created task with id "+str(self.task_id))
19 |         else:
20 |             self.log("could not create task")
21 |             self.log(self.err_string)
22 |             return 0
23 |         #checking result
24 |         time.sleep(3)
25 |         task_result = self.wait_for_result(300)
26 |         if task_result == 0:
27 |             return 0
28 |         else:
29 |             return task_result["solution"]["gRecaptchaResponse"]
30 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav2enterpriseproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV2EnterpriseProxyon(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         if self.create_task({
 9 |             "clientKey": self.client_key,
10 |             "task": {
11 |                 "type": "RecaptchaV2EnterpriseTask",
12 |                 "websiteURL": self.website_url,
13 |                 "websiteKey": self.website_key,
14 |                 "enterprisePayload": self.recaptcha_enterprise_payload,
15 |                 "proxyType": self.proxy_type,
16 |                 "proxyAddress": self.proxy_address,
17 |                 "proxyPort": self.proxy_port,
18 |                 "proxyLogin": self.proxy_login,
19 |                 "proxyPassword": self.proxy_password,
20 |                 "userAgent": self.user_agent,
21 |                 "cookies": self.cookies
22 |             },
23 |             "softId": self.soft_id
24 |         }) == 1:
25 |             self.log("created task with id "+str(self.task_id))
26 |         else:
27 |             self.log("could not create task")
28 |             self.log(self.err_string)
29 |             return 0
30 |         #checking result
31 |         time.sleep(3)
32 |         task_result = self.wait_for_result(300)
33 |         if task_result == 0:
34 |             return 0
35 |         else:
36 |             return task_result["solution"]["gRecaptchaResponse"]
37 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav2proxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV2Proxyless(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "RecaptchaV2TaskProxyless",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key,
12 |             "websiteSToken": self.website_stoken,
13 |             "recaptchaDataSValue": self.recaptcha_data_s
14 |         }
15 |         if self.is_invisible:
16 |             task['isInvisible'] = True
17 |         if self.create_task({
18 |             "clientKey": self.client_key,
19 |             "task": task,
20 |             "softId": self.soft_id
21 |         }) == 1:
22 |             self.log("created task with id "+str(self.task_id))
23 |         else:
24 |             self.log("could not create task")
25 |             self.log(self.err_string)
26 |             return 0
27 |         #checking result
28 |         time.sleep(3)
29 |         task_result = self.wait_for_result(300)
30 |         if task_result == 0:
31 |             return 0
32 |         else:
33 |             return task_result["solution"]["gRecaptchaResponse"]
34 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav2proxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV2Proxyon(antiNetworking):
 6 | 
 7 |     def solve_and_return_solution(self):
 8 |         task = {
 9 |             "type": "RecaptchaV2Task",
10 |             "websiteURL": self.website_url,
11 |             "websiteKey": self.website_key,
12 |             "websiteSToken": self.website_stoken,
13 |             "recaptchaDataSValue": self.recaptcha_data_s,
14 |             "proxyType": self.proxy_type,
15 |             "proxyAddress": self.proxy_address,
16 |             "proxyPort": self.proxy_port,
17 |             "proxyLogin": self.proxy_login,
18 |             "proxyPassword": self.proxy_password,
19 |             "userAgent": self.user_agent,
20 |             "cookies": self.cookies
21 |         }
22 |         if self.is_invisible:
23 |             task['isInvisible'] = True
24 |         if self.create_task({
25 |             "clientKey": self.client_key,
26 |             "task": task,
27 |             "softId": self.soft_id
28 |         }) == 1:
29 |             self.log("created task with id "+str(self.task_id))
30 |         else:
31 |             self.log("could not create task")
32 |             self.log(self.err_string)
33 |             return 0
34 |         #checking result
35 |         time.sleep(3)
36 |         task_result = self.wait_for_result(300)
37 |         if task_result == 0:
38 |             return 0
39 |         else:
40 |             return task_result["solution"]["gRecaptchaResponse"]
41 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav3enterpriseproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV3EnterpriseProxyless(antiNetworking):
 6 | 
 7 |     min_score = 0.9
 8 |     page_action = ""
 9 | 
10 |     def solve_and_return_solution(self):
11 |         if self.create_task({
12 |             "clientKey": self.client_key,
13 |             "task": {
14 |                 "type": "RecaptchaV3TaskProxyless",
15 |                 "websiteURL": self.website_url,
16 |                 "websiteKey": self.website_key,
17 |                 "minScore": self.min_score,
18 |                 "pageAction": self.page_action,
19 |                 "isEnterprise": True
20 |             },
21 |             "softId": self.soft_id
22 |         }) == 1:
23 |             self.log("created task with id "+str(self.task_id))
24 |         else:
25 |             self.log("could not create task")
26 |             self.log(self.err_string)
27 |             return 0
28 |         #checking result
29 |         time.sleep(3)
30 |         task_result = self.wait_for_result(60)
31 |         if task_result == 0:
32 |             return 0
33 |         else:
34 |             return task_result["solution"]["gRecaptchaResponse"]
35 | 
36 |     def set_page_action(self, value):
37 |         self.page_action = value
38 | 
39 |     def set_min_score(self, value):
40 |         available_scores = [0.5, 0.7, 0.9]
41 |         if value in available_scores:
42 |             self.min_score = value
43 |         else:
44 |             self.min_score = 0.9
45 | 
46 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/recaptchav3proxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class recaptchaV3Proxyless(antiNetworking):
 6 | 
 7 |     min_score = 0.9
 8 |     page_action = ""
 9 | 
10 |     def solve_and_return_solution(self):
11 |         if self.create_task({
12 |             "clientKey": self.client_key,
13 |             "task": {
14 |                 "type": "RecaptchaV3TaskProxyless",
15 |                 "websiteURL": self.website_url,
16 |                 "websiteKey": self.website_key,
17 |                 "minScore": self.min_score,
18 |                 "pageAction": self.page_action
19 |             },
20 |             "softId": self.soft_id
21 |         }) == 1:
22 |             self.log("created task with id "+str(self.task_id))
23 |         else:
24 |             self.log("could not create task")
25 |             self.log(self.err_string)
26 |             return 0
27 |         #checking result
28 |         time.sleep(3)
29 |         task_result = self.wait_for_result(60)
30 |         if task_result == 0:
31 |             return 0
32 |         else:
33 |             return task_result["solution"]["gRecaptchaResponse"]
34 | 
35 |     def set_page_action(self, value):
36 |         self.page_action = value
37 | 
38 |     def set_min_score(self, value):
39 |         available_scores = [0.5, 0.7, 0.9]
40 |         if value in available_scores:
41 |             self.min_score = value
42 |         else:
43 |             self.min_score = 0.9
44 | 
45 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/turnstileproxyless.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class turnstileProxyless(antiNetworking):
 6 | 
 7 |     action = ''
 8 |     cdata = ''
 9 |     chlpagedata = ''
10 | 
11 |     def set_action(self, action):
12 |         self.action = action
13 | 
14 |     def set_cdata(self, value):
15 |         self.cdata = value
16 | 
17 |     def set_chlpagedata(self, value):
18 |         self.chlpagedata = value
19 | 
20 |     def solve_and_return_solution(self):
21 |         task = {
22 |             "type": "TurnstileTaskProxyless",
23 |             "websiteURL": self.website_url,
24 |             "websiteKey": self.website_key,
25 |             "action": self.action,
26 |             "cData": self.cdata,
27 |             "chlPageData": self.chlpagedata
28 |         }
29 |         if self.create_task({
30 |             "clientKey": self.client_key,
31 |             "task": task,
32 |             "softId": self.soft_id
33 |         }) == 1:
34 |             self.log("created task with id "+str(self.task_id))
35 |         else:
36 |             self.log("could not create task")
37 |             self.log(self.err_string)
38 |             return 0
39 |         time.sleep(3)
40 |         task_result = self.wait_for_result(300)
41 |         if task_result == 0:
42 |             return 0
43 |         else:
44 |             return task_result["solution"]["token"]
45 | 


--------------------------------------------------------------------------------
/anticaptchaofficial/turnstileproxyon.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antinetworking import *
 2 | import time
 3 | 
 4 | 
 5 | class turnstileProxyon(antiNetworking):
 6 | 
 7 |     action = ''
 8 |     cdata = ''
 9 |     chlpagedata = ''
10 | 
11 |     def set_action(self, action):
12 |         self.action = action
13 | 
14 |     def set_cdata(self, value):
15 |         self.cdata = value
16 | 
17 |     def set_chlpagedata(self, value):
18 |         self.chlpagedata = value
19 | 
20 |     def solve_and_return_solution(self):
21 |         task = {
22 |             "type": "TurnstileTask",
23 |             "websiteURL": self.website_url,
24 |             "websiteKey": self.website_key,
25 |             "action": self.action,
26 |             "cData": self.cdata,
27 |             "chlPageData": self.chlpagedata,
28 |             "proxyType": self.proxy_type,
29 |             "proxyAddress": self.proxy_address,
30 |             "proxyPort": self.proxy_port,
31 |             "proxyLogin": self.proxy_login,
32 |             "proxyPassword": self.proxy_password
33 |         }
34 |         if self.is_invisible:
35 |             task['isInvisible'] = True
36 |         if self.create_task({
37 |             "clientKey": self.client_key,
38 |             "task": task,
39 |             "softId": self.soft_id
40 |         }) == 1:
41 |             self.log("created task with id "+str(self.task_id))
42 |         else:
43 |             self.log("could not create task")
44 |             self.log(self.err_string)
45 |             return 0
46 |         #checking result
47 |         time.sleep(3)
48 |         task_result = self.wait_for_result(300)
49 |         if task_result == 0:
50 |             return 0
51 |         else:
52 |             return task_result["solution"]["token"]
53 | 


--------------------------------------------------------------------------------
/antigate_2fa_delay_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antigatetask import *
 2 | import time
 3 | 
 4 | solver = antigateTask()
 5 | solver.set_verbose(1)
 6 | solver.set_key("YOUR_KEY")
 7 | solver.set_website_url("http://antigate.com/logintest2fa.php")
 8 | solver.set_template_name("Sign-in with 2FA and wait for control text")
 9 | solver.set_variables({
10 |     "login_input_css": "#login",
11 |     "login_input_value": "test login",
12 |     "password_input_css": "#password",
13 |     "password_input_value": "test password",
14 |     "2fa_input_css": "#2facode",
15 |     "2fa_input_value": "_WAIT_FOR_IT_",
16 |     "control_text": "You have been logged successfully"
17 | })
18 | 
19 | # Specify softId to earn 10% commission with your app.
20 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
21 | solver.set_soft_id(0)
22 | 
23 | task_id  = solver.send_antigate_task()
24 | if task_id == 0:
25 |     print("could not create task")
26 |     exit()
27 | 
28 | time.sleep(5)  # emulating actual 2fa retrieval
29 | solver.push_variable(task_id, "2fa_input_value", "349001")
30 | result = solver.wait_for_result(600)
31 | 
32 | if result != 0:
33 |     cookies, localStorage, fingerprint, url, domain = result["cookies"], result["localStorage"], result["fingerprint"], result["url"], result["domain"]
34 |     print("cookies: ", cookies)
35 |     print("localStorage: ", localStorage)
36 |     print("fingerprint: ", fingerprint)
37 |     print("url: "+url)
38 |     print("domain: "+domain)
39 | else:
40 |     print("task finished with error "+solver.error_code)
41 | 


--------------------------------------------------------------------------------
/antigate_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.antigatetask import *
 2 | 
 3 | solver = antigateTask()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("http://antigate.com/logintest.php")
 7 | solver.set_template_name("Sign-in and wait for control text")
 8 | solver.set_variables({
 9 |     "login_input_css": "#login",
10 |     "login_input_value": "test login",
11 |     "password_input_css": "#password",
12 |     "password_input_value": "test password",
13 |     "control_text": "You have been logged successfully"
14 | })
15 | # optional if you want to collect cookies from domains other than task URL
16 | solver.set_domains_of_interest(['domain1.com', 'domain2.com'])
17 | 
18 | # Specify softId to earn 10% commission with your app.
19 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
20 | solver.set_soft_id(0)
21 | 
22 | result  = solver.solve_and_return_solution()
23 | if result != 0:
24 |     cookies, localStorage, fingerprint, url, domain = result["cookies"], result["localStorage"], result["fingerprint"], result["url"], result["domain"]
25 |     print("cookies: ", cookies)
26 |     print("localStorage: ", localStorage)
27 |     print("fingerprint: ", fingerprint)
28 |     print("url: "+url)
29 |     print("domain: "+domain)
30 | else:
31 |     print("task finished with error "+solver.error_code)
32 | 


--------------------------------------------------------------------------------
/captcha.jpeg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/anti-captcha/anticaptcha-python/52bdca82dcd678a1df87888fa30f1a7e79483a02/captcha.jpeg


--------------------------------------------------------------------------------
/check_balance_example.py:
--------------------------------------------------------------------------------
1 | from anticaptchaofficial.recaptchav2proxyless import *
2 | 
3 | solver = recaptchaV2Proxyless()
4 | solver.set_verbose(1)
5 | solver.set_key("ACCOUNT_KEY")
6 | 
7 | print("account balance: " + str(solver.get_balance()))


--------------------------------------------------------------------------------
/coordinates.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/anti-captcha/anticaptcha-python/52bdca82dcd678a1df87888fa30f1a7e79483a02/coordinates.png


--------------------------------------------------------------------------------
/funcaptcha_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.funcaptchaproxyless import *
 2 | 
 3 | solver = funcaptchaProxyless()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX")
 8 | 
 9 | # Specify softId to earn 10% commission with your app.
10 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
11 | solver.set_soft_id(0)
12 | 
13 | token = solver.solve_and_return_solution()
14 | if token != 0:
15 |     print("result token: "+token)
16 | else:
17 |     print("task finished with error "+solver.error_code)
18 | 
19 | 


--------------------------------------------------------------------------------
/funcaptcha_proxyon_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.funcaptchaproxyon import *
 2 | 
 3 | solver = funcaptchaProxyon()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX")
 8 | solver.set_proxy_address("PROXY_ADDRESS")
 9 | solver.set_proxy_port(1234)
10 | solver.set_proxy_login("proxylogin")
11 | solver.set_proxy_password("proxypassword")
12 | solver.set_user_agent("Mozilla/5.0")
13 | 
14 | # Specify softId to earn 10% commission with your app.
15 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
16 | solver.set_soft_id(0)
17 | 
18 | token = solver.solve_and_return_solution()
19 | if token != 0:
20 |     print("result token: "+token)
21 | else:
22 |     print("task finished with error "+solver.error_code)
23 | 
24 | 


--------------------------------------------------------------------------------
/geetest_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.geetestproxyless import *
 2 | 
 3 | # V3 example:
 4 | solver = geetestProxyless()
 5 | solver.set_verbose(1)
 6 | solver.set_key("YOUR_API_KEY")
 7 | solver.set_website_url("https://address.com")
 8 | solver.set_gt_key("CONSTANT_GT_KEY")
 9 | solver.set_challenge_key("VARIABLE_CHALLENGE_KEY")
10 | 
11 | # Specify softId to earn 10% commission with your app.
12 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
13 | solver.set_soft_id(0)
14 | 
15 | token = solver.solve_and_return_solution()
16 | if token != 0:
17 |     print("result tokens: ")
18 |     print(token)
19 | else:
20 |     print("task finished with error "+solver.error_code)
21 | 
22 | 
23 | # V4 example:
24 | solver = geetestProxyless()
25 | solver.set_verbose(1)
26 | solver.set_key("YOUR_API_KEY")
27 | solver.set_website_url("https://address.com")
28 | solver.set_gt_key("captchaId value")
29 | solver.set_version(4)
30 | solver.set_init_parameters({"riskType": "slide"})
31 | token = solver.solve_and_return_solution()
32 | if token != 0:
33 |     print("result tokens: ")
34 |     print(token)
35 | else:
36 |     print("task finished with error "+solver.error_code)
37 | 
38 | 


--------------------------------------------------------------------------------
/geetest_proxyon_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.geetestproxyon import *
 2 | 
 3 | # V3 example:
 4 | solver = geetestProxyon()
 5 | solver.set_verbose(1)
 6 | solver.set_key("YOUR_API_KEY")
 7 | solver.set_website_url("https://address.com")
 8 | solver.set_gt_key("CONSTANT_GT_KEY")
 9 | solver.set_challenge_key("VARIABLE_CHALLENGE_KEY")
10 | solver.set_proxy_address("PROXY_ADDRESS")
11 | solver.set_proxy_port(1234)
12 | solver.set_proxy_login("proxylogin")
13 | solver.set_proxy_password("proxypassword")
14 | solver.set_user_agent("Mozilla/5.0")
15 | 
16 | # Specify softId to earn 10% commission with your app.
17 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
18 | solver.set_soft_id(0)
19 | 
20 | token = solver.solve_and_return_solution()
21 | if token != 0:
22 |     print("result tokens: ")
23 |     print(token)
24 | else:
25 |     print("task finished with error "+solver.error_code)
26 | 
27 | 
28 | # V4 example:
29 | solver = geetestProxyon()
30 | solver.set_verbose(1)
31 | solver.set_key("YOUR_API_KEY")
32 | solver.set_website_url("https://address.com")
33 | solver.set_gt_key("captchaId value")
34 | solver.set_version(4)
35 | solver.set_init_parameters({"riskType": "slide"})
36 | solver.set_proxy_address("PROXY_ADDRESS")
37 | solver.set_proxy_port(1234)
38 | solver.set_proxy_login("proxylogin")
39 | solver.set_proxy_password("proxypassword")
40 | solver.set_user_agent("Mozilla/5.0")
41 | 
42 | token = solver.solve_and_return_solution()
43 | if token != 0:
44 |     print("result tokens: ")
45 |     print(token)
46 | else:
47 |     print("task finished with error "+solver.error_code)
48 | 
49 | 


--------------------------------------------------------------------------------
/hcaptcha_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.hcaptchaproxyless import *
 2 | 
 3 | # Non-Enterprise version
 4 | solver = hCaptchaProxyless()
 5 | solver.set_verbose(1)
 6 | solver.set_key("YOUR_KEY")
 7 | solver.set_website_url("https://website.com")
 8 | solver.set_website_key("SITE_KEY")
 9 | solver.set_user_agent("YOUR FULL USER AGENT HERE")
10 | 
11 | # Specify softId to earn 10% commission with your app.
12 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
13 | solver.set_soft_id(0)
14 | 
15 | g_response = solver.solve_and_return_solution()
16 | if g_response != 0:
17 |     print("g-response: "+g_response)
18 |     print("user-agent, use it to post the form: ", solver.get_user_agent())
19 |     print("respkey, if any: ", solver.get_respkey())
20 | else:
21 |     print("task finished with error "+solver.error_code)
22 | 
23 | 
24 | # Enterprise version
25 | solver = hCaptchaProxyless()
26 | solver.set_verbose(1)
27 | solver.set_key("YOUR_KEY")
28 | solver.set_website_url("https://website.com")
29 | solver.set_website_key("SITE_KEY")
30 | solver.set_user_agent("YOUR FULL USER AGENT HERE")
31 | solver.set_enterprise_payload({
32 |     "rqdata": "rq data value from target website",
33 |     "sentry": True,
34 |     # ... etc, see https://anti-captcha.com/apidoc/task-types/HCaptchaTaskProxyless for more
35 | })
36 | 
37 | g_response = solver.solve_and_return_solution()
38 | if g_response != 0:
39 |     print("g-response: "+g_response)
40 | else:
41 |     print("task finished with error "+solver.error_code)
42 | 


--------------------------------------------------------------------------------
/hcaptcha_proxyon_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.hcaptchaproxyon import *
 2 | 
 3 | # Non-Enterprise version
 4 | solver = hCaptchaProxyon()
 5 | solver.set_verbose(1)
 6 | solver.set_key("YOUR_KEY")
 7 | solver.set_website_url("https://website.com")
 8 | solver.set_website_key("SITE_KEY")
 9 | solver.set_proxy_address("PROXY_ADDRESS")
10 | solver.set_proxy_port(1234)
11 | solver.set_proxy_login("proxylogin")
12 | solver.set_proxy_password("proxypassword")
13 | solver.set_user_agent("Mozilla/5.0")
14 | solver.set_cookies("test=true")
15 | 
16 | # Specify softId to earn 10% commission with your app.
17 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
18 | solver.set_soft_id(0)
19 | 
20 | g_response = solver.solve_and_return_solution()
21 | if g_response != 0:
22 |     print("g-response: "+g_response)
23 |     print("user-agent, use it to post the form: ", solver.get_user_agent())
24 |     print("respkey, if any: ", solver.get_respkey())
25 | else:
26 |     print("task finished with error "+solver.error_code)
27 | 
28 | 
29 | # Enterprise version
30 | solver = hCaptchaProxyon()
31 | solver.set_verbose(1)
32 | solver.set_key("YOUR_KEY")
33 | solver.set_website_url("https://website.com")
34 | solver.set_website_key("SITE_KEY")
35 | solver.set_proxy_address("PROXY_ADDRESS")
36 | solver.set_proxy_port(1234)
37 | solver.set_proxy_login("proxylogin")
38 | solver.set_proxy_password("proxypassword")
39 | solver.set_user_agent("Mozilla/5.0")
40 | solver.set_cookies("test=true")
41 | solver.set_enterprise_payload({
42 |     "rqdata": "rq data value from target website",
43 |     "sentry": True,
44 |     # ... etc, see https://anti-captcha.com/apidoc/task-types/HCaptchaTask for more
45 | })
46 | 
47 | g_response = solver.solve_and_return_solution()
48 | if g_response != 0:
49 |     print("g-response: "+g_response)
50 | else:
51 |     print("task finished with error "+solver.error_code)
52 | 


--------------------------------------------------------------------------------
/image_captcha_body_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.imagecaptcha import *
 2 | 
 3 | solver = imagecaptcha()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | 
 7 | # example of raw image from disc or
 8 | with open('captcha.jpeg', 'rb') as img:
 9 |     raw_img = img.read()
10 | 
11 | # example of raw image from requests
12 | # import requests
13 | # ses = requests.session()
14 | # r = ses.get('url_to_captcha_image')
15 | # raw_img = r.content
16 | 
17 | captcha_text = solver.solve_and_return_solution(None, body=raw_img)
18 | if captcha_text != 0:
19 |     print("captcha text "+captcha_text)
20 | else:
21 |     print("task finished with error "+solver.error_code)
22 | 


--------------------------------------------------------------------------------
/image_captcha_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.imagecaptcha import *
 2 | 
 3 | solver = imagecaptcha()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | 
 7 | # optional parameters, see https://anti-captcha.com/apidoc/task-types/ImageToTextTask for details
 8 | # solver.set_phrase(True)                      # 2 words
 9 | # solver.set_case(True)                        # case sensitivity
10 | # solver.set_numeric(1)                        # only numbers
11 | # solver.set_minLength(1)                      # minimum captcha text length
12 | # solver.set_maxLength(10)                     # maximum captcha text length
13 | # solver.set_math(True)                        # math operation result, for captchas with text like 50+5
14 | # solver.set_comment("only green characters")  # comment for workers
15 | # solver.set_language_pool("en")               # language pool
16 | 
17 | 
18 | captcha_text = solver.solve_and_return_solution("captcha.jpeg")
19 | if captcha_text != 0:
20 |     print("captcha text "+captcha_text)
21 | else:
22 |     print("task finished with error "+solver.error_code)
23 | 


--------------------------------------------------------------------------------
/image_coordinates_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.imagecoordinates import *
 2 | 
 3 | solver = imagecoordinates()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_mode("points")
 7 | solver.set_comment("Select in specified order")
 8 | 
 9 | coordinates = solver.solve_and_return_solution("coordinates.png")
10 | if coordinates != 0:
11 |     print("coordinates: ", captcha_text)
12 | else:
13 |     print("task finished with error "+solver.error_code)
14 | 


--------------------------------------------------------------------------------
/recaptcha_v2_enterprise_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.recaptchav2enterpriseproxyless import *
 2 | 
 3 | solver = recaptchaV2EnterpriseProxyless()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("SITE_KEY")
 8 | # solver.set_enterprise_payload({"s": "sometoken"})
 9 | 
10 | # Specify softId to earn 10% commission with your app.
11 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
12 | solver.set_soft_id(0)
13 | 
14 | g_response = solver.solve_and_return_solution()
15 | if g_response != 0:
16 |     print("g-response: "+g_response)
17 | else:
18 |     print("task finished with error "+solver.error_code)
19 | 


--------------------------------------------------------------------------------
/recaptcha_v2_enterprise_proxyon_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.recaptchav2enterpriseproxyon import *
 2 | 
 3 | solver = recaptchaV2EnterpriseProxyon()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | # solver.set_enterprise_payload({"s": "sometoken"})
 7 | solver.set_website_url("https://website.com")
 8 | solver.set_website_key("SITE_KEY")
 9 | solver.set_proxy_address("PROXY_ADDRESS")
10 | solver.set_proxy_port(1234)
11 | solver.set_proxy_login("proxylogin")
12 | solver.set_proxy_password("proxypassword")
13 | solver.set_user_agent("Mozilla/5.0")
14 | solver.set_cookies("test=true")
15 | 
16 | # Specify softId to earn 10% commission with your app.
17 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
18 | solver.set_soft_id(0)
19 | 
20 | g_response = solver.solve_and_return_solution()
21 | if g_response != 0:
22 |     print("g-response: "+g_response)
23 | else:
24 |     print("task finished with error "+solver.error_code)
25 | 
26 | 


--------------------------------------------------------------------------------
/recaptcha_v2_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.recaptchav2proxyless import *
 2 | 
 3 | solver = recaptchaV2Proxyless()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("SITE_KEY")
 8 | 
 9 | # only for V2-invisible Recaptcha! :
10 | # solver.set_is_invisible(1)
11 | 
12 | # Specify softId to earn 10% commission with your app.
13 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
14 | solver.set_soft_id(0)
15 | 
16 | g_response = solver.solve_and_return_solution()
17 | if g_response != 0:
18 |     print("g-response: "+g_response)
19 | else:
20 |     print("task finished with error "+solver.error_code)
21 | 


--------------------------------------------------------------------------------
/recaptcha_v2_proxyon_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.recaptchav2proxyon import *
 2 | 
 3 | solver = recaptchaV2Proxyon()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("SITE_KEY")
 8 | solver.set_proxy_address("PROXY_ADDRESS")
 9 | solver.set_proxy_port(1234)
10 | solver.set_proxy_login("proxylogin")
11 | solver.set_proxy_password("proxypassword")
12 | solver.set_user_agent("Mozilla/5.0")
13 | solver.set_cookies("test=true")
14 | 
15 | # Specify softId to earn 10% commission with your app.
16 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
17 | solver.set_soft_id(0)
18 | 
19 | g_response = solver.solve_and_return_solution()
20 | if g_response != 0:
21 |     print("g-response: "+g_response)
22 | else:
23 |     print("task finished with error "+solver.error_code)
24 | 
25 | 


--------------------------------------------------------------------------------
/recaptcha_v3_proxyless_example.py:
--------------------------------------------------------------------------------
 1 | from anticaptchaofficial.recaptchav3proxyless import *
 2 | 
 3 | solver = recaptchaV3Proxyless()
 4 | solver.set_verbose(1)
 5 | solver.set_key("YOUR_KEY")
 6 | solver.set_website_url("https://website.com")
 7 | solver.set_website_key("SITE_KEY")
 8 | solver.set_page_action("home_page")
 9 | solver.set_min_score(0.9)
10 | 
11 | # Specify softId to earn 10% commission with your app.
12 | # Get your softId here: https://anti-captcha.com/clients/tools/devcenter
13 | solver.set_soft_id(0)
14 | 
15 | g_response = solver.solve_and_return_solution()
16 | if g_response != 0:
17 |     print("g-response: "+g_response)
18 | else:
19 |     print("task finished with error "+solver.error_code)
20 | 


--------------------------------------------------------------------------------