Update README.md

Resolve turnstile captcha (#1634 )
Fixes #804
2025-12-05 17:18:19 +01:00 · 2025-12-03 08:51:24 +00:00 · 2025-12-03 08:50:31 +00:00 · 2025-12-03 07:07:54 +00:00 · 2025-11-29 02:42:42 +00:00 · 2025-11-29 02:27:05 +00:00
30 changed files with 2074 additions and 398 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -8,6 +8,13 @@ body:
    options:
      - label: I have checked the README
        required: true
+- type: checkboxes
+  attributes:
+    label: Have you followed our Troubleshooting?
+    description: Please follow our <a href="https://github.com/FlareSolverr/FlareSolverr/wiki/Troubleshooting">Troubleshooting</a>.
+    options:
+      - label: I have followed your Troubleshooting
+        required: true
 - type: checkboxes
  attributes:
    label: Is there already an issue for your problem?
@@ -22,6 +29,13 @@ body:
    options:
      - label: I have read the Discussions
        required: true
+- type: input
+  attributes:
+    label: Have you ACTUALLY checked all these?
+    description: Please do not waste our time and yours; these checks are there for a reason, it is not just so you can tick boxes for fun. If you type <b>YES</b> and it is clear you did not or have put in no effort, your issue will be closed and locked without comment. If you type <b>NO</b> but still open this issue, you will be permanently blocked for timewasting.
+    placeholder: YES or NO
+  validations:
+    required: true
 - type: textarea
  attributes:
    label: Environment
--- a/.github/workflows/autotag.yml
+++ b/.github/workflows/autotag.yml
@@ -1,4 +1,4 @@
-name: autotag
+name: Autotag

 on:
  push:
@@ -6,14 +6,13 @@ on:
      - "master"

 jobs:
-  build:
+  tag-release:
    runs-on: ubuntu-latest
    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Auto Tag
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Auto Tag
        uses: Klemensas/action-autotag@stable
        with:
          GITHUB_TOKEN: "${{ secrets.GH_PAT }}"
--- a/.github/workflows/release-docker.yml
+++ b/.github/workflows/release-docker.yml
@@ -1,53 +1,67 @@
-name: release-docker
+name: Docker release

 on:
  push:
    tags:
-      - 'v*.*.*'
+      - "v*.*.*"
+  pull_request:
+    branches:
+      - master
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true

 jobs:
-  build:
+  build-docker-images:
+    if: ${{ !github.event.pull_request.head.repo.fork }}
    runs-on: ubuntu-latest
    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v3
-      -
-        name: Downcase repo
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Downcase repo
        run: echo REPOSITORY=$(echo ${{ github.repository }} | tr '[:upper:]' '[:lower:]') >> $GITHUB_ENV
-      -
-        name: Docker meta
+
+      - name: Docker meta
        id: docker_meta
-        uses: crazy-max/ghaction-docker-meta@v3
+        uses: docker/metadata-action@v5
        with:
-          images: ${{ env.REPOSITORY }},ghcr.io/${{ env.REPOSITORY }}
-          tag-sha: false
-      -
-        name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
-      -
-        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-      -
-        name: Login to DockerHub
-        uses: docker/login-action@v2
+          images: |
+            ${{ env.REPOSITORY }},enable=${{ github.event_name != 'pull_request' }}
+            ghcr.io/${{ env.REPOSITORY }}
+          tags: |
+            type=semver,pattern={{version}},prefix=v
+            type=ref,event=pr
+          flavor: |
+            latest=auto
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      -
-        name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GH_PAT }}
-      -
-        name: Build and push
-        uses: docker/build-push-action@v3
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
        with:
          context: .
          file: ./Dockerfile
          platforms: linux/386,linux/amd64,linux/arm/v7,linux/arm64/v8
-          push: ${{ github.event_name != 'pull_request' }}
+          push: true
          tags: ${{ steps.docker_meta.outputs.tags }}
          labels: ${{ steps.docker_meta.outputs.labels }}
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -1,55 +1,63 @@
-name: release
+name: Release

 on:
  push:
    tags:
-      - 'v*.*.*'
+      - "v*.*.*"

 jobs:
-  build:
+  create-release:
    name: Create release
    runs-on: ubuntu-latest
    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
+      - name: Checkout repository
+        uses: actions/checkout@v5
        with:
-          fetch-depth: 0 # get all commits, branches and tags (required for the changelog)
-
-      - name: Setup Node
-        uses: actions/setup-node@v3
-        with:
-          node-version: '16'
-
-      - name: Build artifacts
-        run: |
-          npm install
-          npm run build
-          npm run package
+          fetch-depth: 0

      - name: Build changelog
        id: github_changelog
        run: |
          changelog=$(git log $(git tag | tail -2 | head -1)..HEAD --no-merges --oneline)
-          changelog="${changelog//'%'/'%25'}"
-          changelog="${changelog//$'\n'/'%0A'}"
-          changelog="${changelog//$'\r'/'%0D'}"
-          echo "##[set-output name=changelog;]${changelog}"
+          echo "changelog<<EOF" >> $GITHUB_OUTPUT
+          echo "$changelog" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT

      - name: Create release
-        id: create_release
-        uses: actions/create-release@v1
+        uses: softprops/action-gh-release@v2
+        with:
+          body: ${{ steps.github_changelog.outputs.changelog }}
        env:
          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
+
+  build-package:
+    name: Build binaries
+    needs: create-release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
        with:
-          tag_name: ${{ github.ref }}
-          release_name: ${{ github.ref }}
-          body: ${{ steps.github_changelog.outputs.changelog }}
-          draft: false
-          prerelease: false
+          fetch-depth: 0
+
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - name: Build artifacts
+        run: |
+          python -m pip install -r requirements.txt
+          python -m pip install pyinstaller==6.16.0
+          cd src
+          python build_package.py

      - name: Upload release artifacts
-        uses: alexellis/upload-assets@0.2.2
+        uses: softprops/action-gh-release@v2
+        with:
+          files: ./dist/flaresolverr_*
        env:
          GITHUB_TOKEN: ${{ secrets.GH_PAT }}
-        with:
-          asset_paths: '["./bin/*.zip"]'
--- a/.gitignore
+++ b/.gitignore
@@ -25,6 +25,7 @@ __pycache__/
 build/
 develop-eggs/
 dist/
+dist_chrome/
 downloads/
 eggs/
 .eggs/
@@ -123,3 +124,6 @@ venv.bak/
 .mypy_cache/
 .dmypy.json
 dmypy.json
+
+# node
+node_modules/
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,217 @@
 # Changelog

+## v3.4.6 (2025/11/29)
+* Add disable image, css, fonts option with CDP. Thanks @Ananto30
+
+## v3.4.5 (2025/11/11)
+* Revert to Python v3.13
+
+## v3.4.4 (2025/11/04)
+* Bump dependencies, Chromium, and some other general fixes. Thanks @flowerey
+
+## v3.4.3 (2025/10/28)
+* Update proxy extension
+
+## v3.4.2 (2025/10/09)
+* Bump dependencies & CI actions. Thanks @flowerey
+* Add optional wait time after resolving the challenge before returning. Thanks @kennedyoliveira
+* Add proxy ENVs. Thanks @Robokishan
+* Handle empty string and keys without value in postData. Thanks @eZ4RK0
+* Add quote protection for password containing it. Thanks @warrenberberd
+* Add returnScreenshot parameter to screenshot the final web page. Thanks @estebanthi
+* Add log file support. Thanks @acg5159
+
+## v3.4.1 (2025/09/15)
+* Fix regex pattern syntax in utils.py
+* Change access denied title check to use startswith
+
+## v3.4.0 (2025/08/25)
+* Modernize and upgrade application. Thanks @TheCrazyLex
+* Remove disable software rasterizer option for ARM builds. Thanks @smrodman83
+
+## v3.3.25 (2025/06/14)
+* Remove `use-gl` argument. Thanks @qwerty12
+* u_c: remove apparent c&p typo. Thanks @ok3721
+* Bump requirements
+
+## v3.3.24 (2025/06/04)
+* Remove hidden character
+
+## v3.3.23 (2025/06/04)
+* Update base image to bookworm. Thanks @rwjack
+
+## v3.3.22 (2025/06/03)
+* Disable search engine choice screen
+* Fix headless=false stalling. Thanks @MAKMED1337
+* Change from click to keys. Thanks @sh4dowb
+* Don't open devtools
+* Bump Chromium to v137 for build
+* Bump requirements
+
+## v3.3.21 (2024/06/26)
+* Add challenge selector to catch reloading page on non-English systems
+* Escape values for generated form used in request.post. Thanks @mynameisbogdan
+
+## v3.3.20 (2024/06/21)
+* maxTimeout should always be int
+* Check not running in Docker before logging version_main error
+* Update Cloudflare challenge and checkbox selectors. Thanks @tenettow & @21hsmw
+
+## v3.3.19 (2024/05/23)
+* Fix occasional headless issue on Linux when set to "false". Thanks @21hsmw
+
+## v3.3.18 (2024/05/20)
+
+* Fix LANG ENV for Linux
+* Fix Chrome v124+ not closing on Windows. Thanks @RileyXX
+
+## v3.3.17 (2024/04/09)
+
+* Fix file descriptor leak in service on quit(). Thanks @zkulis
+
+## v3.3.16 (2024/02/28)
+
+* Fix of the subprocess.STARTUPINFO() call. Thanks @ceconelo
+* Add FreeBSD support. Thanks @Asthowen
+* Use headless configuration properly. Thanks @hashworks
+
+## v3.3.15 (2024/02/20)
+
+* Fix looping challenges
+
+## v3.3.14-hotfix2 (2024/02/17)
+
+* Hotfix 2 - bad Chromium build, instances failed to terminate
+
+## v3.3.14-hotfix (2024/02/17)
+
+* Hotfix for Linux build - some Chrome files no longer exist
+
+## v3.3.14 (2024/02/17)
+
+* Update Chrome downloads. Thanks @opemvbs
+
+## v3.3.13 (2024/01/07)
+
+* Fix too many open files error
+
+## v3.3.12 (2023/12/15)
+
+* Fix looping challenges and invalid cookies
+
+## v3.3.11 (2023/12/11)
+
+* Update UC 3.5.4 & Selenium 4.15.2. Thanks @txtsd
+
+## v3.3.10 (2023/11/14)
+
+* Add LANG ENV - resolves issues with YGGtorrent
+
+## v3.3.9 (2023/11/13)
+
+* Fix for Docker build, capture TypeError
+
+## v3.3.8 (2023/11/13)
+
+* Fix headless=true for Chrome 117+. Thanks @NabiKAZ
+* Support running Chrome 119 from source. Thanks @koleg and @Chris7X
+* Fix "OSError: [WinError 6] The handle is invalid" on exit. Thanks @enesgorkemgenc
+
+## v3.3.7 (2023/11/05)
+
+* Bump to rebuild. Thanks @JoachimDorchies
+
+## v3.3.6 (2023/09/15)
+
+* Update checkbox selector, again
+
+## v3.3.5 (2023/09/13)
+
+* Change checkbox selector, support languages other than English
+
+## v3.3.4 (2023/09/02)
+
+* Update checkbox selector
+
+## v3.3.3 (2023/08/31)
+
+* Update undetected_chromedriver to v3.5.3
+
+## v3.3.2 (2023/08/03)
+
+* Fix URL domain in Prometheus exporter
+
+## v3.3.1 (2023/08/03)
+
+* Fix for Cloudflare verify checkbox
+* Fix HEADLESS=false in Windows binary
+* Fix Prometheus exporter for management and health endpoints
+* Remove misleading stack trace when the verify checkbox is not found
+* Revert "Update base Docker image to Debian Bookworm" #849
+* Revert "Install Chromium 115 from Debian testing" #849
+
+## v3.3.0 (2023/08/02)
+
+* Fix for new Cloudflare detection. Thanks @cedric-bour for #845
+* Add support for proxy authentication username/password. Thanks @jacobprice808	for #807
+* Implement Prometheus metrics
+* Fix Chromium Driver for Chrome / Chromium version > 114
+* Use Chromium 115 in binary packages (Windows and Linux)
+* Install Chromium 115 from Debian testing (Docker)
+* Update base Docker image to Debian Bookworm
+* Update Selenium 4.11.2
+* Update pyinstaller 5.13.0
+* Add more traces in build_package.py
+
+## v3.2.2 (2023/07/16)
+
+* Workaround for updated 'verify you are human' check
+
+## v3.2.1 (2023/06/10)
+
+* Kill dead Chrome processes in Windows
+* Fix Chrome GL erros in ASUSTOR NAS
+
+## v3.2.0 (2023/05/23)
+
+* Support "proxy" param in requests and sessions
+* Support "cookies" param in requests
+* Fix Chromium exec permissions in Linux package
+* Update Python dependencies
+
+## v3.1.2 (2023/04/02)
+
+* Fix headless mode in macOS
+* Remove redundant artifact from Windows binary package
+* Bump Selenium dependency
+
+## v3.1.1 (2023/03/25)
+
+* Distribute binary executables in compressed package
+* Add icon for binary executable
+* Include information about supported architectures in the readme
+* Check Python version on start
+
+## v3.1.0 (2023/03/20)
+
+* Build binaries for Linux x64 and Windows x64
+* Sessions with auto-creation on fetch request and TTL
+* Fix error trace: Crash Reports/pending No such file or directory
+* Fix Waitress server error with asyncore_use_poll=true
+* Attempt to fix Docker ARM32 build
+* Print platform information on start up
+* Add Fairlane challenge selector
+* Update DDOS-GUARD title
+* Update dependencies
+
+## v3.0.4 (2023/03/07)
+
+* Click on the Cloudflare's 'Verify you are human' button if necessary
+
+## v3.0.3 (2023/03/06)
+
+* Update undetected_chromedriver version to 3.4.6
+
 ## v3.0.2 (2023/01/08)

 * Detect Cloudflare blocked access
--- a/28
+++ b/28
@@ -1,4 +1,4 @@
-FROM python:3.11-slim-bullseye as builder
+FROM python:3.13-slim-bookworm AS builder

 # Build dummy packages to skip installing them and their dependencies
 RUN apt-get update \
@@ -12,7 +12,7 @@ RUN apt-get update \
    && equivs-build adwaita-icon-theme \
    && mv adwaita-icon-theme_*.deb /adwaita-icon-theme.deb

-FROM python:3.11-slim-bullseye
+FROM python:3.13-slim-bookworm

 # Copy dummy packages
 COPY --from=builder /*.deb /
@@ -30,7 +30,7 @@ RUN dpkg -i /libgl1-mesa-dri.deb \
    # Install dependencies
    && apt-get update \
    && apt-get install -y --no-install-recommends chromium chromium-common chromium-driver xvfb dumb-init \
-        procps curl vim \
+        procps curl vim xauth \
    # Remove temporary files and hardware decoding libraries
    && rm -rf /var/lib/apt/lists/* \
    && rm -f /usr/lib/x86_64-linux-gnu/libmfxhw* \
@@ -38,7 +38,12 @@ RUN dpkg -i /libgl1-mesa-dri.deb \
    # Create flaresolverr user
    && useradd --home-dir /app --shell /bin/sh flaresolverr \
    && mv /usr/bin/chromedriver chromedriver \
-    && chown -R flaresolverr:flaresolverr .
+    && chown -R flaresolverr:flaresolverr . \
+    # Create config dir
+    && mkdir /config \
+    && chown flaresolverr:flaresolverr /config
+
+VOLUME /config

 # Install Python dependencies
 COPY requirements.txt .
@@ -48,10 +53,13 @@ RUN pip install -r requirements.txt \

 USER flaresolverr

+RUN mkdir -p "/app/.config/chromium/Crash Reports/pending"
+
 COPY src .
 COPY package.json ../

 EXPOSE 8191
+EXPOSE 8192

 # dumb-init avoids zombie chromium processes
 ENTRYPOINT ["/usr/bin/dumb-init", "--"]
@@ -59,11 +67,17 @@ ENTRYPOINT ["/usr/bin/dumb-init", "--"]
 CMD ["/usr/local/bin/python", "-u", "/app/flaresolverr.py"]

 # Local build
-# docker build -t ngosang/flaresolverr:3.0.0 .
-# docker run -p 8191:8191 ngosang/flaresolverr:3.0.0
+# docker build -t ngosang/flaresolverr:3.4.6 .
+# docker run -p 8191:8191 ngosang/flaresolverr:3.4.6

 # Multi-arch build
 # docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
 # docker buildx create --use
-# docker buildx build -t ngosang/flaresolverr:3.0.0 --platform linux/386,linux/amd64,linux/arm/v7,linux/arm64/v8 .
+# docker buildx build -t ngosang/flaresolverr:3.4.6 --platform linux/386,linux/amd64,linux/arm/v7,linux/arm64/v8 .
 #   add --push to publish in DockerHub
+
+# Test multi-arch build
+# docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
+# docker buildx create --use
+# docker buildx build -t ngosang/flaresolverr:3.4.6 --platform linux/arm/v7 --load .
+# docker run -p 8191:8191 --platform linux/arm/v7 ngosang/flaresolverr:3.4.6
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2023 Diego Heras (ngosang / ngosang@hotmail.es)
+Copyright (c) 2025 Diego Heras (ngosang / ngosang@hotmail.es)

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -33,22 +33,25 @@ It is recommended to install using a Docker container because the project depend
 already included within the image.

 Docker images are available in:
-* GitHub Registry => https://github.com/orgs/FlareSolverr/packages/container/package/flaresolverr
-* DockerHub => https://hub.docker.com/r/flaresolverr/flaresolverr
+
+- GitHub Registry => https://github.com/orgs/FlareSolverr/packages/container/package/flaresolverr
+- DockerHub => https://hub.docker.com/r/flaresolverr/flaresolverr

 Supported architectures are:

 | Architecture | Tag          |
-|--------------|--------------|
+| ------------ | ------------ |
 | x86          | linux/386    |
 | x86-64       | linux/amd64  |
 | ARM32        | linux/arm/v7 |
 | ARM64        | linux/arm64  |

-We provide a `docker-compose.yml` configuration file. Clone this repository and execute `docker-compose up -d` to start
+We provide a `docker-compose.yml` configuration file. Clone this repository and execute
+`docker-compose up -d` _(Compose V1)_ or `docker compose up -d` _(Compose V2)_ to start
 the container.

 If you prefer the `docker cli` execute the following command.
+
 ```bash
 docker run -d \
  --name=flaresolverr \
@@ -64,17 +67,33 @@ Remember to restart the Docker daemon and the container after the update.

 ### Precompiled binaries

-Precompiled binaries are not currently available for v3. Please see https://github.com/FlareSolverr/FlareSolverr/issues/660 for updates,
-or below for instructions of how to build FlareSolverr from source code.
+> **Warning**
+> Precompiled binaries are only available for x64 architecture. For other architectures see Docker images.
+
+This is the recommended way for Windows users.
+
+- Download the [FlareSolverr executable](https://github.com/FlareSolverr/FlareSolverr/releases) from the release's page. It is available for Windows x64 and Linux x64.
+- Execute FlareSolverr binary. In the environment variables section you can find how to change the configuration.

 ### From source code

-* Install [Python 3.10](https://www.python.org/downloads/).
-* Install [Chrome](https://www.google.com/intl/en_us/chrome/) or [Chromium](https://www.chromium.org/getting-involved/download-chromium/) web browser.
-* (Only in Linux / macOS) Install [Xvfb](https://en.wikipedia.org/wiki/Xvfb) package.
-* Clone this repository and open a shell in that path.
-* Run `pip install -r requirements.txt` command to install FlareSolverr dependencies.
-* Run `python src/flaresolverr.py` command to start FlareSolverr.
+> **Warning**
+> Installing from source code only works for x64 architecture. For other architectures see Docker images.
+
+- Install [Python 3.13](https://www.python.org/downloads/).
+- Install [Chrome](https://www.google.com/intl/en_us/chrome/) (all OS) or [Chromium](https://www.chromium.org/getting-involved/download-chromium/) (just Linux, it doesn't work in Windows) web browser.
+- (Only in Linux) Install [Xvfb](https://en.wikipedia.org/wiki/Xvfb) package.
+- (Only in macOS) Install [XQuartz](https://www.xquartz.org/) package.
+- Clone this repository and open a shell in that path.
+- Run `pip install -r requirements.txt` command to install FlareSolverr dependencies.
+- Run `python src/flaresolverr.py` command to start FlareSolverr.
+
+### From source code (FreeBSD/TrueNAS CORE)
+
+- Run `pkg install chromium python313 py313-pip xorg-vfbserver` command to install the required dependencies.
+- Clone this repository and open a shell in that path.
+- Run `python3.13 -m pip install -r requirements.txt` command to install FlareSolverr dependencies.
+- Run `python3.13 src/flaresolverr.py` command to start FlareSolverr.

 ### Systemd service

@@ -82,7 +101,8 @@ We provide an example Systemd unit file `flaresolverr.service` as reference. You

 ## Usage

-Example request:
+Example Bash request:
+
 ```bash
 curl -L -X POST 'http://localhost:8191/v1' \
 -H 'Content-Type: application/json' \
@@ -93,6 +113,34 @@ curl -L -X POST 'http://localhost:8191/v1' \
 }'
 ```

+Example Python request:
+
+```py
+import requests
+
+url = "http://localhost:8191/v1"
+headers = {"Content-Type": "application/json"}
+data = {
+    "cmd": "request.get",
+    "url": "http://www.google.com/",
+    "maxTimeout": 60000
+}
+response = requests.post(url, headers=headers, json=data)
+print(response.text)
+```
+
+Example PowerShell request:
+
+```ps1
+$body = @{
+    cmd = "request.get"
+    url = "http://www.google.com/"
+    maxTimeout = 60000
+} | ConvertTo-Json
+
+irm -UseBasicParsing 'http://localhost:8191/v1' -Headers @{"Content-Type"="application/json"} -Method Post -Body $body
+```
+
 ### Commands

 #### + `sessions.create`
@@ -104,9 +152,9 @@ cookies for the browser to use.
 This also speeds up the requests since it won't have to launch a new browser instance for every request.

 | Parameter | Notes                                                                                                                                                                                                                                                                                                             |
-|-----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | session   | Optional. The session ID that you want to be assigned to the instance. If isn't set a random UUID will be assigned.                                                                                                                                                                                               |
-| proxy     | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is not supported. |
+| proxy     | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is supported. Eg: `"proxy": {"url": "http://127.0.0.1:8888", "username": "testuser", "password": "testpass"}` |

 #### + `sessions.list`

@@ -118,11 +166,7 @@ Example response:

 ```json
 {
-  "sessions": [
-    "session_id_1",
-    "session_id_2",
-    "session_id_3..."
-  ]
+  "sessions": ["session_id_1", "session_id_2", "session_id_3..."]
 }
 ```

@@ -132,21 +176,27 @@ This will properly shutdown a browser instance and remove all files associated w
 session. When you no longer need to use a session you should make sure to close it.

 | Parameter | Notes                                         |
-|-----------|-----------------------------------------------|
+| --------- | --------------------------------------------- |
 | session   | The session ID that you want to be destroyed. |

 #### + `request.get`

 | Parameter           | Notes                                                                                                                                                                                                                                                                                                                                        |
-|-------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | url                 | Mandatory                                                                                                                                                                                                                                                                                                                                    |
 | session             | Optional. Will send the request from and existing browser instance. If one is not sent it will create a temporary instance that will be destroyed immediately after the request is completed.                                                                                                                                                |
+| session_ttl_minutes | Optional. FlareSolverr will automatically rotate expired sessions based on the TTL provided in minutes.                                                                                                                                                                                                                                      |
 | maxTimeout          | Optional, default value 60000. Max timeout to solve the challenge in milliseconds.                                                                                                                                                                                                                                                           |
-| cookies           | Optional. Will be used by the headless browser. Follow [this](https://github.com/puppeteer/puppeteer/blob/v3.3.0/docs/api.md#pagesetcookiecookies) format.                                                                                                                                                                                   |
+| cookies             | Optional. Will be used by the headless browser. Eg: `"cookies": [{"name": "cookie1", "value": "value1"}, {"name": "cookie2", "value": "value2"}]`.                                                                                                                                                                                           |
 | returnOnlyCookies   | Optional, default false. Only returns the cookies. Response data, headers and other parts of the response are removed.                                                                                                                                                                                                                       |
+| returnScreenshot    | Optional, default false. Captures a screenshot of the final rendered page after all challenges and waits are completed. The screenshot is returned as a Base64-encoded PNG string in the `screenshot` field of the response.                                                                                                                 |
 | proxy               | Optional, default disabled. Eg: `"proxy": {"url": "http://127.0.0.1:8888"}`. You must include the proxy schema in the URL: `http://`, `socks4://` or `socks5://`. Authorization (username/password) is not supported. (When the `session` parameter is set, the proxy is ignored; a session specific proxy can be set in `sessions.create`.) |
+| waitInSeconds       | Optional, default none. Length to wait in seconds after solving the challenge, and before returning the results. Useful to allow it to load dynamic content.                                                                                                                                                                                 |
+| disableMedia        | Optional, default false. When true FlareSolverr will prevent media resources (images, CSS, and fonts) from being loaded to speed up navigation.                                                                                                                                                                                              |
+| tabs_till_verify    | Optional, default none. Number of times the `Tab` button is needed to be pressed to end up on the turnstile captcha, in order to verify it. After verifying the captcha, the result will be stored in the solution under `turnstile_token`.                                                                                                  |

-:warning: If you want to use Cloudflare clearance cookie in your scripts, make sure you use the FlareSolverr User-Agent too. If they don't match you will see the challenge.
+> **Warning**
+> If you want to use Cloudflare clearance cookie in your scripts, make sure you use the FlareSolverr User-Agent too. If they don't match you will see the challenge.

 Example response from running the `curl` above:

@@ -197,7 +247,8 @@ Example response from running the `curl` above:
        "sameSite": "None"
      }
    ],
-        "userAgent": "Windows NT 10.0; Win64; x64) AppleWebKit/5..."
+    "userAgent": "Windows NT 10.0; Win64; x64) AppleWebKit/5...",
+    "turnstile_token": "03AGdBq24k3lK7JH2v8uN1T5F..."
  },
  "status": "ok",
  "message": "",
@@ -209,42 +260,79 @@ Example response from running the `curl` above:

 ### + `request.post`

-This is the same as `request.get` but it takes one more param:
+This works like `request.get`, with the addition of the postData parameter. Note that `tabs_till_verify` is currently supported only for GET requests and requires one extra argument.

 | Parameter | Notes                                                                    |
-|-----------|--------------------------------------------------------------------------|
+| --------- | ------------------------------------------------------------------------ |
 | postData  | Must be a string with `application/x-www-form-urlencoded`. Eg: `a=b&c=d` |

 ## Environment variables

 | Name               | Default                | Notes                                                                                                                                    |
-|-----------------|------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| ------------------ | ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
 | LOG_LEVEL          | info                   | Verbosity of the logging. Use `LOG_LEVEL=debug` for more information.                                                                    |
+| LOG_FILE           | none                   | Path to capture log to file. Example: `/config/flaresolverr.log`.                                                                         |
 | LOG_HTML           | false                  | Only for debugging. If `true` all HTML that passes through the proxy will be logged to the console in `debug` level.                     |
+| PROXY_URL          | none                   | URL for proxy. Will be overwritten by `request` or `sessions` proxy, if used. Example: `http://127.0.0.1:8080`.                          |
+| PROXY_USERNAME     | none                   | Username for proxy. Will be overwritten by `request` or `sessions` proxy, if used. Example: `testuser`.                                  |
+| PROXY_PASSWORD     | none                   | Password for proxy. Will be overwritten by `request` or `sessions` proxy, if used. Example: `testpass`.                                  |
 | CAPTCHA_SOLVER     | none                   | Captcha solving method. It is used when a captcha is encountered. See the Captcha Solvers section.                                       |
 | TZ                 | UTC                    | Timezone used in the logs and the web browser. Example: `TZ=Europe/London`.                                                              |
+| LANG               | none                   | Language used in the web browser. Example: `LANG=en_GB`.                                                                                 |
 | HEADLESS           | true                   | Only for debugging. To run the web browser in headless mode or visible.                                                                  |
-| BROWSER_TIMEOUT | 40000                  | If you are experiencing errors/timeouts because your system is slow, you can try to increase this value. Remember to increase the `maxTimeout` parameter too. |
+| DISABLE_MEDIA      | false                  | To disable loading images, CSS, and other media in the web browser to save network bandwidth.                                            |
 | TEST_URL           | https://www.google.com | FlareSolverr makes a request on start to make sure the web browser is working. You can change that URL if it is blocked in your country. |
 | PORT               | 8191                   | Listening port. You don't need to change this if you are running on Docker.                                                              |
 | HOST               | 0.0.0.0                | Listening interface. You don't need to change this if you are running on Docker.                                                         |
+| PROMETHEUS_ENABLED | false                  | Enable Prometheus exporter. See the Prometheus section below.                                                                            |
+| PROMETHEUS_PORT    | 8192                   | Listening port for Prometheus exporter. See the Prometheus section below.                                                                |

 Environment variables are set differently depending on the operating system. Some examples:
-* Docker: Take a look at the Docker section in this document. Environment variables can be set in the `docker-compose.yml` file or in the Docker CLI command.
-* Linux: Run `export LOG_LEVEL=debug` and then start FlareSolverr in the same shell.
-* Windows: Open `cmd.exe`, run `set LOG_LEVEL=debug` and then start FlareSolverr in the same shell.
+
+- Docker: Take a look at the Docker section in this document. Environment variables can be set in the `docker-compose.yml` file or in the Docker CLI command.
+- Linux: Run `export LOG_LEVEL=debug` and then run `flaresolverr` in the same shell.
+- Windows: Open `cmd.exe`, run `set LOG_LEVEL=debug` and then run `flaresolverr.exe` in the same shell.
+
+## Prometheus exporter
+
+The Prometheus exporter for FlareSolverr is disabled by default. It can be enabled with the environment variable `PROMETHEUS_ENABLED`. If you are using Docker make sure you expose the `PROMETHEUS_PORT`.
+
+Example metrics:
+
+```shell
+# HELP flaresolverr_request_total Total requests with result
+# TYPE flaresolverr_request_total counter
+flaresolverr_request_total{domain="nowsecure.nl",result="solved"} 1.0
+# HELP flaresolverr_request_created Total requests with result
+# TYPE flaresolverr_request_created gauge
+flaresolverr_request_created{domain="nowsecure.nl",result="solved"} 1.690141657157109e+09
+# HELP flaresolverr_request_duration Request duration in seconds
+# TYPE flaresolverr_request_duration histogram
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="0.0"} 0.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="10.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="25.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="50.0"} 1.0
+flaresolverr_request_duration_bucket{domain="nowsecure.nl",le="+Inf"} 1.0
+flaresolverr_request_duration_count{domain="nowsecure.nl"} 1.0
+flaresolverr_request_duration_sum{domain="nowsecure.nl"} 5.858
+# HELP flaresolverr_request_duration_created Request duration in seconds
+# TYPE flaresolverr_request_duration_created gauge
+flaresolverr_request_duration_created{domain="nowsecure.nl"} 1.6901416571570296e+09
+```

 ## Captcha Solvers

-:warning: At this time none of the captcha solvers work. You can check the status in the open issues. Any help is welcome.
+> **Warning**
+> At this time none of the captcha solvers work. You can check the status in the open issues. Any help is welcome.

 Sometimes CloudFlare not only gives mathematical computations and browser tests, sometimes they also require the user to
 solve a captcha.
 If this is the case, FlareSolverr will return the error `Captcha detected but no automatic solver is configured.`

-FlareSolverr can be customized to solve the captchas automatically by setting the environment variable `CAPTCHA_SOLVER`
-to the file name of one of the adapters inside the [/captcha](src/captcha) directory.
+FlareSolverr can be customized to solve the CAPTCHA automatically by setting the environment variable `CAPTCHA_SOLVER`
+to the file name of one of the adapters inside the `/captcha` directory.

 ## Related projects

-* C# implementation => https://github.com/FlareSolverr/FlareSolverrSharp
+- C# implementation => https://github.com/FlareSolverr/FlareSolverrSharp
+
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -7,9 +7,12 @@ services:
    container_name: flaresolverr
    environment:
      - LOG_LEVEL=${LOG_LEVEL:-info}
+      - LOG_FILE=${LOG_FILE:-none}
      - LOG_HTML=${LOG_HTML:-false}
      - CAPTCHA_SOLVER=${CAPTCHA_SOLVER:-none}
      - TZ=Europe/London
    ports:
      - "${PORT:-8191}:8191"
+    volumes:
+      - /var/lib/flaresolver:/config
    restart: unless-stopped
--- a/flaresolverr.service
+++ b/flaresolverr.service
@@ -0,0 +1,19 @@
+[Unit]
+Description=FlareSolverr
+After=network.target
+
+[Service]
+SyslogIdentifier=flaresolverr
+Restart=always
+RestartSec=5
+Type=simple
+User=flaresolverr
+Group=flaresolverr
+Environment="LOG_LEVEL=info"
+Environment="CAPTCHA_SOLVER=none"
+WorkingDirectory=/opt/flaresolverr
+ExecStart=/opt/flaresolverr/flaresolverr
+TimeoutStopSec=30
+
+[Install]
+WantedBy=multi-user.target
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "flaresolverr",
-  "version": "3.0.3",
+  "version": "3.4.6",
  "description": "Proxy server to bypass Cloudflare protection",
  "author": "Diego Heras (ngosang / ngosang@hotmail.es)",
  "license": "MIT"
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,9 +1,14 @@
-bottle==0.12.23
-waitress==2.1.2
-selenium==4.7.2
+bottle==0.13.4
+waitress==3.0.2
+selenium==4.38.0
 func-timeout==4.3.5
-# required by undetected_chromedriver
-requests==2.28.1
-websockets==10.4
-# only required for linux
-xvfbwrapper==0.2.9
+prometheus-client==0.23.1
+# Required by undetected_chromedriver
+requests==2.32.5
+certifi==2025.10.5
+websockets==15.0.1
+packaging==25.0
+# Only required for Linux and macOS
+xvfbwrapper==0.2.15; platform_system != "Windows"
+# Only required for Windows
+pefile==2024.8.26; platform_system == "Windows"
--- a/resources/flaresolverr_logo.ico
+++ b/resources/flaresolverr_logo.ico
--- a/src/bottle_plugins/logger_plugin.py
+++ b/src/bottle_plugins/logger_plugin.py
@@ -5,7 +5,7 @@ import logging
 def logger_plugin(callback):
    """
    Bottle plugin to use logging module
-    http://bottlepy.org/docs/dev/plugindev.html
+    https://bottlepy.org/docs/dev/plugindev.html

    Wrap a Bottle request so that a log line is emitted after it's handled.
    (This decorator can be extended to take the desired logger as a param.)
--- a/src/bottle_plugins/prometheus_plugin.py
+++ b/src/bottle_plugins/prometheus_plugin.py
@@ -0,0 +1,66 @@
+import logging
+import os
+import urllib.parse
+
+from bottle import request
+from dtos import V1RequestBase, V1ResponseBase
+from metrics import start_metrics_http_server, REQUEST_COUNTER, REQUEST_DURATION
+
+PROMETHEUS_ENABLED = os.environ.get('PROMETHEUS_ENABLED', 'false').lower() == 'true'
+PROMETHEUS_PORT = int(os.environ.get('PROMETHEUS_PORT', 8192))
+
+
+def setup():
+    if PROMETHEUS_ENABLED:
+        start_metrics_http_server(PROMETHEUS_PORT)
+
+
+def prometheus_plugin(callback):
+    """
+    Bottle plugin to expose Prometheus metrics
+    https://bottlepy.org/docs/dev/plugindev.html
+    """
+    def wrapper(*args, **kwargs):
+        actual_response = callback(*args, **kwargs)
+
+        if PROMETHEUS_ENABLED:
+            try:
+                export_metrics(actual_response)
+            except Exception as e:
+                logging.warning("Error exporting metrics: " + str(e))
+
+        return actual_response
+
+    def export_metrics(actual_response):
+        res = V1ResponseBase(actual_response)
+
+        if res.startTimestamp is None or res.endTimestamp is None:
+            # skip management and healthcheck endpoints
+            return
+
+        domain = "unknown"
+        if res.solution and res.solution.url:
+            domain = parse_domain_url(res.solution.url)
+        else:
+            # timeout error
+            req = V1RequestBase(request.json)
+            if req.url:
+                domain = parse_domain_url(req.url)
+
+        run_time = (res.endTimestamp - res.startTimestamp) / 1000
+        REQUEST_DURATION.labels(domain=domain).observe(run_time)
+
+        result = "unknown"
+        if res.message == "Challenge solved!":
+            result = "solved"
+        elif res.message == "Challenge not detected!":
+            result = "not_detected"
+        elif res.message.startswith("Error"):
+            result = "error"
+        REQUEST_COUNTER.labels(domain=domain, result=result).inc()
+
+    def parse_domain_url(url):
+        parsed_url = urllib.parse.urlparse(url)
+        return parsed_url.hostname
+
+    return wrapper
--- a/src/build_package.py
+++ b/src/build_package.py
@@ -0,0 +1,110 @@
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import zipfile
+
+import requests
+
+
+def clean_files():
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'build'))
+    except Exception:
+        pass
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist'))
+    except Exception:
+        pass
+    try:
+        shutil.rmtree(os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist_chrome'))
+    except Exception:
+        pass
+
+
+def download_chromium():
+    # https://commondatastorage.googleapis.com/chromium-browser-snapshots/index.html?prefix=Linux_x64/
+    revision = "1522586" if os.name == 'nt' else '1522586'
+    arch = 'Win_x64' if os.name == 'nt' else 'Linux_x64'
+    dl_file = 'chrome-win' if os.name == 'nt' else 'chrome-linux'
+    dl_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist_chrome')
+    dl_path_folder = os.path.join(dl_path, dl_file)
+    dl_path_zip = dl_path_folder + '.zip'
+
+    # response = requests.get(
+    #     f'https://commondatastorage.googleapis.com/chromium-browser-snapshots/{arch}/LAST_CHANGE',
+    #     timeout=30)
+    # revision = response.text.strip()
+    print("Downloading revision: " + revision)
+
+    os.mkdir(dl_path)
+    with requests.get(
+            f'https://commondatastorage.googleapis.com/chromium-browser-snapshots/{arch}/{revision}/{dl_file}.zip',
+            stream=True) as r:
+        r.raise_for_status()
+        with open(dl_path_zip, 'wb') as f:
+            for chunk in r.iter_content(chunk_size=8192):
+                f.write(chunk)
+    print("File downloaded: " + dl_path_zip)
+    with zipfile.ZipFile(dl_path_zip, 'r') as zip_ref:
+        zip_ref.extractall(dl_path)
+    os.remove(dl_path_zip)
+
+    chrome_path = os.path.join(dl_path, "chrome")
+    shutil.move(dl_path_folder, chrome_path)
+    print("Extracted in: " + chrome_path)
+
+    if os.name != 'nt':
+        # Give executable permissions for *nix
+        # file * | grep executable | cut -d: -f1
+        print("Giving executable permissions...")
+        execs = ['chrome', 'chrome_crashpad_handler', 'chrome_sandbox', 'chrome-wrapper', 'xdg-mime', 'xdg-settings']
+        for exec_file in execs:
+            exec_path = os.path.join(chrome_path, exec_file)
+            os.chmod(exec_path, 0o755)
+
+
+def run_pyinstaller():
+    sep = ';' if os.name == 'nt' else ':'
+    result = subprocess.run([sys.executable, "-m", "PyInstaller",
+                             "--icon", "resources/flaresolverr_logo.ico",
+                             "--add-data", f"package.json{sep}.",
+                             "--add-data", f"{os.path.join('dist_chrome', 'chrome')}{sep}chrome",
+                             os.path.join("src", "flaresolverr.py")],
+                            cwd=os.pardir, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if result.returncode != 0:
+        print(result.stderr.decode('utf-8'))
+        raise Exception("Error running pyInstaller")
+
+
+def compress_package():
+    dist_folder = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'dist')
+    package_folder = os.path.join(dist_folder, 'package')
+    shutil.move(os.path.join(dist_folder, 'flaresolverr'), os.path.join(package_folder, 'flaresolverr'))
+    print("Package folder: " + package_folder)
+
+    compr_format = 'zip' if os.name == 'nt' else 'gztar'
+    compr_file_name = 'flaresolverr_windows_x64' if os.name == 'nt' else 'flaresolverr_linux_x64'
+    compr_file_path = os.path.join(dist_folder, compr_file_name)
+    shutil.make_archive(compr_file_path, compr_format, package_folder)
+    print("Compressed file path: " + compr_file_path)
+
+
+if __name__ == "__main__":
+    print("Building package...")
+    print("Platform: " + platform.platform())
+
+    print("Cleaning previous build...")
+    clean_files()
+
+    print("Downloading Chromium...")
+    download_chromium()
+
+    print("Building pyinstaller executable... ")
+    run_pyinstaller()
+
+    print("Compressing package... ")
+    compress_package()
+
+# NOTE: python -m pip install pyinstaller
--- a/src/dtos.py
+++ b/src/dtos.py
@@ -10,6 +10,8 @@ class ChallengeResolutionResultT:
    response: str = None
    cookies: list = None
    userAgent: str = None
+    screenshot: str | None = None
+    turnstile_token: str = None

    def __init__(self, _dict):
        self.__dict__.update(_dict)
@@ -33,6 +35,7 @@ class V1RequestBase(object):
    maxTimeout: int = None
    proxy: dict = None
    session: str = None
+    session_ttl_minutes: int = None
    headers: list = None  # deprecated v2.0.0, not used
    userAgent: str = None  # deprecated v2.0.0, not used

@@ -40,8 +43,14 @@ class V1RequestBase(object):
    url: str = None
    postData: str = None
    returnOnlyCookies: bool = None
+    returnScreenshot: bool = None
    download: bool = None   # deprecated v2.0.0, not used
    returnRawHtml: bool = None  # deprecated v2.0.0, not used
+    waitInSeconds: int = None
+    # Optional resource blocking flag (blocks images, CSS, and fonts)
+    disableMedia: bool = None
+    # Optional when you've got a turnstile captcha that needs to be clicked after X number of Tab presses
+    tabs_till_verify : int = None

    def __init__(self, _dict):
        self.__dict__.update(_dict)
@@ -51,6 +60,8 @@ class V1ResponseBase(object):
    # V1ResponseBase
    status: str = None
    message: str = None
+    session: str = None
+    sessions: list[str] = None
    startTimestamp: int = None
    endTimestamp: int = None
    version: str = None
--- a/src/flaresolverr.py
+++ b/src/flaresolverr.py
@@ -3,14 +3,20 @@ import logging
 import os
 import sys

-from bottle import run, response, Bottle, request
+import certifi
+from bottle import run, response, Bottle, request, ServerAdapter

 from bottle_plugins.error_plugin import error_plugin
 from bottle_plugins.logger_plugin import logger_plugin
-from dtos import IndexResponse, V1RequestBase
+from bottle_plugins import prometheus_plugin
+from dtos import V1RequestBase
 import flaresolverr_service
 import utils

+env_proxy_url = os.environ.get('PROXY_URL', None)
+env_proxy_username = os.environ.get('PROXY_USERNAME', None)
+env_proxy_password = os.environ.get('PROXY_PASSWORD', None)
+

 class JSONErrorBottle(Bottle):
    """
@@ -23,10 +29,6 @@ class JSONErrorBottle(Bottle):

 app = JSONErrorBottle()

-# plugin order is important
-app.install(logger_plugin)
-app.install(error_plugin)
-

@app.route('/')
 def index():
@@ -52,7 +54,14 @@ def controller_v1():
    """
    Controller v1
    """
-    req = V1RequestBase(request.json)
+    data = request.json or {}
+    if (('proxy' not in data or not data.get('proxy')) and env_proxy_url is not None and (env_proxy_username is None and env_proxy_password is None)):
+        logging.info('Using proxy URL ENV')
+        data['proxy'] = {"url": env_proxy_url}
+    if (('proxy' not in data or not data.get('proxy')) and env_proxy_url is not None and (env_proxy_username is not None or env_proxy_password is not None)):
+        logging.info('Using proxy URL, username & password ENVs')
+        data['proxy'] = {"url": env_proxy_url, "username": env_proxy_username, "password": env_proxy_password}
+    req = V1RequestBase(data)
    res = flaresolverr_service.controller_v1_endpoint(req)
    if res.__error_500__:
        response.status = 500
@@ -60,8 +69,25 @@ def controller_v1():


 if __name__ == "__main__":
+    # check python version
+    if sys.version_info < (3, 9):
+        raise Exception("The Python version is less than 3.9, a version equal to or higher is required.")
+
+    # fix for HEADLESS=false in Windows binary
+    # https://stackoverflow.com/a/27694505
+    if os.name == 'nt':
+        import multiprocessing
+        multiprocessing.freeze_support()
+
+    # fix ssl certificates for compiled binaries
+    # https://github.com/pyinstaller/pyinstaller/issues/7229
+    # https://stackoverflow.com/q/55736855
+    os.environ["REQUESTS_CA_BUNDLE"] = certifi.where()
+    os.environ["SSL_CERT_FILE"] = certifi.where()
+
    # validate configuration
    log_level = os.environ.get('LOG_LEVEL', 'info').upper()
+    log_file = os.environ.get('LOG_FILE', None)
    log_html = utils.get_config_log_html()
    headless = utils.get_config_headless()
    server_host = os.environ.get('HOST', '0.0.0.0')
@@ -71,6 +97,20 @@ if __name__ == "__main__":
    logger_format = '%(asctime)s %(levelname)-8s %(message)s'
    if log_level == 'DEBUG':
        logger_format = '%(asctime)s %(levelname)-8s ReqId %(thread)s %(message)s'
+    if log_file:
+        log_file = os.path.realpath(log_file)
+        log_path = os.path.dirname(log_file)
+        os.makedirs(log_path, exist_ok=True)
+        logging.basicConfig(
+            format=logger_format,
+            level=log_level,
+            datefmt='%Y-%m-%d %H:%M:%S',
+            handlers=[
+                logging.StreamHandler(sys.stdout),
+                logging.FileHandler(log_file)
+            ]
+        )
+    else:
        logging.basicConfig(
            format=logger_format,
            level=log_level,
@@ -79,6 +119,7 @@ if __name__ == "__main__":
                logging.StreamHandler(sys.stdout)
            ]
        )
+
    # disable warning traces from urllib3
    logging.getLogger('urllib3').setLevel(logging.ERROR)
    logging.getLogger('selenium.webdriver.remote.remote_connection').setLevel(logging.WARNING)
@@ -87,9 +128,25 @@ if __name__ == "__main__":
    logging.info(f'FlareSolverr {utils.get_flaresolverr_version()}')
    logging.debug('Debug log enabled')

+    # Get current OS for global variable
+    utils.get_current_platform()
+
    # test browser installation
    flaresolverr_service.test_browser_installation()

+    # start bootle plugins
+    # plugin order is important
+    app.install(logger_plugin)
+    app.install(error_plugin)
+    prometheus_plugin.setup()
+    app.install(prometheus_plugin.prometheus_plugin)
+
    # start webserver
    # default server 'wsgiref' does not support concurrent requests
-    run(app, host=server_host, port=server_port, quiet=True, server='waitress')
+    # https://github.com/FlareSolverr/FlareSolverr/issues/680
+    # https://github.com/Pylons/waitress/issues/31
+    class WaitressServerPoll(ServerAdapter):
+        def run(self, handler):
+            from waitress import serve
+            serve(handler, host=self.host, port=self.port, asyncore_use_poll=True)
+    run(app, host=server_host, port=server_port, quiet=True, server=WaitressServerPoll)
--- a/src/flaresolverr_service.py
+++ b/src/flaresolverr_service.py
@@ -1,18 +1,26 @@
 import logging
+import platform
 import sys
 import time
-from urllib.parse import unquote
+from datetime import timedelta
+from html import escape
+from urllib.parse import unquote, quote

-from func_timeout import func_timeout, FunctionTimedOut
+from func_timeout import FunctionTimedOut, func_timeout
 from selenium.common import TimeoutException
 from selenium.webdriver.chrome.webdriver import WebDriver
 from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+from selenium.webdriver.support.expected_conditions import (
+    presence_of_element_located, staleness_of, title_is)
+from selenium.webdriver.common.action_chains import ActionChains
 from selenium.webdriver.support.wait import WebDriverWait
-from selenium.webdriver.support.expected_conditions import presence_of_element_located, staleness_of, title_is

-from dtos import V1RequestBase, V1ResponseBase, ChallengeResolutionT, ChallengeResolutionResultT, IndexResponse, \
-    HealthResponse, STATUS_OK, STATUS_ERROR
 import utils
+from dtos import (STATUS_ERROR, STATUS_OK, ChallengeResolutionResultT,
+                  ChallengeResolutionT, HealthResponse, IndexResponse,
+                  V1RequestBase, V1ResponseBase)
+from sessions import SessionsStorage

 ACCESS_DENIED_TITLES = [
    # Cloudflare
@@ -30,19 +38,28 @@ CHALLENGE_TITLES = [
    # Cloudflare
    'Just a moment...',
    # DDoS-GUARD
-    'DDOS-GUARD',
+    'DDoS-Guard'
 ]
 CHALLENGE_SELECTORS = [
    # Cloudflare
-    '#cf-challenge-running', '.ray_id', '.attack-box', '#cf-please-wait', '#challenge-spinner', '#trk_jschal_js',
+    '#cf-challenge-running', '.ray_id', '.attack-box', '#cf-please-wait', '#challenge-spinner', '#trk_jschal_js', '#turnstile-wrapper', '.lds-ring',
    # Custom CloudFlare for EbookParadijs, Film-Paleis, MuziekFabriek and Puur-Hollands
-    'td.info #js_info'
+    'td.info #js_info',
+    # Fairlane / pararius.com
+    'div.vc div.text-box h2'
 ]
-SHORT_TIMEOUT = 10
+
+TURNSTILE_SELECTORS = [
+    "input[name='cf-turnstile-response']"
+]
+
+SHORT_TIMEOUT = 1
+SESSIONS_STORAGE = SessionsStorage()


 def test_browser_installation():
    logging.info("Testing web browser installation...")
+    logging.info("Platform: " + platform.platform())

    chrome_exe_path = utils.get_chrome_exe_path()
    if chrome_exe_path is None:
@@ -58,9 +75,10 @@ def test_browser_installation():
    else:
        logging.info("Chrome / Chromium major version: " + chrome_major_version)

+    logging.info("Launching web browser...")
    user_agent = utils.get_user_agent()
    logging.info("FlareSolverr User-Agent: " + user_agent)
-    logging.info("Test successful")
+    logging.info("Test successful!")


 def index_endpoint() -> IndexResponse:
@@ -108,17 +126,17 @@ def _controller_v1_handler(req: V1RequestBase) -> V1ResponseBase:
        logging.warning("Request parameter 'userAgent' was removed in FlareSolverr v2.")

    # set default values
-    if req.maxTimeout is None or req.maxTimeout < 1:
+    if req.maxTimeout is None or int(req.maxTimeout) < 1:
        req.maxTimeout = 60000

    # execute the command
    res: V1ResponseBase
    if req.cmd == 'sessions.create':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_create(req)
    elif req.cmd == 'sessions.list':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_list(req)
    elif req.cmd == 'sessions.destroy':
-        raise Exception("Not implemented yet.")
+        res = _cmd_sessions_destroy(req)
    elif req.cmd == 'request.get':
        res = _cmd_request_get(req)
    elif req.cmd == 'request.post':
@@ -165,42 +183,220 @@ def _cmd_request_post(req: V1RequestBase) -> V1ResponseBase:
    return res


+def _cmd_sessions_create(req: V1RequestBase) -> V1ResponseBase:
+    logging.debug("Creating new session...")
+
+    session, fresh = SESSIONS_STORAGE.create(session_id=req.session, proxy=req.proxy)
+    session_id = session.session_id
+
+    if not fresh:
+        return V1ResponseBase({
+            "status": STATUS_OK,
+            "message": "Session already exists.",
+            "session": session_id
+        })
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "Session created successfully.",
+        "session": session_id
+    })
+
+
+def _cmd_sessions_list(req: V1RequestBase) -> V1ResponseBase:
+    session_ids = SESSIONS_STORAGE.session_ids()
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "",
+        "sessions": session_ids
+    })
+
+
+def _cmd_sessions_destroy(req: V1RequestBase) -> V1ResponseBase:
+    session_id = req.session
+    existed = SESSIONS_STORAGE.destroy(session_id)
+
+    if not existed:
+        raise Exception("The session doesn't exist.")
+
+    return V1ResponseBase({
+        "status": STATUS_OK,
+        "message": "The session has been removed."
+    })
+
+
 def _resolve_challenge(req: V1RequestBase, method: str) -> ChallengeResolutionT:
-    timeout = req.maxTimeout / 1000
+    timeout = int(req.maxTimeout) / 1000
    driver = None
    try:
-        driver = utils.get_webdriver()
+        if req.session:
+            session_id = req.session
+            ttl = timedelta(minutes=req.session_ttl_minutes) if req.session_ttl_minutes else None
+            session, fresh = SESSIONS_STORAGE.get(session_id, ttl)
+
+            if fresh:
+                logging.debug(f"new session created to perform the request (session_id={session_id})")
+            else:
+                logging.debug(f"existing session is used to perform the request (session_id={session_id}, "
+                              f"lifetime={str(session.lifetime())}, ttl={str(ttl)})")
+
+            driver = session.driver
+        else:
+            driver = utils.get_webdriver(req.proxy)
+            logging.debug('New instance of webdriver has been created to perform the request')
        return func_timeout(timeout, _evil_logic, (req, driver, method))
    except FunctionTimedOut:
        raise Exception(f'Error solving the challenge. Timeout after {timeout} seconds.')
    except Exception as e:
-        raise Exception('Error solving the challenge. ' + str(e))
+        raise Exception('Error solving the challenge. ' + str(e).replace('\n', '\\n'))
    finally:
-        if driver is not None:
+        if not req.session and driver is not None:
+            if utils.PLATFORM_VERSION == "nt":
+                driver.close()
            driver.quit()
+            logging.debug('A used instance of webdriver has been destroyed')


+def click_verify(driver: WebDriver, num_tabs: int = 1):
+    try:
+        logging.debug("Try to find the Cloudflare verify checkbox...")
+        actions = ActionChains(driver)
+        actions.pause(5)
+        for _ in range(num_tabs):
+            actions.send_keys(Keys.TAB).pause(0.1)
+        actions.pause(1)
+        actions.send_keys(Keys.SPACE).perform()
+        
+        logging.debug(f"Cloudflare verify checkbox clicked after {num_tabs} tabs!")
+    except Exception:
+        logging.debug("Cloudflare verify checkbox not found on the page.")
+    finally:
+        driver.switch_to.default_content()
+
+    try:
+        logging.debug("Try to find the Cloudflare 'Verify you are human' button...")
+        button = driver.find_element(
+            by=By.XPATH,
+            value="//input[@type='button' and @value='Verify you are human']",
+        )
+        if button:
+            actions = ActionChains(driver)
+            actions.move_to_element_with_offset(button, 5, 7)
+            actions.click(button)
+            actions.perform()
+            logging.debug("The Cloudflare 'Verify you are human' button found and clicked!")
+    except Exception:
+        logging.debug("The Cloudflare 'Verify you are human' button not found on the page.")
+
+    time.sleep(2)
+
+def _get_turnstile_token(driver: WebDriver, tabs: int):
+    token_input = driver.find_element(By.CSS_SELECTOR, "input[name='cf-turnstile-response']")
+    current_value = token_input.get_attribute("value")
+    while True:
+        click_verify(driver, num_tabs=tabs)
+        turnstile_token = token_input.get_attribute("value")
+        if turnstile_token:
+            if turnstile_token != current_value:
+                logging.info(f"Turnstile token: {turnstile_token}")
+                return turnstile_token
+        logging.debug(f"Failed to extract token possibly click failed")        
+
+        # reset focus
+        driver.execute_script("""
+            let el = document.createElement('button');
+            el.style.position='fixed';
+            el.style.top='0';
+            el.style.left='0';
+            document.body.prepend(el);
+            el.focus();
+        """)
+        time.sleep(1)
+
+def _resolve_turnstile_captcha(req: V1RequestBase, driver: WebDriver):
+    turnstile_token = None
+    if req.tabs_till_verify is not None:
+        logging.debug(f'Navigating to... {req.url} in order to pass the turnstile challenge')
+        driver.get(req.url)
+
+        turnstile_challenge_found = False
+        for selector in TURNSTILE_SELECTORS:
+            found_elements = driver.find_elements(By.CSS_SELECTOR, selector)   
+            if len(found_elements) > 0:
+                turnstile_challenge_found = True
+                logging.info("Turnstile challenge detected. Selector found: " + selector)
+                break
+        if turnstile_challenge_found:
+            turnstile_token = _get_turnstile_token(driver=driver, tabs=req.tabs_till_verify)
+        else:
+            logging.debug(f'Turnstile challenge not found')
+    return turnstile_token
+
 def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> ChallengeResolutionT:
    res = ChallengeResolutionT({})
    res.status = STATUS_OK
    res.message = ""

+    # optionally block resources like images/css/fonts using CDP
+    disable_media = utils.get_config_disable_media()
+    if req.disableMedia is not None:
+        disable_media = req.disableMedia
+    if disable_media:
+        block_urls = [
+            # Images
+            "*.png", "*.jpg", "*.jpeg", "*.gif", "*.webp", "*.bmp", "*.svg", "*.ico",
+            "*.PNG", "*.JPG", "*.JPEG", "*.GIF", "*.WEBP", "*.BMP", "*.SVG", "*.ICO",
+            "*.tiff", "*.tif", "*.jpe", "*.apng", "*.avif", "*.heic", "*.heif",
+            "*.TIFF", "*.TIF", "*.JPE", "*.APNG", "*.AVIF", "*.HEIC", "*.HEIF",
+            # Stylesheets
+            "*.css",
+            "*.CSS",
+            # Fonts
+            "*.woff", "*.woff2", "*.ttf", "*.otf", "*.eot",
+            "*.WOFF", "*.WOFF2", "*.TTF", "*.OTF", "*.EOT"
+        ]
+        try:
+            logging.debug("Network.setBlockedURLs: %s", block_urls)
+            driver.execute_cdp_cmd("Network.enable", {})
+            driver.execute_cdp_cmd("Network.setBlockedURLs", {"urls": block_urls})
+        except Exception:
+            # if CDP commands are not available or fail, ignore and continue
+            logging.debug("Network.setBlockedURLs failed or unsupported on this webdriver")
+
    # navigate to the page
-    logging.debug(f'Navigating to... {req.url}')
+    logging.debug(f"Navigating to... {req.url}")
+    turnstile_token = None
+
+    if method == "POST":
+        _post_request(req, driver)
+    else:
+        if req.tabs_till_verify is None:
+            driver.get(req.url)
+        else:
+            turnstile_token = _resolve_turnstile_captcha(req, driver)
+
+    # set cookies if required
+    if req.cookies is not None and len(req.cookies) > 0:
+        logging.debug(f'Setting cookies...')
+        for cookie in req.cookies:
+            driver.delete_cookie(cookie['name'])
+            driver.add_cookie(cookie)
+        # reload the page
        if method == 'POST':
            _post_request(req, driver)
        else:
            driver.get(req.url)
-    if utils.get_config_log_html():
-        logging.debug(f"Response HTML:\n{driver.page_source}")

    # wait for the page
+    if utils.get_config_log_html():
+        logging.debug(f"Response HTML:\n{driver.page_source}")
    html_element = driver.find_element(By.TAG_NAME, "html")
    page_title = driver.title

    # find access denied titles
    for title in ACCESS_DENIED_TITLES:
-        if title == page_title:
+        if page_title.startswith(title):
            raise Exception('Cloudflare has blocked this request. '
                            'Probably your IP is banned for this site, check in your web browser.')
    # find access denied selectors
@@ -213,9 +409,9 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge
    # find challenge by title
    challenge_found = False
    for title in CHALLENGE_TITLES:
-        if title == page_title:
+        if title.lower() == page_title.lower():
            challenge_found = True
-            logging.info("Challenge detected. Title found: " + title)
+            logging.info("Challenge detected. Title found: " + page_title)
            break
    if not challenge_found:
        # find challenge by selectors
@@ -226,17 +422,19 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge
                logging.info("Challenge detected. Selector found: " + selector)
                break

+    attempt = 0
    if challenge_found:
        while True:
            try:
+                attempt = attempt + 1
                # wait until the title changes
                for title in CHALLENGE_TITLES:
-                    logging.debug("Waiting for title: " + title)
+                    logging.debug("Waiting for title (attempt " + str(attempt) + "): " + title)
                    WebDriverWait(driver, SHORT_TIMEOUT).until_not(title_is(title))

                # then wait until all the selectors disappear
                for selector in CHALLENGE_SELECTORS:
-                    logging.debug("Waiting for selector: " + selector)
+                    logging.debug("Waiting for selector (attempt " + str(attempt) + "): " + selector)
                    WebDriverWait(driver, SHORT_TIMEOUT).until_not(
                        presence_of_element_located((By.CSS_SELECTOR, selector)))

@@ -245,6 +443,9 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge

            except TimeoutException:
                logging.debug("Timeout waiting for selector")
+
+                click_verify(driver)
+
                # update the html (cloudflare reloads the page every 5 s)
                html_element = driver.find_element(By.TAG_NAME, "html")

@@ -267,21 +468,30 @@ def _evil_logic(req: V1RequestBase, driver: WebDriver, method: str) -> Challenge
    challenge_res.status = 200  # todo: fix, selenium not provides this info
    challenge_res.cookies = driver.get_cookies()
    challenge_res.userAgent = utils.get_user_agent(driver)
+    challenge_res.turnstile_token = turnstile_token

    if not req.returnOnlyCookies:
        challenge_res.headers = {}  # todo: fix, selenium not provides this info
+
+        if req.waitInSeconds and req.waitInSeconds > 0:
+            logging.info("Waiting " + str(req.waitInSeconds) + " seconds before returning the response...")
+            time.sleep(req.waitInSeconds)
+
        challenge_res.response = driver.page_source

+    if req.returnScreenshot:
+        challenge_res.screenshot = driver.get_screenshot_as_base64()
+
    res.result = challenge_res
    return res


 def _post_request(req: V1RequestBase, driver: WebDriver):
    post_form = f'<form id="hackForm" action="{req.url}" method="POST">'
-    query_string = req.postData if req.postData[0] != '?' else req.postData[1:]
+    query_string = req.postData if req.postData and req.postData[0] != '?' else req.postData[1:] if req.postData else ''
    pairs = query_string.split('&')
    for pair in pairs:
-        parts = pair.split('=')
+        parts = pair.split('=', 1)
        # noinspection PyBroadException
        try:
            name = unquote(parts[0])
@@ -291,10 +501,12 @@ def _post_request(req: V1RequestBase, driver: WebDriver):
            continue
        # noinspection PyBroadException
        try:
-            value = unquote(parts[1])
+            value = unquote(parts[1]) if len(parts) > 1 else ''
        except Exception:
-            value = parts[1]
-        post_form += f'<input type="text" name="{name}" value="{value}"><br>'
+            value = parts[1] if len(parts) > 1 else ''
+        # Protection of " character, for syntax
+        value=value.replace('"','&quot;')
+        post_form += f'<input type="text" name="{escape(quote(name))}" value="{escape(quote(value))}"><br>'
    post_form += '</form>'
    html_content = f"""
        <!DOCTYPE html>
@@ -304,4 +516,4 @@ def _post_request(req: V1RequestBase, driver: WebDriver):
            <script>document.getElementById('hackForm').submit();</script>
        </body>
        </html>"""
-    driver.get("data:text/html;charset=utf-8," + html_content)
+    driver.get("data:text/html;charset=utf-8,{html_content}".format(html_content=html_content))
--- a/src/metrics.py
+++ b/src/metrics.py
@@ -0,0 +1,32 @@
+import logging
+
+from prometheus_client import Counter, Histogram, start_http_server
+import time
+
+REQUEST_COUNTER = Counter(
+    name='flaresolverr_request',
+    documentation='Total requests with result',
+    labelnames=['domain', 'result']
+)
+REQUEST_DURATION = Histogram(
+    name='flaresolverr_request_duration',
+    documentation='Request duration in seconds',
+    labelnames=['domain'],
+    buckets=[0, 10, 25, 50]
+)
+
+
+def serve(port):
+    start_http_server(port=port)
+    while True:
+        time.sleep(600)
+
+
+def start_metrics_http_server(prometheus_port: int):
+    logging.info(f"Serving Prometheus exporter on http://0.0.0.0:{prometheus_port}/metrics")
+    from threading import Thread
+    Thread(
+        target=serve,
+        kwargs=dict(port=prometheus_port),
+        daemon=True,
+    ).start()
--- a/src/sessions.py
+++ b/src/sessions.py
@@ -0,0 +1,84 @@
+import logging
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from typing import Optional, Tuple
+from uuid import uuid1
+
+from selenium.webdriver.chrome.webdriver import WebDriver
+
+import utils
+
+
+@dataclass
+class Session:
+    session_id: str
+    driver: WebDriver
+    created_at: datetime
+
+    def lifetime(self) -> timedelta:
+        return datetime.now() - self.created_at
+
+
+class SessionsStorage:
+    """SessionsStorage creates, stores and process all the sessions"""
+
+    def __init__(self):
+        self.sessions = {}
+
+    def create(self, session_id: Optional[str] = None, proxy: Optional[dict] = None,
+               force_new: Optional[bool] = False) -> Tuple[Session, bool]:
+        """create creates new instance of WebDriver if necessary,
+        assign defined (or newly generated) session_id to the instance
+        and returns the session object. If a new session has been created
+        second argument is set to True.
+
+        Note: The function is idempotent, so in case if session_id
+        already exists in the storage a new instance of WebDriver won't be created
+        and existing session will be returned. Second argument defines if 
+        new session has been created (True) or an existing one was used (False).
+        """
+        session_id = session_id or str(uuid1())
+
+        if force_new:
+            self.destroy(session_id)
+
+        if self.exists(session_id):
+            return self.sessions[session_id], False
+
+        driver = utils.get_webdriver(proxy)
+        created_at = datetime.now()
+        session = Session(session_id, driver, created_at)
+
+        self.sessions[session_id] = session
+
+        return session, True
+
+    def exists(self, session_id: str) -> bool:
+        return session_id in self.sessions
+
+    def destroy(self, session_id: str) -> bool:
+        """destroy closes the driver instance and removes session from the storage.
+        The function is noop if session_id doesn't exist.
+        The function returns True if session was found and destroyed,
+        and False if session_id wasn't found.
+        """
+        if not self.exists(session_id):
+            return False
+
+        session = self.sessions.pop(session_id)
+        if utils.PLATFORM_VERSION == "nt":
+            session.driver.close()
+        session.driver.quit()
+        return True
+
+    def get(self, session_id: str, ttl: Optional[timedelta] = None) -> Tuple[Session, bool]:
+        session, fresh = self.create(session_id)
+
+        if ttl is not None and not fresh and session.lifetime() > ttl:
+            logging.debug(f'session\'s lifetime has expired, so the session is recreated (session_id={session_id})')
+            session, fresh = self.create(session_id, force_new=True)
+
+        return session, fresh
+
+    def session_ids(self) -> list[str]:
+        return list(self.sessions.keys())
--- a/src/tests.py
+++ b/src/tests.py
@@ -1,4 +1,5 @@
 import unittest
+from typing import Optional

 from webtest import TestApp

@@ -7,7 +8,7 @@ import flaresolverr
 import utils


-def _find_obj_by_key(key: str, value: str, _list: list) -> dict | None:
+def _find_obj_by_key(key: str, value: str, _list: list) -> Optional[dict]:
    for obj in _list:
        if obj[key] == value:
            return obj
@@ -20,13 +21,16 @@ class TestFlareSolverr(unittest.TestCase):
    proxy_socks_url = "socks5://127.0.0.1:1080"
    google_url = "https://www.google.com"
    post_url = "https://httpbin.org/post"
-    cloudflare_url = "https://nowsecure.nl"
+    cloudflare_url = "https://nowsecure.nl/"
    cloudflare_url_2 = "https://idope.se/torrent-list/harry/"
-    ddos_guard_url = "https://anidex.info/"
-    custom_cloudflare_url = "https://www.muziekfabriek.org"
+    ddos_guard_url = "https://www.litres.ru/"
+    fairlane_url = "https://www.pararius.com/apartments/amsterdam"
+    custom_cloudflare_url = "https://www.muziekfabriek.org/"
    cloudflare_blocked_url = "https://cpasbiens3.fr/index.php?do=search&subaction=search"

    app = TestApp(flaresolverr.app)
+    # wait until the server is ready
+    app.get('/')

    def test_wrong_endpoint(self):
        res = self.app.get('/wrong', status=404)
@@ -88,6 +92,29 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertGreater(len(solution.cookies), 0)
        self.assertIn("Chrome/", solution.userAgent)

+    def test_v1_endpoint_request_get_disable_resources(self):
+        res = self.app.post_json("/v1", {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "disableMedia": True
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
    def test_v1_endpoint_request_get_cloudflare_js_1(self):
        res = self.app.post_json('/v1', {
            "cmd": "request.get",
@@ -158,7 +185,7 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertIn(self.ddos_guard_url, solution.url)
        self.assertEqual(solution.status, 200)
        self.assertIs(len(solution.headers), 0)
-        self.assertIn("<title>AniDex</title>", solution.response)
+        self.assertIn("<title>Литрес", solution.response)
        self.assertGreater(len(solution.cookies), 0)
        self.assertIn("Chrome/", solution.userAgent)

@@ -166,6 +193,32 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertIsNotNone(cf_cookie, "DDOS-Guard cookie not found")
        self.assertGreater(len(cf_cookie["value"]), 10)

+    def test_v1_endpoint_request_get_fairlane_js(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.fairlane_url
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge solved!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.fairlane_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Rental Apartments Amsterdam</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+        cf_cookie = _find_obj_by_key("name", "fl_pass_v2_b", solution.cookies)
+        self.assertIsNotNone(cf_cookie, "Fairlane cookie not found")
+        self.assertGreater(len(cf_cookie["value"]), 50)
+
    def test_v1_endpoint_request_get_custom_cloudflare_js(self):
        res = self.app.post_json('/v1', {
            "cmd": "request.get",
@@ -209,7 +262,45 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
        self.assertEqual(utils.get_flaresolverr_version(), body.version)

-    # todo: test Cmd 'request.get' should return OK with 'cookies' param
+    def test_v1_endpoint_request_get_cookies_param(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "cookies": [
+                {
+                    "name": "testcookie1",
+                    "value": "testvalue1"
+                },
+                {
+                    "name": "testcookie2",
+                    "value": "testvalue2"
+                }
+            ]
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 1)
+        self.assertIn("Chrome/", solution.userAgent)
+
+        user_cookie1 = _find_obj_by_key("name", "testcookie1", solution.cookies)
+        self.assertIsNotNone(user_cookie1, "User cookie 1 not found")
+        self.assertEqual("testvalue1", user_cookie1["value"])
+
+        user_cookie2 = _find_obj_by_key("name", "testcookie2", solution.cookies)
+        self.assertIsNotNone(user_cookie2, "User cookie 2 not found")
+        self.assertEqual("testvalue2", user_cookie2["value"])

    def test_v1_endpoint_request_get_returnOnlyCookies_param(self):
        res = self.app.post_json('/v1', {
@@ -234,10 +325,124 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertGreater(len(solution.cookies), 0)
        self.assertIn("Chrome/", solution.userAgent)

-    # todo: test Cmd 'request.get' should return OK with HTTP 'proxy' param
-    # todo: test Cmd 'request.get' should return OK with HTTP 'proxy' param with credentials
-    # todo: test Cmd 'request.get' should return OK with SOCKSv5 'proxy' param
-    # todo: test Cmd 'request.get' should fail with wrong 'proxy' param
+    def test_v1_endpoint_request_get_proxy_http_param(self):
+        """
+        To configure TinyProxy in local:
+           * sudo vim /etc/tinyproxy/tinyproxy.conf
+              * edit => LogFile "/tmp/tinyproxy.log"
+              * edit => Syslog Off
+           * sudo tinyproxy -d
+           * sudo tail -f /tmp/tinyproxy.log
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_http_param_with_credentials(self):
+        """
+        To configure TinyProxy in local:
+           * sudo vim /etc/tinyproxy/tinyproxy.conf
+              * edit => LogFile "/tmp/tinyproxy.log"
+              * edit => Syslog Off
+              * add => BasicAuth testuser testpass
+           * sudo tinyproxy -d
+           * sudo tail -f /tmp/tinyproxy.log
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_url,
+                "username": "testuser",
+                "password": "testpass"
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_socks_param(self):
+        """
+        To configure Dante in local:
+           * https://linuxhint.com/set-up-a-socks5-proxy-on-ubuntu-with-dante/
+           * sudo vim /etc/sockd.conf
+           * sudo systemctl restart sockd.service
+           * curl --socks5 socks5://127.0.0.1:1080 https://www.google.com
+        """
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": self.proxy_socks_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Challenge not detected!", body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)
+
+        solution = body.solution
+        self.assertIn(self.google_url, solution.url)
+        self.assertEqual(solution.status, 200)
+        self.assertIs(len(solution.headers), 0)
+        self.assertIn("<title>Google</title>", solution.response)
+        self.assertGreater(len(solution.cookies), 0)
+        self.assertIn("Chrome/", solution.userAgent)
+
+    def test_v1_endpoint_request_get_proxy_wrong_param(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "url": self.google_url,
+            "proxy": {
+                "url": "http://127.0.0.1:43210"
+            }
+        }, status=500)
+        self.assertEqual(res.status_code, 500)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_ERROR, body.status)
+        self.assertIn("Error: Error solving the challenge. Message: unknown error: net::ERR_PROXY_CONNECTION_FAILED",
+                      body.message)
+        self.assertGreater(body.startTimestamp, 10000)
+        self.assertGreaterEqual(body.endTimestamp, body.startTimestamp)
+        self.assertEqual(utils.get_flaresolverr_version(), body.version)

    def test_v1_endpoint_request_get_fail_timeout(self):
        res = self.app.post_json('/v1', {
@@ -351,12 +556,99 @@ class TestFlareSolverr(unittest.TestCase):
        self.assertEqual(STATUS_OK, body.status)
        self.assertEqual("Challenge not detected!", body.message)

-    # todo: test Cmd 'sessions.create' should return OK
-    # todo: test Cmd 'sessions.create' should return OK with session
-    # todo: test Cmd 'sessions.list' should return OK
-    # todo: test Cmd 'sessions.destroy' should return OK
-    # todo: test Cmd 'sessions.destroy' should fail
-    # todo: test Cmd 'request.get' should use session
+    def test_v1_endpoint_sessions_create_without_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertIsNotNone(body.session)
+
+    def test_v1_endpoint_sessions_create_with_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_create_session"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertEqual(body.session, "test_create_session")
+
+    def test_v1_endpoint_sessions_create_with_proxy(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "proxy": {
+                "url": self.proxy_url
+            }
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("Session created successfully.", body.message)
+        self.assertIsNotNone(body.session)
+
+    def test_v1_endpoint_sessions_list(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_list_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.list"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("", body.message)
+        self.assertGreaterEqual(len(body.sessions), 1)
+        self.assertIn("test_list_sessions", body.sessions)
+
+    def test_v1_endpoint_sessions_destroy_existing_session(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_destroy_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.destroy",
+            "session": "test_destroy_sessions"
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)
+        self.assertEqual("The session has been removed.", body.message)
+
+    def test_v1_endpoint_sessions_destroy_non_existing_session(self):
+        res = self.app.post_json('/v1', {
+            "cmd": "sessions.destroy",
+            "session": "non_existing_session_name"
+        }, status=500)
+        self.assertEqual(res.status_code, 500)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_ERROR, body.status)
+        self.assertEqual("Error: The session doesn't exist.", body.message)
+
+    def test_v1_endpoint_request_get_with_session(self):
+        self.app.post_json('/v1', {
+            "cmd": "sessions.create",
+            "session": "test_request_sessions"
+        })
+        res = self.app.post_json('/v1', {
+            "cmd": "request.get",
+            "session": "test_request_sessions",
+            "url": self.google_url
+        })
+        self.assertEqual(res.status_code, 200)
+
+        body = V1ResponseBase(res.json)
+        self.assertEqual(STATUS_OK, body.status)


 if __name__ == '__main__':
--- a/src/tests_sites.py
+++ b/src/tests_sites.py
@@ -39,6 +39,8 @@ def asset_cloudflare_solution(self, res, site_url, site_text):

 class TestFlareSolverr(unittest.TestCase):
    app = TestApp(flaresolverr.app)
+    # wait until the server is ready
+    app.get('/')

    def test_v1_endpoint_request_get_cloudflare(self):
        sites_get = [
--- a/src/undetected_chromedriver/init.py
+++ b/src/undetected_chromedriver/init.py
@@ -17,11 +17,12 @@ by UltrafunkAmsterdam (https://github.com/ultrafunkamsterdam)
 from __future__ import annotations


-__version__ = "3.4.6"
+__version__ = "3.5.5"

 import json
 import logging
 import os
+import pathlib
 import re
 import shutil
 import subprocess
@@ -33,7 +34,7 @@ from weakref import finalize
 import selenium.webdriver.chrome.service
 import selenium.webdriver.chrome.webdriver
 from selenium.webdriver.common.by import By
-import selenium.webdriver.common.service
+import selenium.webdriver.chromium.service
 import selenium.webdriver.remote.command
 import selenium.webdriver.remote.webdriver

@@ -109,11 +110,11 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
        browser_executable_path=None,
        port=0,
        enable_cdp_events=False,
-        service_args=None,
-        service_creationflags=None,
+        # service_args=None,
+        # service_creationflags=None,
        desired_capabilities=None,
        advanced_elements=False,
-        service_log_path=None,
+        # service_log_path=None,
        keep_alive=True,
        log_level=0,
        headless=False,
@@ -124,6 +125,7 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
        debug=False,
        no_sandbox=True,
        windows_headless=False,
+        user_multi_procs: bool = False,
        **kw,
    ):
        """
@@ -235,6 +237,14 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
             uses the --no-sandbox option, and additionally does suppress the "unsecure option" status bar
             this option has a default of True since many people seem to run this as root (....) , and chrome does not start
             when running as root without using --no-sandbox flag.
+
+        user_multi_procs:
+            set to true when you are using multithreads/multiprocessing
+            ensures not all processes are trying to modify a binary which is in use by another.
+            for this to work. YOU MUST HAVE AT LEAST 1 UNDETECTED_CHROMEDRIVER BINARY IN YOUR ROAMING DATA FOLDER.
+            this requirement can be easily satisfied, by just running this program "normal" and close/kill it.
+
+
        """

        finalize(self, self._ensure_close, self)
@@ -243,8 +253,11 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
            executable_path=driver_executable_path,
            force=patcher_force_close,
            version_main=version_main,
+            user_multi_procs=user_multi_procs,
        )
+        # self.patcher.auto(user_multiprocess = user_multi_num_procs)
        self.patcher.auto()
+
        # self.patcher = patcher
        if not options:
            options = ChromeOptions()
@@ -361,6 +374,18 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                browser_executable_path or find_chrome_executable()
            )

+        if not options.binary_location or not \
+                pathlib.Path(options.binary_location).exists():
+                raise FileNotFoundError(
+                    "\n---------------------\n"
+                    "Could not determine browser executable."
+                    "\n---------------------\n"
+                    "Make sure your browser is installed in the default location (path).\n"
+                    "If you are sure about the browser executable, you can specify it using\n"
+                    "the `browser_executable_path='{}` parameter.\n\n"
+                    .format("/path/to/browser/executable" if IS_POSIX else "c:/path/to/your/browser.exe")
+                )
+
        self._delay = 3

        self.user_data_dir = user_data_dir
@@ -371,10 +396,17 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
        if no_sandbox:
            options.arguments.extend(["--no-sandbox", "--test-type"])

-        if headless or options.headless:
-            if self.patcher.version_main < 108:
+        if headless or getattr(options, 'headless', None):
+            #workaround until a better checking is found
+            try:
+                v_main = int(self.patcher.version_main) if self.patcher.version_main else 108
+                if v_main < 108:
                    options.add_argument("--headless=chrome")
-            elif self.patcher.version_main >= 108:
+                elif v_main >= 108:
+                    options.add_argument("--headless=new")
+            except:
+                logger.warning("could not detect version_main."
+                               "therefore, we are assuming it is chrome 108 or higher")
                options.add_argument("--headless=new")

        options.add_argument("--window-size=1920,1080")
@@ -419,8 +451,10 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                options.binary_location, *options.arguments
            )
        else:
-            startupinfo = subprocess.STARTUPINFO()	
+            startupinfo = None
            if os.name == 'nt' and windows_headless:
+                # STARTUPINFO() is Windows only
+                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            browser = subprocess.Popen(
                [options.binary_location, *options.arguments],
@@ -432,26 +466,15 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
            )
            self.browser_pid = browser.pid

-        if service_creationflags:
-            service = selenium.webdriver.common.service.Service(
-                self.patcher.executable_path, port, service_args, service_log_path
-            )
-            for attr_name in ("creationflags", "creation_flags"):
-                if hasattr(service, attr_name):
-                    setattr(service, attr_name, service_creationflags)
-                    break
-        else:
-            service = None

-        super(Chrome, self).__init__(
-            executable_path=self.patcher.executable_path,
-            port=port,
+        service = selenium.webdriver.chromium.service.ChromiumService(
+            self.patcher.executable_path
+        )
+
+        super().__init__(
+            service=service,
            options=options,
-            service_args=service_args,
-            desired_capabilities=desired_capabilities,
-            service_log_path=service_log_path,
            keep_alive=keep_alive,
-            service=service,  # needed or the service will be re-created
        )

        self.reactor = None
@@ -470,7 +493,7 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
        else:
            self._web_element_cls = WebElement

-        if options.headless:
+        if headless or getattr(options, 'headless', None):
            self._configure_headless()

    def _configure_headless(self):
@@ -484,8 +507,6 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                    "Page.addScriptToEvaluateOnNewDocument",
                    {
                        "source": """
-
-                           Object.defineProperty(window, "navigator", {
                                Object.defineProperty(window, "navigator", {
                                  value: new Proxy(navigator, {
                                    has: (target, key) => (key === "webdriver" ? false : key in target),
@@ -706,14 +727,49 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
    def start_session(self, capabilities=None, browser_profile=None):
        if not capabilities:
            capabilities = self.options.to_capabilities()
-        super(selenium.webdriver.chrome.webdriver.WebDriver, self).start_session(
-            capabilities, browser_profile
-        )
-        # super(Chrome, self).start_session(capabilities, browser_profile)
+        super().start_session(capabilities)
+        # super(Chrome, self).start_session(capabilities, browser_profile) # Original explicit call commented out
+
+    def find_elements_recursive(self, by, value):
+        """
+        find elements in all frames
+        this is a generator function, which is needed
+            since if it would return a list of elements, they
+            will be stale on arrival.
+        using generator, when the element is returned we are in the correct frame
+        to use it directly
+        Args:
+            by: By
+            value: str
+        Returns: Generator[webelement.WebElement]
+        """
+        def search_frame(f=None):
+            if not f:
+                # ensure we are on main content frame
+                self.switch_to.default_content()
+            else:
+                self.switch_to.frame(f)
+            for elem in self.find_elements(by, value):
+                yield elem
+            # switch back to main content, otherwise we will get StaleElementReferenceException
+            self.switch_to.default_content()
+
+        # search root frame
+        for elem in search_frame():
+            yield elem
+        # get iframes
+        frames = self.find_elements('css selector', 'iframe')
+
+        # search per frame
+        for f in frames:
+            for elem in search_frame(f):
+                yield elem

    def quit(self):
        try:
+            self.service.stop()
            self.service.process.kill()
+            self.command_executor.close()
            self.service.process.wait(5)
            logger.debug("webdriver process ended")
        except (AttributeError, RuntimeError, OSError):
@@ -727,7 +783,7 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
            os.kill(self.browser_pid, 15)
            logger.debug("gracefully closed browser")
        except Exception as e:  # noqa
-            logger.debug(e, exc_info=True)
+            pass
        if (
            hasattr(self, "keep_user_data_dir")
            and hasattr(self, "user_data_dir")
@@ -746,7 +802,11 @@ class Chrome(selenium.webdriver.chrome.webdriver.WebDriver):
                else:
                    logger.debug("successfully removed %s" % self.user_data_dir)
                    break
+
+                try:
                    time.sleep(0.1)
+                except OSError:
+                    pass

        # dereference patcher, so patcher can start cleaning up as well.
        # this must come last, otherwise it will throw 'in use' errors
@@ -841,10 +901,10 @@ def find_chrome_executable():
            if item is not None:
                for subitem in (
                    "Google/Chrome/Application",
-                    "Google/Chrome Beta/Application",
-                    "Google/Chrome Canary/Application",
                ):
                    candidates.add(os.sep.join((item, subitem, "chrome.exe")))
    for candidate in candidates:
+        logger.debug('checking if %s exists and is executable' % candidate)
        if os.path.exists(candidate) and os.access(candidate, os.X_OK):
+            logger.debug('found! using %s' % candidate)
            return os.path.normpath(candidate)
--- a/src/undetected_chromedriver/devtool.py
+++ b/src/undetected_chromedriver/devtool.py
@@ -2,6 +2,7 @@ import asyncio
 from collections.abc import Mapping
 from collections.abc import Sequence
 from functools import wraps
+import os
 import logging
 import threading
 import time
@@ -187,4 +188,6 @@ def test():

    time.sleep(10)

+    if os.name == "nt":
+        driver.close()
    driver.quit()
--- a/src/undetected_chromedriver/dprocess.py
+++ b/src/undetected_chromedriver/dprocess.py
@@ -41,6 +41,7 @@ def start_detached(executable, *args):
    # close pipes
    writer.close()
    reader.close()
+    process.close()

    return pid

--- a/src/undetected_chromedriver/patcher.py
+++ b/src/undetected_chromedriver/patcher.py
@@ -1,41 +1,35 @@
 #!/usr/bin/env python3
 # this module is part of undetected_chromedriver

-from distutils.version import LooseVersion
+from packaging.version import Version as LooseVersion
 import io
+import json
 import logging
 import os
+import pathlib
+import platform
 import random
 import re
+import shutil
 import string
+import subprocess
 import sys
 import time
 from urllib.request import urlopen
 from urllib.request import urlretrieve
 import zipfile
-
+from multiprocessing import Lock

 logger = logging.getLogger(__name__)

-IS_POSIX = sys.platform.startswith(("darwin", "cygwin", "linux", "linux2"))
+IS_POSIX = sys.platform.startswith(("darwin", "cygwin", "linux", "linux2", "freebsd"))


 class Patcher(object):
-    url_repo = "https://chromedriver.storage.googleapis.com"
-    zip_name = "chromedriver_%s.zip"
+    lock = Lock()
    exe_name = "chromedriver%s"

    platform = sys.platform
-    if platform.endswith("win32"):
-        zip_name %= "win32"
-        exe_name %= ".exe"
-    if platform.endswith(("linux", "linux2")):
-        zip_name %= "linux64"
-        exe_name %= ""
-    if platform.endswith("darwin"):
-        zip_name %= "mac64"
-        exe_name %= ""
-
    if platform.endswith("win32"):
        d = "~/appdata/roaming/undetected_chromedriver"
    elif "LAMBDA_TASK_ROOT" in os.environ:
@@ -48,7 +42,13 @@ class Patcher(object):
        d = "~/.undetected_chromedriver"
    data_path = os.path.abspath(os.path.expanduser(d))

-    def __init__(self, executable_path=None, force=False, version_main: int = 0):
+    def __init__(
+        self,
+        executable_path=None,
+        force=False,
+        version_main: int = 0,
+        user_multi_procs=False,
+    ):
        """
        Args:
            executable_path: None = automatic
@@ -61,11 +61,33 @@ class Patcher(object):
        self.force = force
        self._custom_exe_path = False
        prefix = "undetected"
+        self.user_multi_procs = user_multi_procs
+
+        try:
+            # Try to convert version_main into an integer
+            version_main_int = int(version_main)
+            # check if version_main_int is less than or equal to e.g 114
+            self.is_old_chromedriver = version_main and version_main_int <= 114
+        except (ValueError,TypeError):
+            # Check not running inside Docker
+            if not os.path.exists("/app/chromedriver"):
+                # If the conversion fails, log an error message
+                logging.info("version_main cannot be converted to an integer")
+            # Set self.is_old_chromedriver to False if the conversion fails
+            self.is_old_chromedriver = False
+
+        # Needs to be called before self.exe_name is accessed
+        self._set_platform_name()

        if not os.path.exists(self.data_path):
            os.makedirs(self.data_path, exist_ok=True)

        if not executable_path:
+            if sys.platform.startswith("freebsd"):
+                self.executable_path = os.path.join(
+                    self.data_path, self.exe_name
+                )
+            else:
                self.executable_path = os.path.join(
                    self.data_path, "_".join([prefix, self.exe_name])
                )
@@ -78,6 +100,7 @@ class Patcher(object):
        self.zip_path = os.path.join(self.data_path, prefix)

        if not executable_path:
+            if not self.user_multi_procs:
                self.executable_path = os.path.abspath(
                    os.path.join(".", self.executable_path)
                )
@@ -85,10 +108,59 @@ class Patcher(object):
        if executable_path:
            self._custom_exe_path = True
            self.executable_path = executable_path
+
+        # Set the correct repository to download the Chromedriver from
+        if self.is_old_chromedriver:
+            self.url_repo = "https://chromedriver.storage.googleapis.com"
+        else:
+            self.url_repo = "https://googlechromelabs.github.io/chrome-for-testing"
+
        self.version_main = version_main
        self.version_full = None

-    def auto(self, executable_path=None, force=False, version_main=None):
+    def _set_platform_name(self):
+        """
+        Set the platform and exe name based on the platform undetected_chromedriver is running on
+        in order to download the correct chromedriver.
+        """
+        if self.platform.endswith("win32"):
+            self.platform_name = "win32"
+            self.exe_name %= ".exe"
+        if self.platform.endswith(("linux", "linux2")):
+            self.platform_name = "linux64"
+            self.exe_name %= ""
+        if self.platform.endswith("darwin"):
+            if self.is_old_chromedriver:
+                self.platform_name = "mac64"
+            else:
+                self.platform_name = "mac-x64"
+            self.exe_name %= ""
+        if self.platform.startswith("freebsd"):
+            self.platform_name = "freebsd"
+            self.exe_name %= ""
+
+    def auto(self, executable_path=None, force=False, version_main=None, _=None):
+        """
+
+        Args:
+            executable_path:
+            force:
+            version_main:
+
+        Returns:
+
+        """
+        p = pathlib.Path(self.data_path)
+        if self.user_multi_procs:
+            with Lock():
+                files = list(p.rglob("*chromedriver*"))
+                most_recent = max(files, key=lambda f: f.stat().st_mtime)
+                files.remove(most_recent)
+                list(map(lambda f: f.unlink(), files))
+                if self.is_binary_patched(most_recent):
+                    self.executable_path = str(most_recent)
+                    return True
+
        if executable_path:
            self.executable_path = executable_path
            self._custom_exe_path = True
@@ -105,6 +177,35 @@ class Patcher(object):
        if force is True:
            self.force = force

+
+        if self.platform_name == "freebsd":
+            chromedriver_path = shutil.which("chromedriver")
+
+            if not os.path.isfile(chromedriver_path) or not os.access(chromedriver_path, os.X_OK):
+                logging.error("Chromedriver not installed!")
+                return
+
+            version_path = os.path.join(os.path.dirname(self.executable_path), "version.txt")
+
+            process = os.popen(f'"{chromedriver_path}" --version')
+            chromedriver_version = process.read().split(' ')[1].split(' ')[0]
+            process.close()
+
+            current_version = None
+            if os.path.isfile(version_path) or os.access(version_path, os.X_OK):
+                with open(version_path, 'r') as f:
+                    current_version = f.read()
+
+            if current_version != chromedriver_version:
+                logging.info("Copying chromedriver executable...")
+                shutil.copy(chromedriver_path, self.executable_path)
+                os.chmod(self.executable_path, 0o755)
+
+                with open(version_path, 'w') as f:
+                    f.write(chromedriver_version)
+
+                logging.info("Chromedriver executable copied!")
+        else:
            try:
                os.unlink(self.executable_path)
            except PermissionError:
@@ -122,11 +223,59 @@ class Patcher(object):
                pass

            release = self.fetch_release_number()
-        self.version_main = release.version[0]
+            self.version_main = release.major
            self.version_full = release
            self.unzip_package(self.fetch_package())
+
        return self.patch()

+    def driver_binary_in_use(self, path: str = None) -> bool:
+        """
+        naive test to check if a found chromedriver binary is
+        currently in use
+
+        Args:
+            path: a string or PathLike object to the binary to check.
+                  if not specified, we check use this object's executable_path
+        """
+        if not path:
+            path = self.executable_path
+        p = pathlib.Path(path)
+
+        if not p.exists():
+            raise OSError("file does not exist: %s" % p)
+        try:
+            with open(p, mode="a+b") as fs:
+                exc = []
+                try:
+
+                    fs.seek(0, 0)
+                except PermissionError as e:
+                    exc.append(e)  # since some systems apprently allow seeking
+                    # we conduct another test
+                try:
+                    fs.readline()
+                except PermissionError as e:
+                    exc.append(e)
+
+                if exc:
+
+                    return True
+                return False
+            # ok safe to assume this is in use
+        except Exception as e:
+            # logger.exception("whoops ", e)
+            pass
+
+    def cleanup_unused_files(self):
+        p = pathlib.Path(self.data_path)
+        items = list(p.glob("*undetected*"))
+        for item in items:
+            try:
+                item.unlink()
+            except:
+                pass
+
    def patch(self):
        self.patch_exe()
        return self.is_binary_patched()
@@ -137,13 +286,33 @@ class Patcher(object):
        :return: version string
        :rtype: LooseVersion
        """
-        path = "/latest_release"
-        if self.version_main:
-            path += f"_{self.version_main}"
+        # Endpoint for old versions of Chromedriver (114 and below)
+        if self.is_old_chromedriver:
+            path = f"/latest_release_{self.version_main}"
            path = path.upper()
            logger.debug("getting release number from %s" % path)
            return LooseVersion(urlopen(self.url_repo + path).read().decode())

+        # Endpoint for new versions of Chromedriver (115+)
+        if not self.version_main:
+            # Fetch the latest version
+            path = "/last-known-good-versions-with-downloads.json"
+            logger.debug("getting release number from %s" % path)
+            with urlopen(self.url_repo + path) as conn:
+                response = conn.read().decode()
+
+            last_versions = json.loads(response)
+            return LooseVersion(last_versions["channels"]["Stable"]["version"])
+
+        # Fetch the latest minor version of the major version provided
+        path = "/latest-versions-per-milestone-with-downloads.json"
+        logger.debug("getting release number from %s" % path)
+        with urlopen(self.url_repo + path) as conn:
+            response = conn.read().decode()
+
+        major_versions = json.loads(response)
+        return LooseVersion(major_versions["milestones"][str(self.version_main)]["version"])
+
    def parse_exe_version(self):
        with io.open(self.executable_path, "rb") as f:
            for line in iter(lambda: f.readline(), b""):
@@ -157,10 +326,16 @@ class Patcher(object):

        :return: path to downloaded file
        """
-        u = "%s/%s/%s" % (self.url_repo, self.version_full.vstring, self.zip_name)
-        logger.debug("downloading from %s" % u)
-        # return urlretrieve(u, filename=self.data_path)[0]
-        return urlretrieve(u)[0]
+        zip_name = f"chromedriver_{self.platform_name}.zip"
+        if self.is_old_chromedriver:
+            download_url = "%s/%s/%s" % (self.url_repo, str(self.version_full), zip_name)
+        else:
+            zip_name = zip_name.replace("_", "-", 1)
+            download_url = "https://storage.googleapis.com/chrome-for-testing-public/%s/%s/%s"
+            download_url %= (str(self.version_full), self.platform_name, zip_name)
+
+        logger.debug("downloading from %s" % download_url)
+        return urlretrieve(download_url)[0]

    def unzip_package(self, fp):
        """
@@ -168,6 +343,12 @@ class Patcher(object):

        :return: path to unpacked executable
        """
+        exe_path = self.exe_name
+        if not self.is_old_chromedriver:
+            # The new chromedriver unzips into its own folder
+            zip_name = f"chromedriver-{self.platform_name}"
+            exe_path = os.path.join(zip_name, self.exe_name)
+
        logger.debug("unzipping %s" % fp)
        try:
            os.unlink(self.zip_path)
@@ -176,10 +357,10 @@ class Patcher(object):

        os.makedirs(self.zip_path, mode=0o755, exist_ok=True)
        with zipfile.ZipFile(fp, mode="r") as zf:
-            zf.extract(self.exe_name, self.zip_path)
-        os.rename(os.path.join(self.zip_path, self.exe_name), self.executable_path)
+            zf.extractall(self.zip_path)
+        os.rename(os.path.join(self.zip_path, exe_path), self.executable_path)
        os.remove(fp)
-        os.rmdir(self.zip_path)
+        shutil.rmtree
        os.chmod(self.executable_path, 0o755)
        return self.executable_path

@@ -193,10 +374,31 @@ class Patcher(object):
        """
        exe_name = os.path.basename(exe_name)
        if IS_POSIX:
-            r = os.system("kill -f -9 $(pidof %s)" % exe_name)
+            # Using shell=True for pidof, consider a more robust pid finding method if issues arise.
+            # pgrep can be an alternative: ["pgrep", "-f", exe_name]
+            # Or psutil if adding a dependency is acceptable.
+            command = f"pidof {exe_name}"
+            try:
+                result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
+                pids = result.stdout.strip().split()
+                if pids:
+                    subprocess.run(["kill", "-9"] + pids, check=False) # Changed from -f -9 to -9 as -f is not standard for kill
+                    return True
+                return False # No PIDs found
+            except subprocess.CalledProcessError: # pidof returns 1 if no process found
+                return False # No process found
+            except Exception as e:
+                logger.debug(f"Error killing process on POSIX: {e}")
+                return False
        else:
-            r = os.system("taskkill /f /im %s" % exe_name)
-        return not r
+            try:
+                # TASKKILL /F /IM chromedriver.exe
+                result = subprocess.run(["taskkill", "/f", "/im", exe_name], check=False, capture_output=True)
+                # taskkill returns 0 if process was killed, 128 if not found.
+                return result.returncode == 0
+            except Exception as e:
+                logger.debug(f"Error killing process on Windows: {e}")
+                return False

    @staticmethod
    def gen_random_cdc():
@@ -255,21 +457,17 @@ class Patcher(object):
        else:
            timeout = 3  # stop trying after this many seconds
            t = time.monotonic()
-            while True:
-                now = time.monotonic()
-                if now - t > timeout:
+            now = lambda: time.monotonic()
+            while now() - t > timeout:
                # we don't want to wait until the end of time
-                    logger.debug(
-                        "could not unlink %s in time (%d seconds)"
-                        % (self.executable_path, timeout)
-                    )
-                    break
                try:
+                    if self.user_multi_procs:
+                        break
                    os.unlink(self.executable_path)
                    logger.debug("successfully unlinked %s" % self.executable_path)
                    break
                except (OSError, RuntimeError, PermissionError):
-                    time.sleep(0.1)
+                    time.sleep(0.01)
                    continue
                except FileNotFoundError:
                    break
--- a/src/utils.py
+++ b/src/utils.py
@@ -1,13 +1,19 @@
 import json
 import logging
 import os
+import platform
 import re
 import shutil
+import sys
+import tempfile
+import urllib.parse

 from selenium.webdriver.chrome.webdriver import WebDriver
 import undetected_chromedriver as uc

 FLARESOLVERR_VERSION = None
+PLATFORM_VERSION = None
+CHROME_EXE_PATH = None
 CHROME_MAJOR_VERSION = None
 USER_AGENT = None
 XVFB_DISPLAY = None
@@ -22,32 +28,147 @@ def get_config_headless() -> bool:
    return os.environ.get('HEADLESS', 'true').lower() == 'true'


+def get_config_disable_media() -> bool:
+    return os.environ.get('DISABLE_MEDIA', 'false').lower() == 'true'
+
+
 def get_flaresolverr_version() -> str:
    global FLARESOLVERR_VERSION
    if FLARESOLVERR_VERSION is not None:
        return FLARESOLVERR_VERSION

    package_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.pardir, 'package.json')
+    if not os.path.isfile(package_path):
+        package_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'package.json')
    with open(package_path) as f:
        FLARESOLVERR_VERSION = json.loads(f.read())['version']
        return FLARESOLVERR_VERSION

+def get_current_platform() -> str:
+    global PLATFORM_VERSION
+    if PLATFORM_VERSION is not None:
+        return PLATFORM_VERSION
+    PLATFORM_VERSION = os.name
+    return PLATFORM_VERSION

-def get_webdriver() -> WebDriver:
-    global PATCHED_DRIVER_PATH
+
+def create_proxy_extension(proxy: dict) -> str:
+    parsed_url = urllib.parse.urlparse(proxy['url'])
+    scheme = parsed_url.scheme
+    host = parsed_url.hostname
+    port = parsed_url.port
+    username = proxy['username']
+    password = proxy['password']
+    manifest_json = """
+    {
+        "version": "1.0.0",
+        "manifest_version": 3,
+        "name": "Chrome Proxy",
+        "permissions": [
+            "proxy",
+            "tabs",
+            "storage",
+            "webRequest",
+            "webRequestAuthProvider"
+        ],
+        "host_permissions": [
+          "<all_urls>"
+        ],
+        "background": {
+          "service_worker": "background.js"
+        },
+        "minimum_chrome_version": "76.0.0"
+    }
+    """
+
+    background_js = """
+    var config = {
+        mode: "fixed_servers",
+        rules: {
+            singleProxy: {
+                scheme: "%s",
+                host: "%s",
+                port: %d
+            },
+            bypassList: ["localhost"]
+        }
+    };
+
+    chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});
+
+    function callbackFn(details) {
+        return {
+            authCredentials: {
+                username: "%s",
+                password: "%s"
+            }
+        };
+    }
+
+    chrome.webRequest.onAuthRequired.addListener(
+        callbackFn,
+        { urls: ["<all_urls>"] },
+        ['blocking']
+    );
+    """ % (
+        scheme,
+        host,
+        port,
+        username,
+        password
+    )
+
+    proxy_extension_dir = tempfile.mkdtemp()
+
+    with open(os.path.join(proxy_extension_dir, "manifest.json"), "w") as f:
+        f.write(manifest_json)
+
+    with open(os.path.join(proxy_extension_dir, "background.js"), "w") as f:
+        f.write(background_js)
+
+    return proxy_extension_dir
+
+
+def get_webdriver(proxy: dict = None) -> WebDriver:
+    global PATCHED_DRIVER_PATH, USER_AGENT
    logging.debug('Launching web browser...')

    # undetected_chromedriver
    options = uc.ChromeOptions()
    options.add_argument('--no-sandbox')
    options.add_argument('--window-size=1920,1080')
+    options.add_argument('--disable-search-engine-choice-screen')
    # todo: this param shows a warning in chrome head-full
    options.add_argument('--disable-setuid-sandbox')
    options.add_argument('--disable-dev-shm-usage')
    # this option removes the zygote sandbox (it seems that the resolution is a bit faster)
    options.add_argument('--no-zygote')
+    # attempt to fix Docker ARM32 build
+    IS_ARMARCH = platform.machine().startswith(('arm', 'aarch'))
+    if IS_ARMARCH:
+        options.add_argument('--disable-gpu-sandbox')
+    options.add_argument('--ignore-certificate-errors')
+    options.add_argument('--ignore-ssl-errors')

-    # note: headless mode is detected (options.headless = True)
+    language = os.environ.get('LANG', None)
+    if language is not None:
+        options.add_argument('--accept-lang=%s' % language)
+
+    # Fix for Chrome 117 | https://github.com/FlareSolverr/FlareSolverr/issues/910
+    if USER_AGENT is not None:
+        options.add_argument('--user-agent=%s' % USER_AGENT)
+
+    proxy_extension_dir = None
+    if proxy and all(key in proxy for key in ['url', 'username', 'password']):
+        proxy_extension_dir = create_proxy_extension(proxy)
+        options.add_argument("--disable-features=DisableLoadExtensionCommandLineSwitch")
+        options.add_argument("--load-extension=%s" % os.path.abspath(proxy_extension_dir))
+    elif proxy and 'url' in proxy:
+        proxy_url = proxy['url']
+        logging.debug("Using webdriver proxy: %s", proxy_url)
+        options.add_argument('--proxy-server=%s' % proxy_url)
+
+    # note: headless mode is detected (headless = True)
    # we launch the browser in head-full mode with the window hidden
    windows_headless = False
    if get_config_headless():
@@ -55,6 +176,8 @@ def get_webdriver() -> WebDriver:
            windows_headless = True
        else:
            start_xvfb_display()
+    # For normal headless mode:
+    # options.add_argument('--headless')

    # if we are inside the Docker container, we avoid downloading the driver
    driver_exe_path = None
@@ -67,16 +190,30 @@ def get_webdriver() -> WebDriver:
        if PATCHED_DRIVER_PATH is not None:
            driver_exe_path = PATCHED_DRIVER_PATH

+    # detect chrome path
+    browser_executable_path = get_chrome_exe_path()
+
    # downloads and patches the chromedriver
    # if we don't set driver_executable_path it downloads, patches, and deletes the driver each time
-    driver = uc.Chrome(options=options, driver_executable_path=driver_exe_path, version_main=version_main,
-                       windows_headless=windows_headless)
+    try:
+        driver = uc.Chrome(options=options, browser_executable_path=browser_executable_path,
+                           driver_executable_path=driver_exe_path, version_main=version_main,
+                           windows_headless=windows_headless, headless=get_config_headless())
+    except Exception as e:
+        logging.error("Error starting Chrome: %s" % e)
+        # No point in continuing if we cannot retrieve the driver
+        raise e

    # save the patched driver to avoid re-downloads
    if driver_exe_path is None:
        PATCHED_DRIVER_PATH = os.path.join(driver.patcher.data_path, driver.patcher.exe_name)
+        if PATCHED_DRIVER_PATH != driver.patcher.executable_path:
            shutil.copy(driver.patcher.executable_path, PATCHED_DRIVER_PATH)

+    # clean up proxy extension directory
+    if proxy_extension_dir is not None:
+        shutil.rmtree(proxy_extension_dir)
+
    # selenium vanilla
    # options = webdriver.ChromeOptions()
    # options.add_argument('--no-sandbox')
@@ -89,7 +226,25 @@ def get_webdriver() -> WebDriver:


 def get_chrome_exe_path() -> str:
-    return uc.find_chrome_executable()
+    global CHROME_EXE_PATH
+    if CHROME_EXE_PATH is not None:
+        return CHROME_EXE_PATH
+    # linux pyinstaller bundle
+    chrome_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'chrome', "chrome")
+    if os.path.exists(chrome_path):
+        if not os.access(chrome_path, os.X_OK):
+            raise Exception(f'Chrome binary "{chrome_path}" is not executable. '
+                            f'Please, extract the archive with "tar xzf <file.tar.gz>".')
+        CHROME_EXE_PATH = chrome_path
+        return CHROME_EXE_PATH
+    # windows pyinstaller bundle
+    chrome_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'chrome', "chrome.exe")
+    if os.path.exists(chrome_path):
+        CHROME_EXE_PATH = chrome_path
+        return CHROME_EXE_PATH
+    # system
+    CHROME_EXE_PATH = uc.find_chrome_executable()
+    return CHROME_EXE_PATH


 def get_chrome_major_version() -> str:
@@ -98,17 +253,17 @@ def get_chrome_major_version() -> str:
        return CHROME_MAJOR_VERSION

    if os.name == 'nt':
-        try:
-            stream = os.popen(
-                'reg query "HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Google Chrome"')
-            output = stream.read()
        # Example: '104.0.5112.79'
-            complete_version = extract_version_registry(output)
+        try:
+            complete_version = extract_version_nt_executable(get_chrome_exe_path())
+        except Exception:
+            try:
+                complete_version = extract_version_nt_registry()
            except Exception:
                # Example: '104.0.5112.79'
-            complete_version = extract_version_folder()
+                complete_version = extract_version_nt_folder()
    else:
-        chrome_path = uc.find_chrome_executable()
+        chrome_path = get_chrome_exe_path()
        process = os.popen(f'"{chrome_path}" --version')
        # Example 1: 'Chromium 104.0.5112.79 Arch Linux\n'
        # Example 2: 'Google Chrome 104.0.5112.79 Arch Linux\n'
@@ -119,8 +274,19 @@ def get_chrome_major_version() -> str:
    return CHROME_MAJOR_VERSION


-def extract_version_registry(output) -> str:
-    try:
+def extract_version_nt_executable(exe_path: str) -> str:
+    import pefile
+    pe = pefile.PE(exe_path, fast_load=True)
+    pe.parse_data_directories(
+        directories=[pefile.DIRECTORY_ENTRY["IMAGE_DIRECTORY_ENTRY_RESOURCE"]]
+    )
+    return pe.FileInfo[0][0].StringTable[0].entries[b"FileVersion"].decode('utf-8')
+
+
+def extract_version_nt_registry() -> str:
+    stream = os.popen(
+        'reg query "HKLM\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Google Chrome"')
+    output = stream.read()
    google_version = ''
    for letter in output[output.rindex('DisplayVersion    REG_SZ') + 24:]:
        if letter != '\n':
@@ -128,11 +294,9 @@ def extract_version_registry(output) -> str:
        else:
            break
    return google_version.strip()
-    except TypeError:
-        return ''


-def extract_version_folder() -> str:
+def extract_version_nt_folder() -> str:
    # Check if the Chrome folder exists in the x32 or x64 Program Files folders.
    for i in range(2):
        path = 'C:\\Program Files' + (' (x86)' if i else '') + '\\Google\\Chrome\\Application'
@@ -140,7 +304,7 @@ def extract_version_folder() -> str:
            paths = [f.path for f in os.scandir(path) if f.is_dir()]
            for path in paths:
                filename = os.path.basename(path)
-                pattern = '\d+\.\d+\.\d+\.\d+'
+                pattern = r'\d+\.\d+\.\d+\.\d+'
                match = re.search(pattern, filename)
                if match and match.group():
                    # Found a Chrome version.
@@ -157,11 +321,15 @@ def get_user_agent(driver=None) -> str:
        if driver is None:
            driver = get_webdriver()
        USER_AGENT = driver.execute_script("return navigator.userAgent")
+        # Fix for Chrome 117 | https://github.com/FlareSolverr/FlareSolverr/issues/910
+        USER_AGENT = re.sub('HEADLESS', '', USER_AGENT, flags=re.IGNORECASE)
        return USER_AGENT
    except Exception as e:
        raise Exception("Error getting browser User-Agent. " + str(e))
    finally:
        if driver is not None:
+            if PLATFORM_VERSION == "nt":
+                driver.close()
            driver.quit()


--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -1 +1 @@
-WebTest==3.0.0
+WebTest==3.0.7
Author	SHA1	Message	Date
ilike2burnthing	0fe9958afe	Update README.md	2025-12-03 08:51:24 +00:00
Prodan Denis	9f8c71131f	Resolve turnstile captcha (#1634 ) Fixes #804	2025-12-03 08:50:31 +00:00
ilike2burnthing	2405c00521	Add formatting to log file Resolves #1635	2025-12-03 07:07:54 +00:00
ilike2burnthing	ff65b7cc68	Bump version 3.4.6 (#1633 )	2025-11-29 02:42:42 +00:00
Azizul Haque Ananto	409e0844a7	Add disable image, css, fonts option with CDP (#1626 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-11-29 02:27:05 +00:00
ilike2burnthing	368d5d4e05	Update README.md	2025-11-26 00:15:20 +00:00
ilike2burnthing	c7505e3cbf	Revert to Python v3.13 and bump FlareSolverr to 3.4.5 (#1617 )	2025-11-11 01:58:14 +00:00
ilike2burnthing	5a27090abe	Fix Dockerfile casing	2025-11-06 02:11:28 +00:00
flower	e505ea4fe4	Fix changelog building (#1611 )	2025-11-06 00:52:46 +00:00
ilike2burnthing	63b6fc53e3	Bump version 3.4.4 (#1609 )	2025-11-04 23:04:55 +00:00
flower	8d72617219	Bump dependencies, Chrome, and some other general fixes (#1607 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-11-04 22:49:32 +00:00
ilike2burnthing	8a8b9415c3	Bump version 3.4.3 (#1601 )	2025-10-28 10:21:38 +00:00
ilike2burnthing	16722ef963	Update proxy extension. Fixes #1534	2025-10-28 00:01:30 +00:00
ilike2burnthing	bbc24e9d86	Bump version 3.4.2 (#1590 )	2025-10-09 20:05:32 +01:00
acg5159	7dfdfc5e33	Add log file support (#1480 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-10-09 19:55:32 +01:00
Esteban Thilliez	136422c85c	Add `returnScreenshot` parameter to screenshot the final web page (#1439 )	2025-10-08 10:59:39 +01:00
flower	05a72f2709	bump: dependencies (#1585 )	2025-10-05 16:25:13 +01:00
flower	da810830da	Bump prometheus-client to 0.23.1 (#1583 )	2025-10-02 12:32:01 +01:00
Warrenberberd	d27f57c27c	Add quote protection for password containing it (#858 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-10-01 06:46:08 +01:00
eZ4RK0	a916d93779	Handle empty string and keys without value in postData. resolves #1548 (#1550 )	2025-10-01 04:56:57 +01:00
Kishan Joshi	0d889cb0b2	Add proxy envs (#1499 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-09-20 13:43:58 +01:00
Kennedy Oliveira	d430404de8	Add optional wait time after resolving the challenge before returning (#1046 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2025-09-20 04:59:16 +01:00
flower	d3b1ba6e88	Bump dependencies & CI actions (#1578 )	2025-09-18 21:20:15 +01:00
ilike2burnthing	75e5b190d6	Bump version 3.4.1 (#1576 )	2025-09-15 19:01:04 +01:00
ilike2burnthing	cdc3db3c21	Change access denied title check to use startswith. resolves #1574	2025-09-15 18:55:40 +01:00
ilike2burnthing	2dbb0442e0	Fix regex pattern syntax in utils.py	2025-08-25 04:50:05 +01:00
ilike2burnthing	6faab19533	Bump version 3.4.0 (#1564 )	2025-08-25 04:21:44 +01:00
ilike2burnthing	af0a7af757	Remove disable software rasterizer option for ARM builds	2025-08-25 04:17:22 +01:00
Alex Naidis	ff74b50b60	Modernize and upgrade application (#1540 ) Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2025-08-25 03:55:06 +01:00
ilike2burnthing	3e51ac1188	Update README.md	2025-06-26 05:30:44 +01:00
ilike2burnthing	6627de4fa6	Bump version 3.3.25 (#1523 )	2025-06-14 03:52:28 +01:00
ilike2burnthing	fe649255f2	Revert "Fix Chrome GL erros in ASUSTOR NAS" This reverts commit `8316350b98`.	2025-06-14 03:42:08 +01:00
dependabot[bot]	3e338fce2e	Bump requests from 2.32.3 to 2.32.4 (#1516 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2025-06-11 02:48:00 +01:00
ilike2burnthing	3dd3e7559d	u_c: remove apparent c&p typo https://github.com/ultrafunkamsterdam/undetected-chromedriver/pull/1933	2025-06-06 08:04:00 +01:00
ilike2burnthing	f21c1d51bc	Restore example service file. #1204	2025-06-04 23:13:00 +01:00
ilike2burnthing	957347f73a	Bump version 3.3.24 (#1505 )	2025-06-04 19:02:06 +01:00
ilike2burnthing	c55080b0ec	Remove hidden character	2025-06-04 18:54:48 +01:00
ilike2burnthing	639bfca020	Bump version 3.3.23 (#1504 )	2025-06-04 18:51:31 +01:00
ilike2burnthing	237694df76	Update base image to bookworm. resolves #1503	2025-06-04 18:44:17 +01:00
ilike2burnthing	6e5d6f1795	Bump version 3.3.22 (#1500 )	2025-06-03 05:54:25 +01:00
ilike2burnthing	30804a86e5	Bump Chromium to v137 for build	2025-06-03 05:39:46 +01:00
ilike2burnthing	e0bdaf7745	Don't open devtools	2025-06-03 05:38:55 +01:00
ilike2burnthing	795365dbe4	Change from click to keys credit to @sh4dowb - #1497	2025-06-03 05:38:06 +01:00
ilike2burnthing	ce5369dd41	Update bug_report.yml fix accidental delete	2025-03-04 02:05:23 +00:00
ilike2burnthing	600b09d498	Update bug_report.yml	2025-03-04 02:04:29 +00:00
ilike2burnthing	d1f19405a1	Update README.md. closes #1267	2025-01-21 20:27:36 +00:00
ilike2burnthing	82a1366d34	Remove dead directory link from readme. resolve #1436	2025-01-20 17:37:14 +00:00
dependabot[bot]	a2fe9e7776	Bump waitress from 2.1.2 to 3.0.1 (#1418 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2024-11-29 01:53:34 +00:00
ilike2burnthing	6cc628df9e	Disable search engine choice screen	2024-11-24 18:31:50 +00:00
Eduard Tykhoniuk	8b1851eeb1	Fix headless=false stalling	2024-11-24 18:30:35 +00:00
ilike2burnthing	54668a11e7	bug_report: lint fix again	2024-09-28 08:08:49 +01:00
ilike2burnthing	701d8fb4ff	bug_report: change to input	2024-09-28 08:07:56 +01:00
ilike2burnthing	39a265ccb8	bug_report: lint fix	2024-09-28 07:58:14 +01:00
ilike2burnthing	e32b247014	bug_report: default=0	2024-09-28 07:57:11 +01:00
ilike2burnthing	0d8fe8fe50	bug_report: no booleans allowed	2024-09-28 07:51:57 +01:00
ilike2burnthing	718da3a36f	bug_report: add 'no really' drop down maybe this will help... 🙄	2024-09-28 07:50:11 +01:00
ilike2burnthing	a798561338	Bump requests version *.0 was yanked	2024-07-30 02:38:13 +01:00
Bogdan	eb680efc90	Don't build docker images for PRs from forks (#1281 )	2024-07-20 22:08:40 +03:00
ilike2burnthing	0f8f0bec25	revert and bump action version	2024-07-20 19:41:49 +01:00
ilike2burnthing	3d9bc5627b	Change to GITHUB_TOKEN for GHRC login	2024-07-20 14:21:34 +01:00
ilike2burnthing	dd7eaee2e3	Bump requirements resolves Dependabot alerts	2024-07-12 17:11:40 +01:00
ilike2burnthing	031177bbdb	Bump version 3.3.21 (#1240 )	2024-06-26 02:14:25 +01:00
Bogdan	a8644532a1	Escape values for generated form used in `request.post` (#1236 ) and build docker images for PRs	2024-06-26 02:04:59 +01:00
ilike2burnthing	e96161c873	Add challenge selector to catch reloading page on non-English systems. resolves #1237	2024-06-25 22:32:06 +01:00
ilike2burnthing	5a1f25cd52	Bump version 3.3.20 (#1229 )	2024-06-21 22:21:37 +01:00
tenettow	a2c0e4348e	Update Cloudflare challenge and checkbox selectors (#1224 )	2024-06-21 22:07:03 +01:00
ilike2burnthing	2ecf88895b	Check not running in Docker before logging version_main error	2024-06-15 08:37:42 +01:00
ilike2burnthing	984368edb5	maxTimeout should always be int. resolves #1212	2024-06-15 05:41:45 +01:00
21hsmw	6c1d78cb84	Fix occasional headless issue on Linux when set to "false" (#1199 ) * Fix occasional headless issue on Linux when set to "false" - Add a variable containing the current platform - Check if the platform is "nt" (Windows) before closing the driver * Update CHANGELOG.md --------- Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2024-05-24 17:33:46 +01:00
ilike2burnthing	5a2c61601e	Fix Chrome v124+ not closing on Windows. resolves #1161 (#1193 )	2024-05-20 00:52:55 +01:00
ilike2burnthing	c304da2964	Update README.md	2024-04-22 23:30:52 +01:00
ilike2burnthing	b811412699	Fix LANG ENV for Linux. #1036	2024-04-20 03:41:53 +01:00
Ross Patterson	0bb8de144f	Add Compose V2 command to readme (#1154 ) Co-authored-by: root@library.moodysalon.net <root@library.moodysalon.net> Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2024-04-18 05:07:06 +01:00
ilike2burnthing	38166dfaa0	Bump version 3.3.17 (#1147 )	2024-04-09 20:31:21 +01:00
ilike2burnthing	8dea0ed017	Fix file descriptor leak in service on quit(). resolves #983 credit: @zkulis - https://github.com/ultrafunkamsterdam/undetected-chromedriver/pull/1812	2024-04-09 20:27:42 +01:00
francisco-lafe	20cd2944a7	Update README.md (#1127 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2024-03-19 18:05:11 +00:00
ilike2burnthing	fd773e5909	Bump version 3.3.16 (#1105 )	2024-02-28 21:38:53 +00:00
Justin Kromlinger	35c7bff3c8	Use headless configuration properly (#1104 )	2024-02-28 20:36:38 +00:00
Raphaël	afdc1c7a8e	Add FreeBSD support (#1054 )	2024-02-28 02:45:04 +00:00
ilike2burnthing	0bc7a4498c	Update README.md	2024-02-23 05:01:00 +00:00
Xewdy	c5a5f6d65e	Add platform specifiers to dependencies (#877 )	2024-02-21 21:14:25 +00:00
ilike2burnthing	aaf29be8e1	Bump version 3.3.15 (#1088 )	2024-02-20 23:48:23 +00:00
Tadas Gedgaudas	800866d033	Fix looping challenges. #1036 (#1065 ) Co-authored-by: Tadas Gedgaudas <tg@infrahub.io> Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2024-02-20 23:41:02 +00:00
ilike2burnthing	043f18b231	Bump UC version to 3.5.5	2024-02-17 19:28:06 +00:00
ilike2burnthing	d21a332519	Hotfix 2 - bad Chromium build, instances failed to terminate (#1072 )	2024-02-17 05:53:45 +00:00
ilike2burnthing	3ca6d08f41	Hotfix for Linux build - some Chrome files no longer exist (#1071 )	2024-02-17 01:15:32 +00:00
ilike2burnthing	227bd7ac72	Update Chrome downloads (#1070 )	2024-02-17 00:50:14 +00:00
ilike2burnthing	e6a08584c0	Update README.md thanks @kimboslice99	2024-02-16 04:35:37 +00:00
ilike2burnthing	df06d13cf8	Update README.md	2024-01-12 23:38:18 +00:00
ilike2burnthing	993b8c41ac	Fix too many open files error. resolves #983 (#1033 )	2024-01-07 21:22:14 +00:00
ilike2burnthing	a4d42d7834	Remove unnecessary comment	2023-12-17 00:33:06 +00:00
21hsmw	1c855b8af0	Fix looping challenges and invalid cookies. resolves #1006 (#1010 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-12-15 22:11:58 +00:00
ilike2burnthing	745c69491f	Bump version 3.3.11 (#999 )	2023-12-11 20:56:14 +00:00
txtsd	f7e316fd5a	updates: UC 3.5.4 & Selenium 4.15.2 (#970 ) Co-authored-by: GaspardRuan <1039553124@qq.com> Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-12-11 20:51:16 +00:00
ilike2burnthing	16c8ab5f3d	Update README.md	2023-11-14 07:54:09 +00:00
ilike2burnthing	7af311b73c	Bump version 3.3.10 (#969 )	2023-11-14 04:04:42 +00:00
ilike2burnthing	daec97532d	Update README.md	2023-11-14 04:00:01 +00:00
ilike2burnthing	8d7ed48f21	Add LANG ENV. resolves #951	2023-11-14 03:56:57 +00:00
ilike2burnthing	220f2599ae	Bump version 3.3.9 (#963 )	2023-11-13 07:17:28 +00:00
ilike2burnthing	d772cf3f50	Fix for Docker build, capture TypeError. Fixes #962	2023-11-13 07:14:13 +00:00
ilike2burnthing	ab4365894b	Bump version 3.3.8 (#961 )	2023-11-13 04:55:49 +00:00
ilike2burnthing	3fa9631559	Fix "OSError: [WinError 6] The handle is invalid" on exit	2023-11-13 04:28:19 +00:00
ilike2burnthing	04858c22fd	Support running Chrome 119 from source (#960 )	2023-11-13 04:23:06 +00:00
Nabi KaramAliZadeh	5085ca6990	Fix headless=true for Chrome 117+. Fixes #910 (#921 )	2023-11-13 04:03:56 +00:00
ilike2burnthing	cd4df1e061	Bump version 3.3.7 (#944 )	2023-11-05 14:41:12 +00:00
ilike2burnthing	6c79783f7c	Bump version 3.3.6 (#905 )	2023-09-15 20:40:56 +01:00
ilike2burnthing	4139e8d47c	Update checkbox selector, again	2023-09-15 20:37:26 +01:00
zax2002	1942eb5fdc	Typo in README (#901 )	2023-09-14 07:41:59 +01:00
ilike2burnthing	401bf5be76	Bump version 3.3.5 (#902 )	2023-09-13 10:28:02 +01:00
ilike2burnthing	d8ffdd3061	Change checkbox selector, support language other than English. resolves #891	2023-09-13 10:19:19 +01:00
ilike2burnthing	2d66590b08	Bump version 3.3.4 (#884 )	2023-09-02 12:30:21 +01:00
Zachary Hampton	a217510dc7	Update checkbox selector (#882 )	2023-09-02 12:24:25 +01:00
ilike2burnthing	553bd8ab4f	Bump version 3.3.3 (#879 )	2023-08-31 20:02:17 +01:00
ilike2burnthing	1b197c3e53	Update undetected_chromedriver to v3.5.3 (#860 )	2023-08-31 19:56:06 +01:00
ngosang	fd308f01be	Bump version 3.3.2	2023-08-03 10:00:16 +02:00
ngosang	b5eef32615	Fix URL domain in Prometheus exporter	2023-08-03 09:02:46 +02:00
ngosang	644a843d89	Bump version 3.3.1	2023-08-03 08:13:01 +02:00
ngosang	82e1c94c6f	Fix HEADLESS=false in Windows binary	2023-08-03 08:10:14 +02:00
ngosang	fbc71516f5	Fix for Cloudflare verify checkbox	2023-08-03 07:28:58 +02:00
ngosang	40bd1cba4c	Fix Prometheus exporter for management and health endpoints	2023-08-03 06:36:31 +02:00
ngosang	d1588c1156	Remove misleading stack trace when a button is not found	2023-08-03 05:45:38 +02:00
ngosang	b4ad583baa	Revert "Update base Docker image to Debian Bookworm" This reverts commit `0edc50e271`.	2023-08-03 05:19:56 +02:00
ngosang	5d31e551cc	Revert "Install Chromium 115 from Debian testing" This reverts commit `2aa095ed5d`.	2023-08-03 05:19:27 +02:00
ngosang	d92845f34f	Bump version 3.3.0	2023-08-02 20:10:35 +02:00
ngosang	5d3b73ea9d	Add more traces in build_package.py	2023-08-02 20:05:42 +02:00
ngosang	2aa095ed5d	Install Chromium 115 from Debian testing	2023-08-02 19:30:39 +02:00
ngosang	687c8f75ae	Update pyinstaller 5.13.0	2023-08-02 19:30:03 +02:00
ngosang	22ed3d324b	Fix for new Cloudflare detection. Thanks @cedric-bour for #845	2023-08-02 19:29:44 +02:00
ngosang	5ba9ef03f3	Update Selenium 4.11.2	2023-08-02 19:23:08 +02:00
ngosang	d2e144ea12	Implement Prometheus metrics	2023-07-23 21:52:06 +02:00
ngosang	313fb2c14b	Add support for proxy authentication username/password. Thanks @jacobprice808	2023-07-23 19:46:46 +02:00
ngosang	6d69f40b58	Update Chromium 115 in binary packages	2023-07-23 19:46:18 +02:00
ngosang	a1c36f60d2	Fix for Chrome / Chromium version > 114	2023-07-23 19:46:18 +02:00
ngosang	0edc50e271	Update base Docker image to Debian Bookworm	2023-07-23 19:46:18 +02:00
ngosang	f4a4baa57c	Update Selenium 4.10.0	2023-07-23 19:46:18 +02:00
ngosang	f7e434c6e3	Simplify 'Verify you are human' resolver. Related #811	2023-07-23 19:46:15 +02:00
Maksim Kurnosenko	7728f2ab31	Update undetected_chromedriver to v3.5.0 (#803 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-07-17 18:46:43 +01:00
Garfield69	c920bea4ca	Update .gitignore	2023-07-17 13:50:11 +12:00
ilike2burnthing	a785f83034	Update CHANGELOG.md	2023-07-16 23:46:31 +01:00
ilike2burnthing	b42c22f5b1	Bump version 3.2.2	2023-07-16 23:46:25 +01:00
Tyler Hagstrom	9c62410a8b	Workaround for updated 'verify your are human' check (#816 ) Co-authored-by: ilike2burnthing <59480337+ilike2burnthing@users.noreply.github.com>	2023-07-16 23:42:41 +01:00
ngosang	b8768ae17d	Bump version 3.2.1	2023-06-10 19:27:55 +02:00
ngosang	9b2c602a1f	Kill dead Chrome processes in Windows	2023-06-10 19:26:28 +02:00
ngosang	8316350b98	Fix Chrome GL erros in ASUSTOR NAS	2023-06-10 18:49:09 +02:00
ilike2burnthing	33307ce461	bug_report: add troubleshooting check	2023-06-04 04:08:25 +01:00
ngosang	cedb7bc54e	Bump version 3.2.0	2023-05-23 23:13:31 +02:00
ngosang	6ecaf2362c	Support cookies param in request cmd	2023-05-23 22:39:07 +02:00
ngosang	3c97c9603a	Add integration tests for requests with proxy param	2023-05-23 22:13:52 +02:00
NyaMisty	efaa5f31b6	Support proxy in request and session cmds (#754 )	2023-05-23 21:53:13 +02:00
ngosang	4db85a2d0f	Update Python dependencies	2023-05-23 20:18:06 +02:00
ngosang	66b9db21e5	Fix Chromium exec permissions in Linux package	2023-05-21 21:09:06 +02:00
ngosang	ab0fe58d4a	Bump version 3.1.2	2023-04-02 21:06:52 +02:00
ngosang	f68ddb7573	Bump Selenium dependency	2023-04-02 21:05:07 +02:00
ngosang	ac77110578	Remove redundant artifact from Windows binary package	2023-04-02 21:04:34 +02:00
Rawand Ahmed Shaswar	a9d1a2de2d	Fix headless mode in mac OS (#750 )	2023-04-02 20:49:18 +02:00
ngosang	ab5f14d6c3	Bump version 3.1.1	2023-03-25 22:20:56 +01:00
ngosang	e0bf02fb8b	Distribute binary executables in compressed package	2023-03-25 22:19:26 +01:00
ilike2burnthing	82a1cd835a	Add icon for binary executable (#739 )	2023-03-25 21:35:37 +01:00
ngosang	7017715e21	Include information about supported architectures in the readme	2023-03-25 21:32:17 +01:00
ngosang	ae18559db1	Check Python version on start	2023-03-25 21:23:06 +01:00
ngosang	2680521008	Bump version 3.1.0	2023-03-20 23:17:05 +01:00
ngosang	2297bab185	Update changelog	2023-03-20 23:16:39 +01:00
ngosang	8d9bac9dd4	Build binaries for Linux x64 and Windows x64	2023-03-20 22:30:52 +01:00
ngosang	30ccf18e85	Several fixes in Sessions	2023-03-20 17:06:16 +01:00
ngosang	a15d041a0c	Fix Waitress server error with asyncore_use_poll=true. Resolves #680	2023-03-20 16:27:25 +01:00
Martino Mensio	c6c74e7c9d	Add Fairlane challenge selector (#723 )	2023-03-20 16:27:24 +01:00
Artemiy Ryabinkov	49fd1aacfc	Sessions with auto-creation on fetch request and TTL (#736 ) * Add support for sessions * Add tests for sessions * Missing return type * Don't re-create an existing session * Return success in case of session doesn't exists on destroy * Create session if necessary on get request * Add session TTL to the request.get method When fetching some webpage with a predefined session id, FlareSorverr is using existing instance of WebDriver. That allows user to not manage cookies explicitly and rely on WebDriver to maintain the session. However, if session has been created long time ago, CloudFlare might stop accepting the requests, so we want to recreate the session time to time. From the user perspective the easiest way of doing it is to define their expectation on the session duration. These changes add an option to define Time-to-live (TTL) for the session and FlareSorverr takes care about rotating the sessions. * Update message for session destroy in tests --------- Co-authored-by: Michel Roux <xefir@crystalyx.net>	2023-03-20 16:25:48 +01:00
Martino Mensio	f6879c70de	Add Fairlane challenge selector (#723 )	2023-03-20 16:13:21 +01:00
ngosang	24f59a39cb	Print platform information on start up	2023-03-20 15:07:12 +01:00
ngosang	4d16105176	Fix error trace: Crash Reports/pending No such file or directory	2023-03-20 15:07:12 +01:00
ngosang	5957b7b3bc	Update dependencies	2023-03-20 15:07:12 +01:00
ngosang	8de16058d0	Attempt to fix Docker ARM32 build	2023-03-20 15:07:12 +01:00
bilditup1	5fc4f966a5	Update ddos-guard title (#692 ) * update ddos-guard title (anidex.info) * make page_title test case-insensitive --------- Co-authored-by: bilditup1 <git@github.com>	2023-03-20 15:06:27 +01:00
ilike2burnthing	b903a5dd84	Bump version 3.0.4	2023-03-07 03:54:10 +00:00
ilike2burnthing	7e9d5f424f	Update changelog	2023-03-07 03:54:05 +00:00
ilike2burnthing	fc6d2d9095	Click on the Cloudflare's 'Verify you are human' button if necessary Co-authored-by: furdarius <furdarius@users.noreply.github.com> `69e023b946` minus screenshot function	2023-03-07 03:51:17 +00:00
ilike2burnthing	aef9b2d4d6	Update changelog	2023-03-06 14:02:56 +00:00