diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index b101ec0..a966f0b 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -9,3 +9,11 @@ updates:
       python-packages:
         patterns:
           - "*"
+
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: 'github-actions'
+    # Workflow files stored in the default location of `.github/workflows`
+    # You don't need to specify `/.github/workflows` for `directory`. You can use `directory: "/"`.
+    directory: '/'
+    schedule:
+      interval: 'weekly'
diff --git a/.gitignore b/.gitignore
index 5895d7e..40ce45b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -302,3 +302,6 @@ dev/
 pytestdebug.log
 
 */_version.py
+
+# local temp files
+.server.key
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index e221f0c..c3df5f8 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -3,9 +3,27 @@
 #   pre-commit run --all-files
 # Update this file:
 #   pre-commit autoupdate
+
+exclude: |
+  (?x)^(
+      .*\{\{.*\}\}.*|     # Exclude any files with cookiecutter variables
+      docs/site/.*|       # Exclude mkdocs compiled files
+      \.history/.*|       # Exclude history files
+      .*cache.*/.*|       # Exclude cache directories
+      .*venv.*/.*|        # Exclude virtual environment directories
+      .*/versioneer\.py|
+      .*/_version\.py|
+      .*/.*\.svg
+  )$
+
+fail_fast: true
+
+default_install_hook_types:
+  - pre-commit
+  - commit-msg
+
 default_language_version:
   python: python3
-exclude: ^(.*/versioneer\.py|.*/_version\.py|.*/.*\.svg)
 
 ci:
     autofix_commit_msg: |
@@ -19,129 +37,237 @@ ci:
     skip: []
     submodules: false
 
+# .pre-commit-config.yaml
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v6.0.0
     hooks:
+      # Python-specific checks
       - id: check-ast
+        name: "🐍 python · Validate syntax"
       - id: check-builtin-literals
-      - id: fix-byte-order-marker
-      - id: check-case-conflict
+        name: "🐍 python · Use literal syntax"
       - id: check-docstring-first
-      - id: check-vcs-permalinks
-      # Fail if staged files are above a certain size.
-      # To add a large file, use 'git lfs track <file>; git add <file> to track large files with
-      # git-lfs rather than committing them directly to the git history
+        name: "🐍 python · Validate docstring placement"
+      - id: debug-statements
+        name: "🐍 python · Detect debug statements"
+        language_version: python3
+
+      # Git workflow protection
       - id: check-added-large-files
-        args: [ "--maxkb=500" ]
-      # Fails if there are any ">>>>>" lines in files due to merge conflicts.
+        name: "🌳 git · Block large files"
+        args: ['--maxkb=500']
       - id: check-merge-conflict
-      # ensure syntaxes are valid
+        name: "🌳 git · Detect conflict markers"
+      - id: forbid-new-submodules
+        name: "🌳 git · Prevent submodules"
+      - id: no-commit-to-branch
+        name: "🌳 git · Protect main branches"
+        args: ["--branch", "main", "--branch", "master"]
+      - id: check-vcs-permalinks
+        name: "🌳 git · Validate VCS links"
+
+      # Filesystem and naming validation
+      - id: check-case-conflict
+        name: "📁 filesystem · Check case sensitivity"
+      - id: check-illegal-windows-names
+        name: "📁 filesystem · Validate Windows names"
+      - id: check-symlinks
+        name: "📁 filesystem · Check symlink validity"
+      - id: destroyed-symlinks
+        name: "📁 filesystem · Detect broken symlinks"
+
+      # File format validation
       - id: check-toml
-      - id: debug-statements
-      # Makes sure files end in a newline and only a newline;
+        name: "📋 format · Validate TOML"
+      - id: check-yaml
+        name: "📋 format · Validate YAML"
+        exclude: conda.recipe/meta.yaml
+
+      # File content fixes
+      - id: fix-byte-order-marker
+        name: "✨ fix · Remove BOM markers"
       - id: end-of-file-fixer
+        name: "✨ fix · Ensure final newline"
       - id: mixed-line-ending
-      # Trims trailing whitespace. Allow a single space on the end of .md lines for hard line breaks.
+        name: "✨ fix · Normalize line endings"
       - id: trailing-whitespace
-        args: [ --markdown-linebreak-ext=md ]
-      # Sort requirements in requirements.txt files.
+        name: "✨ fix · Trim trailing whitespace"
+        args: [--markdown-linebreak-ext=md]
       - id: requirements-txt-fixer
-      # Prevent committing directly to trunk
-      - id: no-commit-to-branch
-        args: [ "--branch=master" ]
-      # Detects the presence of private keys
+        name: "✨ fix · Sort requirements"
+
+      # Security checks
       - id: detect-private-key
+        name: "🔒 security · Detect private keys"
 
+  # Git commit quality
   - repo: https://github.com/jorisroovers/gitlint
     rev: v0.19.1
     hooks:
       - id: gitlint
+        name: "🌳 git · Validate commit format"
 
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v4.11.1
+    hooks:
+      - id: commitizen
+        name: "🌳 git · Validate commit message"
+        stages: [commit-msg]
+
+  # Security scanning (grouped together)
   - repo: https://github.com/Yelp/detect-secrets
     rev: v1.5.0
     hooks:
-      - id: detect-secrets  # Detect accidentally committed secrets
+      - id: detect-secrets
+        name: "🔒 security · Detect committed secrets"
 
-  - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
+  - repo: https://github.com/gitleaks/gitleaks
+    rev: v8.30.0
     hooks:
-      - id: codespell
-        args: [--write]
-        exclude: ^tests
+      - id: gitleaks
+        name: "🔒 security · Scan for hardcoded secrets"
 
+  - repo: https://github.com/PyCQA/bandit
+    rev: 1.9.2
+    hooks:
+      - id: bandit
+        name: "🔒 security · Check Python vulnerabilities"
+        args: ["-c", "pyproject.toml", "-r", "."]
+        exclude: ^tests/
+        additional_dependencies: [".[toml]"]
+
+# TODO: Enable it for a single check
+#  - repo: https://github.com/pypa/pip-audit
+#    rev: v2.10.0
+#    hooks:
+#      - id: pip-audit
+#        name: "🔒 security · Audit Python dependencies"
+#        args: ['--desc', 'on']
+
+  - repo: https://github.com/semgrep/pre-commit
+    rev: 'v1.146.0'
+    hooks:
+      - id: semgrep
+        name: "🔒 security · Static analysis (semgrep)"
+        args: [ '--config=auto', '--error' ]
+
+
+  # Spelling and typos
+  - repo: https://github.com/crate-ci/typos
+    rev: v1.40.0
+    hooks:
+      - id: typos
+        name: "📝 spelling · Check typos"
+
+#  - repo: https://github.com/codespell-project/codespell
+#    rev: v2.4.1
+#    hooks:
+#      - id: codespell
+#        name: "📝 spelling · Fix common misspellings"
+#        args: [--write]
+#        exclude: ^tests
+
+  # CI/CD validation
   - repo: https://github.com/python-jsonschema/check-jsonschema
-    rev: 0.35.0
+    rev: 0.36.0
     hooks:
+      - id: check-dependabot
+        name: "🔧 ci/cd · Validate Dependabot config"
       - id: check-github-workflows
+        name: "🔧 ci/cd · Validate GitHub workflows"
         files: ^\.github/workflows/.*\.ya?ml$
 
-  - repo: https://github.com/akaihola/darker
-    rev: v3.0.0
-    hooks:
-      - id: darker
-        additional_dependencies: [black]
-
+  # Python code formatting (order matters: autoflake → pyupgrade → darker/ruff)
   - repo: https://github.com/PyCQA/autoflake
     rev: v2.3.1
     hooks:
       - id: autoflake
+        name: "🐍 format · Remove unused imports"
         args:
           - --in-place
           - --remove-all-unused-imports
           - --remove-unused-variable
           - --ignore-init-module-imports
 
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.21.2
+    hooks:
+      - id: pyupgrade
+        name: "🐍 format · Modernize syntax"
+        args: [--py310-plus, --keep-runtime-typing]
+
+  - repo: https://github.com/akaihola/darker
+    rev: v3.0.0
+    hooks:
+      - id: darker
+        name: "🐍 format · Format changed lines"
+        additional_dependencies: [black]
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.14.10
+    hooks:
+      - id: ruff-check
+        name: "🐍 lint · Check with Ruff"
+        args: [--fix, --preview, --exit-non-zero-on-fix]
+      - id: ruff-format
+        name: "🐍 format · Format with Ruff"
+
+  # Python linting (comprehensive checks)
   - repo: https://github.com/pycqa/flake8
     rev: 7.3.0
     hooks:
-    -   id: flake8
+      - id: flake8
+        name: "🐍 lint · Check style (Flake8)"
+        args: ["--ignore=E501,C901", --max-complexity=13]  # Sets McCabe complexity limit
         additional_dependencies:
           - radon
           - flake8-docstrings
           - Flake8-pyproject
-        # TODO: Remove tests when we will be ready to process tests
+          - flake8-bugbear
+          - flake8-comprehensions
+          - flake8-tidy-imports
+          - pycodestyle
         exclude: ^tests
 
   - repo: https://github.com/PyCQA/pylint
     rev: v4.0.4
     hooks:
       - id: pylint
+        name: "🐍 lint · Check code quality"
         args:
           - --exit-zero
 
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v3.21.2
+  - repo: https://github.com/dosisod/refurb
+    rev: v2.2.0
     hooks:
-      - id: pyupgrade
-        args: [--py310-plus, --keep-runtime-typing]
-
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    # Ruff version.
-    rev: v0.14.8
-    hooks:
-      # Run the linter.
-      - id: ruff-check
-        args: [--fix, --preview, --exit-non-zero-on-fix]
-      # Run the formatter.
-      - id: ruff-format
+      - id: refurb
+        name: "🐍 performance · Suggest modernizations"
+        # TODO: Fix FURB147.
+        args: ["--enable-all", "--ignore", "FURB147"]
 
+  # Python documentation
   - repo: https://github.com/pycqa/pydocstyle
     rev: 6.3.0
     hooks:
       - id: pydocstyle
+        name: "🐍 docs · Validate docstrings"
         args: [--select=D200,D213,D400,D415]
         additional_dependencies: [tomli]
 
-  -   repo: https://github.com/dosisod/refurb
-      rev: v2.2.0
-      hooks:
-      -   id: refurb
+  - repo: https://github.com/econchick/interrogate
+    rev: 1.7.0
+    hooks:
+      - id: interrogate
+        name: "📝 docs · Check docstring coverage"
+        args: [ --verbose, --fail-under=53, --ignore-init-method ]
 
+  # Python type checking
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.0
+    rev: v1.19.1
     hooks:
-    -   id: mypy
+      - id: mypy
+        name: "🐍 types · Check with mypy"
         args: [--config-file=./pyproject.toml]
         additional_dependencies:
           - types-requests
@@ -151,27 +277,66 @@ repos:
   - repo: https://github.com/RobertCraigie/pyright-python
     rev: v1.1.407
     hooks:
-    - id: pyright
+      - id: pyright
+        name: "🐍 types · Check with pyright"
 
-  - repo: https://github.com/PyCQA/bandit
-    rev: 1.9.2
+  # Python project configuration
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.24.1
     hooks:
-      - id: bandit
-        args: ["-c", "pyproject.toml", "-r", "."]
-        # ignore all tests, not just tests data
-        exclude: ^tests/
-        additional_dependencies: [".[toml]"]
+      - id: validate-pyproject
+        name: "🐍 config · Validate pyproject.toml"
 
-  - repo: https://github.com/crate-ci/typos
-    rev: v1.38.1
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: v2.8.0
     hooks:
-      - id: typos
+      - id: pyproject-fmt
+        name: "🐍 config · Format pyproject.toml"
 
+#  - repo: https://github.com/mgedmin/check-manifest
+#    rev: '0.50'
+#    hooks:
+#      - id: check-manifest
+#        name: "🐍 📦 packaging · Verify MANIFEST"
+#        args: [--no-build-isolation, --ignore-bad-ideas=MANIFEST.in]
+#        additional_dependencies: [setuptools, wheel, setuptools-scm]
+
+  - repo: https://github.com/pre-commit/pygrep-hooks
+    rev: v1.10.0
+    hooks:
+      - id: python-check-blanket-noqa
+        name: "🐍 lint · Disallow blanket noqa"
+      - id: python-use-type-annotations
+        name: "🐍 types · Enforce type annotations"
+      - id: python-check-blanket-type-ignore
+        name: "🐍 types · Disallow blanket type:ignore"
+      - id: python-no-log-warn
+        name: "🐍 lint · Use logging.warning not warn"
+      - id: text-unicode-replacement-char
+        name: "📋 format · Detect unicode replacement char"
+      - id: python-no-eval
+        name: "🔒 security · Prevent eval() usage"
+
+  # Markdown formatting
   - repo: https://github.com/executablebooks/mdformat
     rev: 1.0.0
     hooks:
       - id: mdformat
+        name: "📝 markdown · Format files"
         additional_dependencies:
-          # gfm = GitHub Flavored Markdown
           - mdformat-gfm
           - mdformat-black
+          - mdformat-ruff
+# TODO: Enable it for a single check
+#  - repo: https://github.com/tcort/markdown-link-check
+#    rev: v3.14.2
+#    hooks:
+#      - id: markdown-link-check
+#        name: "📝 docs · Check markdown links"
+
+  # Makefile linting
+  - repo: https://github.com/checkmake/checkmake
+    rev: 0.2.2
+    hooks:
+      - id: checkmake
+        name: "🔧 build · Lint Makefile"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8bb8dda..e7d949f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,55 @@ We [keep a changelog.](http://keepachangelog.com/)
 
 ## [Unreleased]
 
+### Added
+
+- Add Keys and Domain Keys API endpoints:
+
+  - Add `handle_keys` to `mailgun.handlers.keys_handler`.
+  - Add `handle_dkimkeys` to `mailgun.handlers.domains_handler`.
+  - Add "dkim" key to special cases in the class `Config`.
+
+- Examples:
+
+  - Add the `get_dkim_keys()`, `post_dkim_keys()`, `delete_dkim_keys()` examples to `mailgun/examples/domain_examples.py`.
+  - Add the `get_keys()`, `post_keys()`, `delete_key()`, `regenerate_key()` examples to `mailgun/examples/keys_examples.py`.
+
+- Docs:
+
+  - Add `Keys` and `Domain Keys` sections with examples to `README.md`.
+  - Add docstrings to the test class `KeysTests` & `AsyncKeysTests` and their methods.
+  - Add `CONTRIBUTING.md`.
+  - Add `MANIFEST.in`.
+
+- Tests:
+
+  - Add dkim keys tests to `DomainTests` and only `test_get_dkim_keys`, `test_post_dkim_keys_invalid_pem_string` to `AsyncDomainTests`.
+  - Add classes `KeysTests` and `AsyncKeysTests` to `tests/tests.py`.
+  - Add keys tests to `KeysTests` and `AsyncKeysTests`.
+
+- CI:
+
+  - Add more pre-commit hooks.
+
+### Changed
+
+- Update `get_own_user_details()` by creating `client_with_secret_key` in `mailgun/examples/users_examples.py`.
+- Improve the users' example in `README.md`.
+- Fix markdown structure in `README.md`.
+- Update environment variables in `README.md`.
+- Move `BounceClassificationTests` to another place in `tests/tests.py`.
+- Replace some pytest's skip marks with xfail.
+- Disable `codespell` pre-commit hook as it lashes with `typos`.
+- Update `pre-commit` hooks to the latest versions.
+- Update test dependencies: add `openssl` and `pytest-asyncio` to `environment-dev.yaml` and `pyproject.toml`.
+- Add `.server.key` to `.gitignore`.
+- Add a constraint `py<311` for `typing_extensions >=4.7.1` in files `environment.yaml`, `environment-dev.yaml`, `pyproject.toml`, and in `mailgun/client.py`.
+- Improve `pyproject.toml`.
+
+### Pull Requests Merged
+
+- [PR_27](https://github.com/mailgun/mailgun-python/pull/27) - Add Keys and Domain Keys API endpoints
+
 ## [1.5.0] - 2025-12-11
 
 ### Added
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..27b0e47
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,24 @@
+### Contributing
+
+First off, thank you for considering contributing to Mailgun Python SDK. Contributions to the `mailgun-python` repository from the community are welcome and encouraged!
+
+Mailgun loves developers. You can be part of this project!
+
+This Python SDK is a great introduction to the open source world, check out the code!
+
+Please create issues for any major changes so it can be discussed first. For small bug fixes feel free to submit the PR directly.
+
+Make sure to run tests before creating the PR.
+
+When submitting a pull request, please include the purpose and implementation details.
+
+Feel free to ask anything, and contribute:
+
+- Fork the project.
+- Create a new branch.
+- Implement your feature or bug fix.
+- Add documentation to it.
+- Commit, push, open a pull request and voila.
+
+If you have suggestions on how to improve the guides, please submit an issue in our
+[Official API Documentation](https://documentation.mailgun.com).
diff --git a/LICENSE b/LICENSE
index 6c01456..261eeb9 100644
--- a/LICENSE
+++ b/LICENSE
@@ -199,4 +199,3 @@
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
->>>>>>> 6b1e6b18e0fd97cff8c7a65813d573875c1cdf0d
diff --git a/MANIFEST.in b/MANIFEST.in
new file mode 100644
index 0000000..28f7849
--- /dev/null
+++ b/MANIFEST.in
@@ -0,0 +1,30 @@
+# MANIFEST.in
+# Include critical files for building/installing
+include LICENSE
+include README.md
+include pyproject.toml
+include *.md
+include *.typed
+include *.yaml
+include Makefile
+include MANIFEST.in
+
+# Include package data
+recursive-include mailgun *.py
+recursive-include mailgun *.csv
+recursive-include mailgun *.mime
+recursive-include mailgun *.txt
+
+# Exclude development/CI files
+exclude .editorconfig
+exclude .pylintrc
+exclude .pre-commit-config.yaml
+
+# Exclude conda-specific files (not needed in PyPI sdist)
+prune conda.recipe
+
+# Exclude test files (optional - include if you want tests in sdist)
+prune tests
+
+# Exclude CI/CD configs
+prune .github
diff --git a/Makefile b/Makefile
index 9092db1..7e5a879 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: clean clean-env clean-test clean-pyc clean-build clean-other help dev test test-debug test-cov pre-commit lint format format-docs analyze docs
+.PHONY: all clean clean-env clean-test clean-pyc clean-build clean-other help dev test test-debug test-cov pre-commit lint format format-docs analyze docs
 .DEFAULT_GOAL := help
 
 # The `.ONESHELL` and setting `SHELL` allows us to run commands that require
diff --git a/README.md b/README.md
index 1b97d3b..eb21106 100644
--- a/README.md
+++ b/README.md
@@ -23,6 +23,8 @@ Check out all the resources and Python code examples in the official
   - [Overview](#overview)
     - [Base URL](#base-url)
     - [Authentication](#authentication)
+    - [Client](#client)
+    - [AsyncClient](#asyncclient)
     - [API Response Codes](#api-response-codes)
   - [Request examples](#request-examples)
     - [Full list of supported endpoints](#full-list-of-supported-endpoints)
@@ -37,6 +39,8 @@ Check out all the resources and Python code examples in the official
       - [Update a domain](#update-a-domain)
       - [Domain connections](#domain-connections)
       - [Domain keys](#domain-keys)
+        - [List keys for all domains](#list-keys-for-all-domains)
+        - [Create a domain key](#create-a-domain-key)
         - [Update DKIM authority](#update-dkim-authority)
       - [Domain Tracking](#domain-tracking)
         - [Get tracking settings](#get-tracking-settings)
@@ -100,7 +104,7 @@ Check out all the resources and Python code examples in the official
       - [Create Mailgun SMTP credentials for a given domain](#create-mailgun-smtp-credentials-for-a-given-domain)
     - [Users](#users)
       - [Get users on an account](#get-users-on-an-account)
-      - [Get a user's details](#)
+      - [Get a user's details](#get-a-users-details)
   - [License](#license)
   - [Contribute](#contribute)
   - [Contributors](#contributors)
@@ -234,8 +238,14 @@ export DOMAINS_DEDICATED_IP="127.0.0.1"
 export MAILLIST_ADDRESS="everyone@mailgun.domain.com"
 export VALIDATION_ADDRESS_1="test1@i.ua"
 export VALIDATION_ADDRESS_2="test2@gmail.com"
+export MAILGUN_EMAIL="username@example.com"
+export USER_ID="123456789012345678901234"
+export USER_NAME="Name Surname"
+export ROLE="admin"
 ```
 
+### Client
+
 Initialize your [Mailgun](http://www.mailgun.com/) client:
 
 ```python
@@ -501,6 +511,68 @@ def get_connections() -> None:
 
 #### Domain keys
 
+### List keys for all domains
+
+List domain keys, and optionally filter by signing domain or selector. The page & limit data is only required when paging through the data.
+
+```python
+def get_dkim_keys() -> None:
+    """
+    GET /v1/dkim/keys
+    :return:
+    """
+    data = {
+        "page": "string",
+        "limit": "0",
+        "signing_domain": "python.test.domain5",
+        "selector": "smtp",
+    }
+
+    request = client.dkim_keys.get(data=data)
+    print(request.json())
+```
+
+#### Create a domain key
+
+Create a domain key.
+Note that once private keys are created or imported they are never exported.
+Alternatively, you can import an existing PEM file containing a RSA private key in PKCS #1, ASn.1 DER format.
+Note, the pem can be passed as a file attachment or as a form-string parameter.
+
+```python
+def post_dkim_keys() -> None:
+    """
+    POST /v1/dkim/keys
+    :return:
+    """
+    import subprocess
+    from pathlib import Path
+
+    # Private key PEM file must be generated in PKCS1 format. You need 'openssl' on your machine
+    # example:
+    # openssl genrsa -traditional -out .server.key 2048
+    subprocess.run(["openssl", "genrsa", "-traditional", "-out", ".server.key", "2048"])
+
+    files = [
+        (
+            "pem",
+            ("server.key", Path(".server.key").read_bytes()),
+        )
+    ]
+
+    data = {
+        "signing_domain": "python.test.domain5",
+        "selector": "smtp",
+        "bits": "2048",
+        "pem": files,
+    }
+
+    headers = {"Content-Type": "multipart/form-data"}
+
+    request = client.dkim_keys.create(data=data, headers=headers, files=files)
+    print(request.json())
+```
+
 ##### Update DKIM authority
 
 ```python
@@ -941,9 +1013,7 @@ def import_list_unsubs() -> None:
     :return:
     """
     files = {
-        "unsubscribe2_csv": Path(
-            "mailgun/doc_tests/files/mailgun_unsubscribes.csv"
-        ).read_bytes()
+        "unsubscribe2_csv": Path("mailgun/doc_tests/files/mailgun_unsubscribes.csv").read_bytes()
     }
     req = client.unsubscribes_import.create(domain=domain, files=files)
     print(req.json())
@@ -976,11 +1046,7 @@ def import_complaint_list() -> None:
     POST /<domain>/complaints/import, Content-Type: multipart/form-data
     :return:
     """
-    files = {
-        "complaints_csv": Path(
-            "mailgun/doc_tests/files/mailgun_complaints.csv"
-        ).read_bytes()
-    }
+    files = {"complaints_csv": Path("mailgun/doc_tests/files/mailgun_complaints.csv").read_bytes()}
     req = client.complaints_import.create(domain=domain, files=files)
     print(req.json())
 ```
@@ -1165,9 +1231,7 @@ def get_all_versions() -> None:
     GET /<domain>/templates/<template>/versions
     :return:
     """
-    req = client.templates.get(
-        domain=domain, template_name="template.name1", versions=True
-    )
+    req = client.templates.get(domain=domain, template_name="template.name1", versions=True)
     print(req.json())
 ```
 
@@ -1196,9 +1260,7 @@ def update_ippool() -> None:
         "name": "test_pool3",
         "description": "Test3",
     }
-    req = client.ippools.patch(
-        domain=domain, data=data, pool_id="60140bc1fee3e84dec5abeeb"
-    )
+    req = client.ippools.patch(domain=domain, data=data, pool_id="60140bc1fee3e84dec5abeeb")
     print(req.json())
 ```
 
@@ -1277,9 +1339,7 @@ def get_aggregate_countries() -> None:
     GET /<domain>/tags/<tag>/stats/aggregates/countries
     :return:
     """
-    req = client.tags_stats_aggregates_countries.get(
-        domain=domain, tag_name="September newsletter"
-    )
+    req = client.tags_stats_aggregates_countries.get(domain=domain, tag_name="September newsletter")
     print(req.json())
 ```
 
@@ -1313,6 +1373,76 @@ def get_all_inbox() -> None:
     print(req.json())
 ```
 
+### Keys
+
+The Keys API lets you view and manage api keys.
+
+#### List Mailgun API keys
+
+```python
+def get_keys() -> None:
+    """
+    GET /v1/keys
+    :return:
+    """
+    query = {"domain_name": "python.test.domain5", "kind": "web"}
+    req = client.keys.get(filters=query)
+    print(req.json())
+```
+
+#### Create Mailgun API key
+
+```python
+import os
+
+from mailgun.client import Client
+
+
+key: str = os.environ["APIKEY"]
+domain: str = os.environ["DOMAIN"]
+mailgun_email = os.environ["MAILGUN_EMAIL"]
+role = os.environ["ROLE"]
+user_id = os.environ["USER_ID"]
+user_name = os.environ["USER_NAME"]
+
+client: Client = Client(auth=("api", key))
+
+
+def post_keys() -> None:
+    """
+    POST /v1/keys
+
+    This code generate a Web API key tied to the account user associated with the data inputted for the USER_EMAIL field and USER_ID  values.
+    This is returned by the API in the "secret":"API_KEY" key/value pair. This key will authenticate the call (Get one's own user details) made to the /v5/users/me endpoint,   # pragma: allowlist secret
+    and will return the user's data associated with the USER_EMAIL and USER_ID values.
+
+    Important Notes:
+    USER_EMAIL - The user login email address of the user that is trying to make the call to the /v5/users/me endpoint.
+    SECONDS - How many seconds you want the key to be active before it expires.
+    ROLE - The role of the API Key. This dictates what permissions the key has (https://help.mailgun.com/hc/en-us/articles/26016288026907-API-Key-Roles)
+    USER_ID - The internal User ID of the user that is trying to call the /v5/users/me endpoint. This is present in the URL in the address bar when viewing the User details in the GUI or in Admin. Both will show /users/USER_ID in the address.
+    DESCRIPTION - Description of the key.
+
+    :return:
+    """
+
+    data = {
+        "email": mailgun_email,
+        "domain_name": "python.test.domain5",
+        "kind": "web",
+        "expiration": "3600",
+        "role": role,
+        "user_id": user_id,
+        "user_name": user_name,
+        "description": "a new key",
+    }
+
+    headers = {"Content-Type": "multipart/form-data"}
+
+    req = client.keys.create(data=data, headers=headers)
+    print(req.json())
+```
+
 ### Credentials
 
 #### List Mailgun SMTP credential metadata for a given domain
@@ -1361,13 +1491,17 @@ def get_users() -> None:
 #### Get a user's details
 
 ```python
+mailgun_email = os.environ["MAILGUN_EMAIL"]
+role = os.environ["ROLE"]
+user_name = os.environ["USER_NAME"]
+
+
 def get_user_details() -> None:
     """
     GET /v5/users/{user_id}
     :return:
     """
-    mailgun_email = os.environ["MAILGUN_EMAIL"]
-    query = {"role": "admin", "limit": "0", "skip": "0"}
+    query = {"role": role, "limit": "0", "skip": "0"}
     req1 = client.users.get(filters=query)
     users = req1.json()["users"]
 
@@ -1383,20 +1517,11 @@ def get_user_details() -> None:
 
 ## Contribute
 
-Mailgun loves developers. You can be part of this project!
-
-This Python SDK is a great introduction to the open source world, check out the code!
-
-Feel free to ask anything, and contribute:
+See for details [CONTRIBUTING.md](CONTRIBUTING.md)
 
-- Fork the project.
-- Create a new branch.
-- Implement your feature or bug fix.
-- Add documentation to it.
-- Commit, push, open a pull request and voila.
+## Security
 
-If you have suggestions on how to improve the guides, please submit an issue in our
-[Official API Documentation](https://documentation.mailgun.com).
+See for details [SECURITY.md](SECURITY.md)
 
 ## Contributors
 
diff --git a/environment-dev.yaml b/environment-dev.yaml
index e15ed79..50e4e7c 100644
--- a/environment-dev.yaml
+++ b/environment-dev.yaml
@@ -12,11 +12,13 @@ dependencies:
   # runtime deps
   - requests >=2.32.5
   - httpx >=0.24.0
-  - typing_extensions >=4.7.1
+  - typing_extensions >=4.7.1  # [py<311]
   # tests
   - conda-forge::pyfakefs
   - coverage >=4.5.4
+  - openssl
   - pytest
+  - pytest-asyncio
   - pytest-benchmark
   - pytest-cov
   - pytest-xdist
diff --git a/environment.yaml b/environment.yaml
index 0ba011b..d023974 100644
--- a/environment.yaml
+++ b/environment.yaml
@@ -9,7 +9,7 @@ dependencies:
   # runtime deps
   - requests >=2.32.5
   - httpx >=0.24.0
-  - typing_extensions >=4.7.1
+  - typing_extensions >=4.7.1  # [py<311]
   # tests
   - pytest >=7.0.0
   # other
diff --git a/mailgun/__init__.py b/mailgun/__init__.py
index 093d796..c4a5d7e 100644
--- a/mailgun/__init__.py
+++ b/mailgun/__init__.py
@@ -6,5 +6,4 @@
 
 Modules:
     - client: Defines the main API client.
-
 """
diff --git a/mailgun/_version.py b/mailgun/_version.py
index c179ed2..5b60188 100644
--- a/mailgun/_version.py
+++ b/mailgun/_version.py
@@ -1 +1 @@
-__version__ = "1.5.0"
\ No newline at end of file
+__version__ = "1.5.0"
diff --git a/mailgun/client.py b/mailgun/client.py
index 75c76b8..2d9ef45 100644
--- a/mailgun/client.py
+++ b/mailgun/client.py
@@ -17,6 +17,7 @@
 
 import io
 import json
+import sys
 from collections import defaultdict
 from typing import TYPE_CHECKING
 from typing import Any
@@ -24,10 +25,10 @@
 
 import httpx
 import requests
-from typing_extensions import Self
 
 from mailgun.handlers.bounce_classification_handler import handle_bounce_classification
 from mailgun.handlers.default_handler import handle_default
+from mailgun.handlers.domains_handler import handle_dkimkeys
 from mailgun.handlers.domains_handler import handle_domainlist
 from mailgun.handlers.domains_handler import handle_domains
 from mailgun.handlers.domains_handler import handle_mailboxes_credentials
@@ -37,6 +38,7 @@
 from mailgun.handlers.inbox_placement_handler import handle_inbox
 from mailgun.handlers.ip_pools_handler import handle_ippools
 from mailgun.handlers.ips_handler import handle_ips
+from mailgun.handlers.keys_handler import handle_keys
 from mailgun.handlers.mailinglists_handler import handle_lists
 from mailgun.handlers.messages_handler import handle_resend_message
 from mailgun.handlers.metrics_handler import handle_metrics
@@ -50,6 +52,12 @@
 from mailgun.handlers.users_handler import handle_users
 
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
 if TYPE_CHECKING:
     import types
     from collections.abc import Callable
@@ -63,6 +71,7 @@
     "resendmessage": handle_resend_message,
     "domains": handle_domains,
     "domainlist": handle_domainlist,
+    "dkim": handle_dkimkeys,
     "dkim_authority": handle_domains,
     "dkim_selector": handle_domains,
     "web_prefix": handle_domains,
@@ -86,11 +95,15 @@
     "analytics": handle_metrics,
     "bounce-classification": handle_bounce_classification,
     "users": handle_users,
+    "keys": handle_keys,
 }
 
 
 class Config:
-    """Config class. Configure client with basic (urls, version, headers)."""
+    """Config class.
+
+    Configure client with basic (urls, version, headers).
+    """
 
     DEFAULT_API_URL: str = "https://api.mailgun.net/"
     API_REF: str = "https://documentation.mailgun.com/en/latest/api_reference.html"
@@ -99,8 +112,9 @@ class Config:
     def __init__(self, api_url: str | None = None) -> None:
         """Initialize a new Config instance with specified or default API settings.
 
-        This initializer sets the API version and base URL. If no version or URL
-        is provided, it defaults to the predefined class values.
+        This initializer sets the API version and base URL. If no
+        version or URL is provided, it defaults to the predefined class
+        values.
 
         :param version: API version (default: v3)
         :type version: str | None
@@ -113,8 +127,8 @@ def __init__(self, api_url: str | None = None) -> None:
     def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
         """Parse incoming split attr name, check it and prepare endpoint url.
 
-        Most urls generated here can't be generated dynamically as we are doing this
-        in build_url() method under Endpoint class.
+        Most urls generated here can't be generated dynamically as we
+        are doing this in build_url() method under Endpoint class.
         :param key: incoming attr name
         :type key: str
         :return: url, headers
@@ -132,7 +146,8 @@ def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
             "mimemessage": {"base": v3_base, "keys": ["messages.mime"]},
             "resendmessage": {"base": v3_base, "keys": ["resendmessage"]},
             "ippools": {"base": v3_base, "keys": ["ip_pools"]},
-            "dkimkeys": {"base": v1_base, "keys": ["dkim", "keys"]},
+            # /v1/dkim/keys
+            "dkim": {"base": v1_base, "keys": ["dkim", "keys"]},
             "domainlist": {"base": v4_base, "keys": ["domainlist"]},
             # /v1/analytics/metrics
             # /v1/analytics/usage/metrics
@@ -148,6 +163,7 @@ def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
                 "base": v2_base,
                 "keys": ["bounce-classification", "metrics"],
             },
+            # /v5/users
             "users": {
                 "base": v5_base,
                 "keys": ["users", "me"],
@@ -179,6 +195,12 @@ def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
                 "keys": key.split("_"),
             }, headers
 
+        if "keys" in key:
+            return {
+                "base": v1_base,
+                "keys": key.split("_"),
+            }, headers
+
         # Handle DIPP endpoints
         if "subaccount" in key:
             if "ip_pools" in key:
@@ -242,6 +264,14 @@ def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
             base = v3_base if any(x in key for x in v3_domain_endpoints) else v4_base
             return {"base": f"{base}domains/", "keys": final_keys}, headers
 
+        # "dkim" must follow after "dkim_management", "dkimauthority", "dkimselector",
+        # otherwise a wrong base url will be chosen.
+        if "dkim" in key:
+            return {
+                "base": v1_base,
+                "keys": key.split("_"),
+            }, headers
+
         if "addressvalidate" in key:
             return {
                 "base": f"{v4_base}address/validate",
@@ -252,7 +282,10 @@ def __getitem__(self, key: str) -> tuple[Any, dict[str, str]]:
 
 
 class BaseEndpoint:
-    """Base class for endpoints. Contains methods common for Endpoint and AsyncEndpoint."""
+    """Base class for endpoints.
+
+    Contains methods common for Endpoint and AsyncEndpoint.
+    """
 
     def __init__(
         self,
@@ -560,7 +593,8 @@ def __init__(self, auth: tuple[str, str] | None = None, **kwargs: Any) -> None:
     def __getattr__(self, name: str) -> Any:
         """Get named attribute of an object, split it and execute.
 
-        :param name: attribute name (Example: client.domains_ips. names: ["domains", "ips"])
+        :param name: attribute name (Example: client.domains_ips. names:
+            ["domains", "ips"])
         :type name: str
         :return: type object (executes existing handler)
         """
@@ -917,7 +951,8 @@ def __init__(self, **kwargs: Any) -> None:
     def __getattr__(self, name: str) -> Any:
         """Get named attribute of an object, split it and execute.
 
-        :param name: attribute name (Example: client.domains_ips. names: ["domains", "ips"])
+        :param name: attribute name (Example: client.domains_ips. names:
+            ["domains", "ips"])
         :type name: str
         :return: type object (executes existing handler)
         """
@@ -941,7 +976,8 @@ def _client(self) -> AsyncClient:
     async def aclose(self) -> None:
         """Close the underlying httpx.AsyncClient.
 
-        Call this when done with the client to properly clean up resources.
+        Call this when done with the client to properly clean up
+        resources.
         """
         if self._httpx_client:
             await self._httpx_client.aclose()
diff --git a/mailgun/examples/domain_examples.py b/mailgun/examples/domain_examples.py
index f703cbe..dfab2ce 100644
--- a/mailgun/examples/domain_examples.py
+++ b/mailgun/examples/domain_examples.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import os
+import subprocess
+from pathlib import Path
 
 from mailgun.client import Client
 
@@ -152,7 +154,7 @@ def put_dkim_authority() -> None:
     PUT /domains/<domain>/dkim_authority
     :return:
     """
-    data = {"self": "false"}
+    data = {"self": "true"}
     request = client.domains_dkimauthority.put(domain=domain, data=data)
     print(request.json())
 
@@ -183,10 +185,73 @@ def get_sending_queues() -> None:
     :return:
     """
     request = client.domains_sendingqueues.get(domain="python.test.domain5")
-    print(request)
+    print(request.json())
+
+
+def get_dkim_keys() -> None:
+    """
+    GET /v1/dkim/keys
+    :return:
+    """
+    data = {
+        "page": "string",
+        "limit": "0",
+        "signing_domain": "python.test.domain5",
+        "selector": "smtp",
+    }
+
+    request = client.dkim_keys.get(data=data)
+    print(request.json())
+
+
+def post_dkim_keys() -> None:
+    """
+    POST /v1/dkim/keys
+    :return:
+    """
+
+    # Private key PEM file must be generated in PKCS1 format. You need 'openssl' on your machine
+    # example:
+    # openssl genrsa -traditional -out .server.key 2048
+    subprocess.run(["openssl", "genrsa", "-traditional", "-out", ".server.key", "2048"])
+
+    files = [
+        (
+            "pem",
+            ("server.key", Path(".server.key").read_bytes()),
+        )
+    ]
+
+    data = {
+        "signing_domain": "python.test.domain5",
+        "selector": "smtp",
+        "bits": "2048",
+        "pem": files,
+    }
+
+    headers = {"Content-Type": "multipart/form-data"}
+
+    request = client.dkim_keys.create(data=data, headers=headers, files=files)
+    print(request.json())
+
+
+def delete_dkim_keys() -> None:
+    """
+    GET /v1/dkim/keys
+    :return:
+    """
+    query = {"signing_domain": "python.test.domain5", "selector": "smtp"}
+
+    request = client.dkim_keys.delete(filters=query)
     print(request.json())
 
 
 if __name__ == "__main__":
     add_domain()
     get_domains()
+
+    post_dkim_keys()
+    get_dkim_keys()
+    get_sending_queues()
+    put_dkim_authority()
+    delete_dkim_keys()
diff --git a/mailgun/examples/keys_examples.py b/mailgun/examples/keys_examples.py
new file mode 100644
index 0000000..00492a0
--- /dev/null
+++ b/mailgun/examples/keys_examples.py
@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+
+from mailgun.client import Client
+
+
+key: str = os.environ["APIKEY"]
+domain: str = os.environ["DOMAIN"]
+mailgun_email = os.environ["MAILGUN_EMAIL"]
+role = os.environ["ROLE"]
+user_id = os.environ["USER_ID"]
+user_name = os.environ["USER_NAME"]
+
+client: Client = Client(auth=("api", key))
+
+
+def get_keys() -> None:
+    """
+    GET /v1/keys
+    :return:
+    """
+    query = {"domain_name": "python.test.domain5", "kind": "web"}
+    req = client.keys.get(filters=query)
+    print(req.json())
+
+
+def post_keys() -> None:
+    """
+    POST /v1/keys
+
+    This code generate a Web API key tied to the account user associated with the data inputted for the USER_EMAIL field and USER_ID  values.
+    This is returned by the API in the "secret":"API_KEY" key/value pair. This key will authenticate the call (Get one's own user details) made to the /v5/users/me endpoint,   # pragma: allowlist secret
+    and will return the user's data associated with the USER_EMAIL and USER_ID values.
+
+    Important Notes:
+    USER_EMAIL - The user login email address of the user that is trying to make the call to the /v5/users/me endpoint.
+    SECONDS - How many seconds you want the key to be active before it expires.
+    ROLE - The role of the API Key. This dictates what permissions the key has (https://help.mailgun.com/hc/en-us/articles/26016288026907-API-Key-Roles)
+    USER_ID - The internal User ID of the user that is trying to call the /v5/users/me endpoint. This is present in the URL in the address bar when viewing the User details in the GUI or in Admin. Both will show /users/USER_ID in the address.
+    DESCRIPTION - Description of the key.
+
+    :return:
+    """
+
+    data = {
+        "email": mailgun_email,
+        "domain_name": "python.test.domain5",
+        "kind": "web",
+        "expiration": "3600",
+        "role": role,
+        "user_id": user_id,
+        "user_name": user_name,
+        "description": "a new key",
+    }
+
+    headers = {"Content-Type": "multipart/form-data"}
+
+    req = client.keys.create(data=data, headers=headers)
+    print(req.json())
+
+
+def delete_key() -> None:
+    """
+    DELETE /vq/keys/{key_id}
+    :return:
+    """
+    query = {"domain_name": "python.test.domain5", "kind": "web"}
+    req1 = client.keys.get(filters=query)
+    items = req1.json()["items"]
+
+    for item in items:
+        if mailgun_email == item["requestor"]:  # codespell:disable-line
+            req2 = client.keys.delete(key_id=item["id"])
+            print(req2.json())
+
+
+def regenerate_key() -> None:
+    """
+    POST /v1/keys/public
+    :return:
+    """
+    req = client.keys_public.create()
+    print(req.json())
+
+
+if __name__ == "__main__":
+    # get_keys()
+    post_keys()
+    get_keys()
+    delete_key()
+    get_keys()
+    regenerate_key()
+    get_keys()
diff --git a/mailgun/examples/users_examples.py b/mailgun/examples/users_examples.py
index 172b122..80b637c 100644
--- a/mailgun/examples/users_examples.py
+++ b/mailgun/examples/users_examples.py
@@ -8,6 +8,10 @@
 key: str = os.environ["APIKEY"]
 domain: str = os.environ["DOMAIN"]
 mailgun_email = os.environ["MAILGUN_EMAIL"]
+role = os.environ["ROLE"]
+user_id = os.environ["USER_ID"]
+user_name = os.environ["USER_NAME"]
+
 
 client: Client = Client(auth=("api", key))
 
@@ -17,7 +21,7 @@ def get_users() -> None:
     GET /v5/users
     :return:
     """
-    query = {"role": "admin", "limit": "0", "skip": "0"}
+    query = {"role": role, "limit": "0", "skip": "0"}
     req = client.users.get(filters=query)
     print(req.json())
 
@@ -27,18 +31,9 @@ def get_own_user_details() -> None:
     GET /v5/users/me
 
     Please note, for the command("Get one's own user details") to be successful, you must use a Web type API key for the call. Private type API keys will Not work.
-    This below Call will generate a Web API key tied to the account user associated with the data inputted for the USER_EMAIL field and USER_ID  values. This is returned by the API in the "secret":"API_KEY" key/value pair. This key will authenticate the call(Get one's own user details) made to the /v5/users/me endpoint, and will return the user's data associated with the USER_EMAIL and USER_ID values.
-
-    Generate Web API Key:
-        curl -i -X POST \
-             -u api:API_KEY \
-        https://api.mailgun.net/v1/keys \
-             -F email=USER_EMAIL \
-             -F kind=web \
-             -F expiration=SECONDS (Lifetime of the key in seconds) \
-             -F role=ROLE \
-             -F user_id=USER_ID \
-             -F description=DESCRIPTION
+    The below Call will generate a Web API key tied to the account user associated with the data inputted for the USER_EMAIL field and USER_ID  values.
+    This is returned by the API in the "secret":"API_KEY" key/value pair.  # pragma: allowlist secret
+    This key will authenticate the call(Get one's own user details) made to the /v5/users/me endpoint, and will return the user's data associated with the USER_EMAIL and USER_ID values.
 
     see https://documentation.mailgun.com/docs/mailgun/api-reference/send/mailgun/keys/api.(*keysapi).createkey-fm-7
 
@@ -52,10 +47,27 @@ def get_own_user_details() -> None:
 
     :return:
     """
-    secret: str = os.environ["SECRET"]
+
+    data = {
+        "email": mailgun_email,
+        "domain_name": "python.test.domain5",
+        "kind": "web",
+        "expiration": "3600",
+        "role": role,
+        "user_id": user_id,
+        "user_name": user_name,
+        "description": "a new key",
+    }
+
+    headers = {"Content-Type": "multipart/form-data"}
+
+    req1 = client.keys.create(data=data, headers=headers)
+    print(req1.json())
+    secret = req1.json()["key"]["secret"]
+
     client_with_secret_key: Client = Client(auth=("api", secret))
-    req = client_with_secret_key.users.get(user_id="me")
-    print(req.json())
+    req2 = client_with_secret_key.users.get(user_id="me")
+    print(req2.json())
 
 
 def get_user_details() -> None:
@@ -63,7 +75,7 @@ def get_user_details() -> None:
     GET /v5/users/{user_id}
     :return:
     """
-    query = {"role": "admin", "limit": "0", "skip": "0"}
+    query = {"role": role, "limit": "0", "skip": "0"}
     req1 = client.users.get(filters=query)
     users = req1.json()["users"]
 
diff --git a/mailgun/handlers/domains_handler.py b/mailgun/handlers/domains_handler.py
index 1aa148c..3eccd78 100644
--- a/mailgun/handlers/domains_handler.py
+++ b/mailgun/handlers/domains_handler.py
@@ -121,3 +121,27 @@ def handle_mailboxes_credentials(
         url = url["base"] + domain + final_keys + "/" + kwargs["login"]
 
     return url
+
+
+def handle_dkimkeys(
+    url: dict[str, Any],
+    _domain: str | None,
+    _method: str | None,
+    **kwargs: Any,
+) -> Any:
+    """Handle Mailboxes credentials.
+
+    :param url: Incoming URL dictionary
+    :type url: dict
+    :param domain: Incoming domain
+    :type domain: str
+    :param _method: Incoming request method (it's not being used for this handler)
+    :type _method: str
+    :param kwargs: kwargs
+    :return: final url for Mailboxes credentials endpoint
+    """
+    final_keys = path.join(*url["keys"]) if url["keys"] else ""
+    if "keys" in final_keys:
+        url = url["base"] + final_keys
+
+    return url
diff --git a/mailgun/handlers/keys_handler.py b/mailgun/handlers/keys_handler.py
new file mode 100644
index 0000000..9982fad
--- /dev/null
+++ b/mailgun/handlers/keys_handler.py
@@ -0,0 +1,35 @@
+"""KEYS HANDLER.
+
+Doc: https://documentation.mailgun.com/docs/mailgun/api-reference/send/mailgun/keys
+"""
+
+from __future__ import annotations
+
+from os import path
+from typing import Any
+
+
+def handle_keys(
+    url: dict[str, Any],
+    _domain: str | None,
+    _method: str | None,
+    **kwargs: Any,
+) -> Any:
+    """Handle Keys.
+
+    :param url: Incoming URL dictionary
+    :type url: dict
+    :param _domain: Incoming domain (it's not being used for this handler)
+    :type _domain: str
+    :param _method: Incoming request method (it's not being used for this handler)
+    :type _method: str
+    :param kwargs: kwargs
+    :return: final url for Keys endpoint
+    """
+    final_keys = path.join("/", *url["keys"]) if url["keys"] else ""
+    if "key_id" in kwargs:
+        url = url["base"][:-1] + final_keys + "/" + kwargs["key_id"]
+    else:
+        url = url["base"][:-1] + final_keys
+
+    return url
diff --git a/pyproject.toml b/pyproject.toml
index 50fe3ab..ec2849a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,143 +1,140 @@
 [build-system]
-requires = ["setuptools>=77.0.0", "setuptools-scm"]
 build-backend = "setuptools.build_meta"
-
-[tool.setuptools_scm]
-version_scheme = "no-guess-dev"  # Don't try to guess next version
-local_scheme = "no-local-version"
-# Ignore uncommitted changes
-git_describe_command = "git describe --tags --match 'v[0-9]*.[0-9]*.[0-9]*'"
-write_to = "mailgun/_version.py"
-write_to_template = '__version__ = "{version}"'
-#fallback_version = "X.Y.ZrcN.postN.devN"  # Explicit fallback
-
-[tool.setuptools]
-py-modules = ["mailgun._version"]
-
-[tool.setuptools.packages.find]
-include = ["mailgun", "mailgun.handlers", "mailgun.*", "tests", "tests.*"]
-
-[tool.setuptools.package-data]
-mailgun = ["py.typed", "*.pyi"]
-
+requires = [ "setuptools>=77", "setuptools-scm" ]
 
 [project]
 name = "mailgun"
-dynamic = ["version"]
 description = "Python SDK for Mailgun"
-authors = [
-    { name = "diskovod", email = "diskovodik@gmail.com" },
-    { name = "Mailgun", email = "api@mailgun.com" },
+readme = "README.md"
+keywords = [
+  "email python-wrapper",
+  "mailgun",
+  "Mailgun API Python Wrapper",
+  "mailgun-api",
+  "Python SDK for Mailgun",
+  "transactional-emails",
+  "wrapper",
 ]
+license = "Apache-2.0"
+license-files = [ "LICENSE" ]
 maintainers = [
-  {name = "Serhii Kupriienko", email = "kupriienko.serhii@gmail.com"}
+  { name = "Serhii Kupriienko", email = "kupriienko.serhii@gmail.com" },
+]
+authors = [
+  { name = "diskovod", email = "diskovodik@gmail.com" },
+  { name = "Mailgun", email = "api@mailgun.com" },
 ]
-license = "Apache-2.0"
-license-files = ["LICENSE"]
-readme = "README.md"
 requires-python = ">=3.10"
 
-dependencies = ["requests>=2.32.5", "httpx>=0.24.0", "typing_extensions>=4.7.1"]
-
-keywords = [
-        "Python SDK for Mailgun",
-        "Mailgun API Python Wrapper",
-        "wrapper",
-        "email python-wrapper",
-        "transactional-emails",
-        "mailgun",
-        "mailgun-api",
-    ]
 classifiers = [
-        "Development Status :: 3 - Alpha",
-        "Environment :: Console",
-        "Intended Audience :: Developers",
-        "Natural Language :: English",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-        "Programming Language :: Python :: 3.13",
-        "Programming Language :: Python :: 3.14",
-        "Programming Language :: Python :: 3 :: Only",
-        "Programming Language :: Python :: Implementation :: CPython",
-        "Topic :: Communications :: Email",
-        "Topic :: Utilities",
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Natural Language :: English",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Communications :: Email",
+  "Topic :: Utilities",
 ]
 
-[project.urls]
-"Homepage" = "https://www.mailgun.com"
-"Documentation" = "https://documentation.mailgun.com"
-"Repository" = "https://github.com/mailgun/mailgun-python"
-"Issue Tracker" = "https://github.com/mailgun/mailgun-python/issues"
+dynamic = [ "version" ]
+dependencies = [ "httpx>=0.24", "requests>=2.32.5", "typing-extensions>=4.7.1; python_version<'3.11'" ]
 
-[project.optional-dependencies]
-linting = [
-    # dev tools
-    "make",
-    "toml",
-    "autopep8",
-    "bandit",
-    "black>=21.7",
-    "autoflake",
-    "flake8>=3.7.8",  # the modular source code checker: pep8 pyflakes and co
-    "pep8-naming",
-    "isort",  # A Python utility / library to sort Python imports.
-    "yapf",  # A formatter for Python code
-    "pycodestyle",
-    "pydocstyle",
-    "pyupgrade",
-    "refurb",
-    "pre-commit",  # A framework for managing and maintaining multi-language pre-commit hooks.
-    "ruff",  # An extremely fast Python linter and code formatter, written in Rust.
-    "mypy",  # Optional static typing for Python
-    "types-requests",   # mypy requests stub
-    "pandas-stubs",  # mypy pandas stub
-    "types-PyYAML",
-    "monkeytype",  # It can generate type hints based on the observed behavior of your code.
-    "pyright",
-    "pylint",
-    "pytype",  # a static type checker for any type hints you have put in your code
-    "radon",
-    "safety", # Checks installed dependencies for known vulnerabilities and licenses.
-    "vulture",
-    # env variables
-    "python-dotenv>=0.19.2",
+optional-dependencies.conda_build = [ "conda-build" ]
+optional-dependencies.docs = [
+  "docconvert",
+  "pyment>=0.3.3", # for generating docstrings
 ]
-
-docs = [
-    "docconvert",
-    "pyment>=0.3.3",  # for generating docstrings
+optional-dependencies.linting = [
+  "autoflake",
+  "autopep8",
+  "bandit",
+  "black>=21.7",
+  "flake8>=3.7.8", # the modular source code checker: pep8 pyflakes and co
+  "isort",         # A Python utility / library to sort Python imports.
+  # dev tools
+  "make",
+  "monkeytype",   # It can generate type hints based on the observed behavior of your code.
+  "mypy",         # Optional static typing for Python
+  "pandas-stubs", # mypy pandas stub
+  "pep8-naming",
+  "pre-commit",   # A framework for managing and maintaining multi-language pre-commit hooks.
+  "pycodestyle",
+  "pydocstyle",
+  "pylint",
+  "pyright",
+  # env variables
+  "python-dotenv>=0.19.2",
+  "pytype",                # a static type checker for any type hints you have put in your code
+  "pyupgrade",
+  "radon",
+  "refurb",
+  "ruff",                  # An extremely fast Python linter and code formatter, written in Rust.
+  "safety",                # Checks installed dependencies for known vulnerabilities and licenses.
+  "toml",
+  "types-pyyaml",
+  "types-requests",        # mypy requests stub
+  "vulture",
+  "yapf",                  # A formatter for Python code
 ]
-
-metrics = [
-    "pystra",  # provides functionalities to enable structural reliability analysis
-    "wily>=1.2.0",  # a tool for reporting code complexity metrics
+optional-dependencies.metrics = [
+  "pystra",    # provides functionalities to enable structural reliability analysis
+  "wily>=1.2", # a tool for reporting code complexity metrics
 ]
-
-profilers = ["scalene>=1.3.16", "snakeviz"]
-
-tests = [
-    # tests
-    "pytest>=7.0.0",
-    "pytest-benchmark",
-    "pytest-order",
-    "pytest-cov",
-    "coverage>=4.5.4",
-    "codecov",
+optional-dependencies.other = [ "toml" ]
+optional-dependencies.profilers = [ "scalene>=1.3.16", "snakeviz" ]
+optional-dependencies.spelling = [ "typos" ]
+optional-dependencies.tests = [
+  "codecov",
+  "coverage>=4.5.4",
+  # For a Private key PEM file generated in PKCS1 format.
+  "openssl",
+  # tests
+  "pytest>=7",
+  "pytest-asyncio",
+  "pytest-benchmark",
+  "pytest-cov",
+  "pytest-order",
 ]
+urls."Documentation" = "https://documentation.mailgun.com"
+urls."Homepage" = "https://www.mailgun.com"
+urls."Issue Tracker" = "https://github.com/mailgun/mailgun-python/issues"
+urls."Repository" = "https://github.com/mailgun/mailgun-python"
+
+[tool.setuptools]
+py-modules = [ "mailgun._version" ]
 
-conda_build = ["conda-build"]
+[tool.setuptools.packages.find]
+include = [ "mailgun", "mailgun.handlers", "mailgun.*", "tests", "tests.*" ]
 
-spelling = ["typos"]
+[tool.setuptools.package-data]
+mailgun = [ "py.typed", "*.pyi" ]
 
-other = ["toml"]
+[tool.setuptools_scm]
+version_scheme = "no-guess-dev"   # Don't try to guess next version
+local_scheme = "no-local-version"
+# Ignore uncommitted changes
+git_describe_command = "git describe --tags --match 'v[0-9]*.[0-9]*.[0-9]*'"
+write_to = "mailgun/_version.py"
+write_to_template = '__version__ = "{version}"'
+#fallback_version = "X.Y.ZrcN.postN.devN"  # Explicit fallback
 
+[tool.autopep8]
+max_line_length = 88
+ignore = ""          # or ["E501", "W6"]
+in-place = true
+recursive = true
+aggressive = 3
 
 [tool.black]
 line-length = 100
-target-version = ["py310", "py311", "py312", "py313", "py314"]
+target-version = [ "py310", "py311", "py312", "py313", "py314" ]
 skip-string-normalization = false
 skip-magic-trailing-comma = false
 extend-exclude = '''
@@ -148,172 +145,148 @@ extend-exclude = '''
 )/
 '''
 
-[tool.autopep8]
-max_line_length = 88
-ignore = ""  # or ["E501", "W6"]
-in-place = true
-recursive = true
-aggressive = 3
-
 [tool.ruff]
-# Exclude a variety of commonly ignored directories.
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".git-rewrite",
-    ".hg",
-    ".ipynb_checkpoints",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".pyenv",
-    ".pytest_cache",
-    ".pytype",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    ".vscode",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "site-packages",
-    "venv",
-]
-extend-exclude = ["tests", "test"]
-
-line-length = 100
 #indent-width = 4
 
 # Assume Python 3.10.
 target-version = "py310"
+line-length = 100
+# Exclude a variety of commonly ignored directories.
+exclude = [
+  ".bzr",
+  ".direnv",
+  ".eggs",
+  ".git",
+  ".git-rewrite",
+  ".hg",
+  ".ipynb_checkpoints",
+  ".mypy_cache",
+  ".nox",
+  ".pants.d",
+  ".pyenv",
+  ".pytest_cache",
+  ".pytype",
+  ".ruff_cache",
+  ".svn",
+  ".tox",
+  ".venv",
+  ".vscode",
+  "__pypackages__",
+  "_build",
+  "buck-out",
+  "build",
+  "dist",
+  "node_modules",
+  "site-packages",
+  "venv",
+]
+extend-exclude = [ "test", "tests" ]
+
 # Enumerate all fixed violations.
 show-fixes = true
 
-[tool.ruff.lint]
+# Like Black, indent with spaces, rather than tabs.
+format.indent-style = "space"
+# Like Black, use double quotes for strings.
+format.quote-style = "double"
+# Like Black, automatically detect the appropriate line ending.
+format.line-ending = "auto"
+# Like Black, respect magic trailing commas.
+format.skip-magic-trailing-comma = false
+# Set the line length limit used when formatting code snippets in
+# docstrings.
+#
+# This only has an effect when the `docstring-code-format` setting is
+# enabled.
+format.docstring-code-line-length = "dynamic"
+format.exclude = [ "*.pyi" ]
+# Enable auto-formatting of code examples in docstrings. Markdown,
+# reStructuredText code/literal blocks and doctests are all supported.
+#
+# This is currently disabled by default, but it is planned for this
+# to be opt-out in the future.
+format.docstring-code-format = true
 # Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
 # McCabe complexity (`C901`) by default.
 # Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default, ('UP') is pyupgrade.
 # "ERA" - Found commented-out code
 # see https://docs.astral.sh/ruff/rules/#rules
-select = ["ALL"]
-#select = ["A", "ARG", "B", "C4", "DTZ", "E", "EM", "ERA", "EXE", "F", "FA", "FLY", "FURB", "G", "ICN", "INP", "INT", "LOG", "N", "PD", "PERF", "PIE", "PLC", "PLE", "PLW", "PT", "PTH", "PYI", "Q", "RET", "RSE", "RUF", "S", "SIM", "T10", "TID", "TRY", "UP", "W"]
-
-external = ["DOC", "PLR"]
-
-exclude = ["mailgun/examples/*", "tests"]
-
+lint.select = [ "ALL" ]
 #extend-select = ["W", "N", "UP", "B", "A", "C4", "PT", "SIM", "PD", "PLE", "RUF"]
 # Never enforce `E501` (line length violations).
-
-ignore = [
-    # TODO: Enable C901, TRY201, TRY003, EM101, PTH118, PLR0917 later
-    "C901", "TRY201", "TRY003", "EM101", "PTH118", "PLR0912", "PLR0917", "TD002", "TD003", "FIX002",
-    "ANN401",  # ANN401 Dynamically typed expressions (typing.Any) are disallowed in `**kwargs`
-    "ARG001",  # ARG001 Unused function argument: `kwargs`
-    "B904",  # Within an `except` clause, raise exceptions with `raise ... from err` or `raise ... from None`
-    # pycodestyle (E, W)
-    "CPY001",   # Missing copyright notice at top of file
-    "DOC201",  # DOC201 `return` is not documented in docstring
-    # TODO: Enable DOC501 when the upstream issue is fixed, see https://github.com/astral-sh/ruff/issues/12520
-    "DOC501",  # DOC501 Raised exception `ApiError` missing from docstring
-    "E501",
-    "PLR0911",  # PLR0911 Too many return statements (9 > 6)
-    "PLR0913",  # PLR0913 Too many arguments in function definition (6 > 5)
+lint.ignore = [
+  "ANN401", # ANN401 Dynamically typed expressions (typing.Any) are disallowed in `**kwargs`
+  "ARG001", # ARG001 Unused function argument: `kwargs`
+  "B904",   # Within an `except` clause, raise exceptions with `raise ... from err` or `raise ... from None`
+  # TODO: Enable C901, TRY201, TRY003, EM101, PTH118, PLR0917 later
+  "C901",
+  # pycodestyle (E, W)
+  "CPY001", # Missing copyright notice at top of file
+  "DOC201", # DOC201 `return` is not documented in docstring
+  # TODO: Enable DOC501 when the upstream issue is fixed, see https://github.com/astral-sh/ruff/issues/12520
+  "DOC501",  # DOC501 Raised exception `ApiError` missing from docstring
+  "E501",
+  "EM101",
+  "FIX002",
+  "PLR0911", # PLR0911 Too many return statements (9 > 6)
+  "PLR0912",
+  "PLR0913", # PLR0913 Too many arguments in function definition (6 > 5)
+  "PLR0917",
+  "PTH118",
+  "TD002",
+  "TD003",
+  "TRY003",
+  "TRY201",
 ]
-
+lint.exclude = [ "mailgun/examples/*", "tests" ]
+lint.per-file-ignores."__init__.py" = [ "E402" ]
 # Allow fix for all enabled rules (when `--fix`) is provided.
-fixable = ["ALL"]
-unfixable = ["B"]
-
+lint.fixable = [ "ALL" ]
+lint.unfixable = [ "B" ]
 # Allow unused variables when underscore-prefixed.
-dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
-
-[tool.ruff.lint.flake8-annotations]
-allow-star-arg-any = false
-ignore-fully-untyped = false
-
-[tool.ruff.lint.flake8-quotes]
-docstring-quotes = "double"
-
-[tool.ruff.format]
-exclude = ["*.pyi"]
-# Like Black, use double quotes for strings.
-quote-style = "double"
-
-# Like Black, indent with spaces, rather than tabs.
-indent-style = "space"
-
-# Like Black, respect magic trailing commas.
-skip-magic-trailing-comma = false
-
-# Like Black, automatically detect the appropriate line ending.
-line-ending = "auto"
-
-# Enable auto-formatting of code examples in docstrings. Markdown,
-# reStructuredText code/literal blocks and doctests are all supported.
-#
-# This is currently disabled by default, but it is planned for this
-# to be opt-out in the future.
-docstring-code-format = true
-
-# Set the line length limit used when formatting code snippets in
-# docstrings.
-#
-# This only has an effect when the `docstring-code-format` setting is
-# enabled.
-docstring-code-line-length = "dynamic"
-
-# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
-[tool.ruff.lint.per-file-ignores]
-"__init__.py" = ["E402"]
+lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+#select = ["A", "ARG", "B", "C4", "DTZ", "E", "EM", "ERA", "EXE", "F", "FA", "FLY", "FURB", "G", "ICN", "INP", "INT", "LOG", "N", "PD", "PERF", "PIE", "PLC", "PLE", "PLW", "PT", "PTH", "PYI", "Q", "RET", "RSE", "RUF", "S", "SIM", "T10", "TID", "TRY", "UP", "W"]
+lint.external = [ "DOC", "PLR" ]
+lint.flake8-annotations.allow-star-arg-any = false
+lint.flake8-annotations.ignore-fully-untyped = false
+lint.flake8-quotes.docstring-quotes = "double"
 #"path/to/file.py" = ["E402"]
-
-[tool.ruff.lint.isort]
-force-single-line = true
-force-sort-within-sections = false
-lines-after-imports = 2
-
-[tool.ruff.lint.mccabe]
-# Unlike Flake8, default to a complexity level of 10.
-max-complexity = 10
-
-[tool.ruff.lint.pycodestyle]
-ignore-overlong-task-comments = true
-
-[tool.ruff.lint.pydocstyle]
+lint.isort.force-single-line = true
+lint.isort.force-sort-within-sections = false
+lint.isort.lines-after-imports = 2
+lint.mccabe.max-complexity = 13
+lint.pycodestyle.ignore-overlong-task-comments = true
+# Ignore `E402` (import violations) in all `__init__.py` files, and in `path/to/file.py`.
 # TODO: Enable the 'sphinx' style when it will be available, see https://github.com/astral-sh/ruff/pull/13286
-convention = "google"
-
-[tool.pydocstyle]
-convention = "google"
-match = ".*.py"
-match_dir = '^examples/'
+lint.pydocstyle.convention = "google"
 
 [tool.flake8]
-exclude = ["mailgun/examples/*", "tests"]
-ignore = ['E501']
+exclude = [ "mailgun/examples/*", "tests" ]
+ignore = [ 'E501' ]
 extend-ignore = "W503"
 per-file-ignores = [
-    '__init__.py:F401',
+  '__init__.py:F401',
 ]
 max-line-length = 100
 count = true
+max-complexity = 13
 
-[tool.yapf]
-based_on_style = "facebook"
-SPLIT_BEFORE_BITWISE_OPERATOR = true
-SPLIT_BEFORE_ARITHMETIC_OPERATOR = true
-SPLIT_BEFORE_LOGICAL_OPERATOR = true
-SPLIT_BEFORE_DOT = true
+[tool.coverage.run]
+source_pkgs = [ "mailgun" ]
+branch = true
+parallel = true
+omit = [
+  "mailgun/examples/*",
+]
 
-[tool.yapfignore]
-ignore_patterns = [
+[tool.coverage.paths]
+tests = [ "tests" ]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
 ]
 
 [tool.mypy]
@@ -359,7 +332,7 @@ strict_equality = true
 #    (^|/)test[^/]*\.py$    # files named "test*.py"
 #  )'''
 exclude = [
-    "mailgun/examples/*",
+  "mailgun/examples/*",
 ]
 
 # Configuring error messages
@@ -369,17 +342,35 @@ show_error_codes = true
 disable_error_code = 'misc'
 
 [tool.pyright]
-include = ["mailgun"]
-exclude = ["mailgun/examples/*", "**/__pycache__"]
+include = [ "mailgun" ]
+exclude = [ "mailgun/examples/*", "**/__pycache__" ]
 reportAttributeAccessIssue = false
 reportMissingImports = false
 
+[tool.typos.default.extend-words]
+requestor = "requestor"
+
+[tool.pydocstyle]
+convention = "google"
+match = ".*.py"
+match_dir = '^examples/'
+
+[tool.yapf]
+based_on_style = "facebook"
+SPLIT_BEFORE_BITWISE_OPERATOR = true
+SPLIT_BEFORE_ARITHMETIC_OPERATOR = true
+SPLIT_BEFORE_LOGICAL_OPERATOR = true
+SPLIT_BEFORE_DOT = true
+
+[tool.yapfignore]
+ignore_patterns = [
+]
 
 [tool.bandit]
 # usage: bandit -c pyproject.toml -r .
-exclude_dirs = ["tests", "tests.py"]
-tests = ["B201", "B301"]
-skips = ["B101", "B601"]
+exclude_dirs = [ "tests", "tests.py" ]
+tests = [ "B201", "B301" ]
+skips = [ "B101", "B601" ]
 
 [tool.bandit.any_other_function_with_shell_equals_true]
 no_shell = [
@@ -399,7 +390,7 @@ no_shell = [
   "os.spawnve",
   "os.spawnvp",
   "os.spawnvpe",
-  "os.startfile"
+  "os.startfile",
 ]
 shell = [
   "os.system",
@@ -413,29 +404,11 @@ shell = [
   "popen2.Popen3",
   "popen2.Popen4",
   "commands.getoutput",
-  "commands.getstatusoutput"
+  "commands.getstatusoutput",
 ]
 subprocess = [
   "subprocess.Popen",
   "subprocess.call",
   "subprocess.check_call",
-  "subprocess.check_output"
-]
-
-[tool.coverage.run]
-source_pkgs = ["mailgun"]
-branch = true
-parallel = true
-omit = [
-    "mailgun/examples/*",
-]
-
-[tool.coverage.paths]
-tests = ["tests"]
-
-[tool.coverage.report]
-exclude_lines = [
-    "no cov",
-    "if __name__ == .__main__.:",
-    "if TYPE_CHECKING:",
+  "subprocess.check_output",
 ]
diff --git a/tests/__init__.py b/tests/__init__.py
index 8a3bbd3..541ba74 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1,6 +1,7 @@
 """The `tests` package contains unit and integration tests for the Mailgun API client.
 
-This package ensures that all core functionalities of the Mailgun client, including
-authentication, API requests, error handling, and response parsing, work as expected.
-Each module within this package tests a specific aspect or component of the client.
+This package ensures that all core functionalities of the Mailgun
+client, including authentication, API requests, error handling, and
+response parsing, work as expected. Each module within this package
+tests a specific aspect or component of the client.
 """
diff --git a/tests/tests.py b/tests/tests.py
index 1f4e471..9c29a42 100644
--- a/tests/tests.py
+++ b/tests/tests.py
@@ -5,8 +5,10 @@
 import json
 import os
 import string
+import subprocess
 import unittest
 import random
+from pathlib import Path
 from typing import Any
 from datetime import datetime, timedelta
 
@@ -22,7 +24,6 @@ class MessagesTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -66,7 +67,6 @@ class DomainTests(unittest.TestCase):
 
     It's happening because domain name is not deleting permanently after API call, so every new create will cause an error,
     as that domain is still exists. To avoid the problems we use a random domain name generator.
-
     """
 
     def setUp(self) -> None:
@@ -129,6 +129,8 @@ def tearDown(self) -> None:
         # otherwise, test_delete_domain and test_verify_domain will fail with a new run of tests
         self.client.domains.delete(domain=self.test_domain)
 
+    # Make sure that you can Add New Domain (see https://app.mailgun.com/mg/sending/new-domain) in your Mailgun Plan,
+    # otherwise you get Error 403.
     @pytest.mark.order(1)
     def test_post_domain(self) -> None:
         self.client.domains.delete(domain=self.test_domain)
@@ -145,7 +147,7 @@ def test_post_domain_creds(self) -> None:
         self.assertEqual(request.status_code, 200)
         self.assertIn("message", request.json())
 
-    @pytest.mark.order(2)
+    @pytest.mark.order(3)
     def test_update_simple_domain(self) -> None:
         self.client.domains.delete(domain=self.test_domain)
         self.client.domains.create(data=self.post_domain_data)
@@ -154,7 +156,7 @@ def test_update_simple_domain(self) -> None:
         self.assertEqual(request.status_code, 200)
         self.assertEqual(request.json()["message"], "Domain has been updated")
 
-    @pytest.mark.order(2)
+    @pytest.mark.order(3)
     def test_put_domain_creds(self) -> None:
         self.client.domains_credentials.create(
             domain=self.domain,
@@ -169,7 +171,7 @@ def test_put_domain_creds(self) -> None:
         self.assertEqual(request.status_code, 200)
         self.assertIn("message", request.json())
 
-    @pytest.mark.order(2)
+    @pytest.mark.order(3)
     def test_put_mailboxes_credentials(self) -> None:
         """Test to update Mailgun SMTP credentials: Happy Path with valid data."""
         self.client.domains_credentials.create(
@@ -206,7 +208,8 @@ def test_get_smtp_creds(self) -> None:
         self.assertEqual(request.status_code, 200)
         self.assertIn("items", request.json())
 
-    @pytest.mark.order(3)
+    @pytest.mark.order(4)
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     def test_get_sending_queues(self) -> None:
         self.client.domains.delete(domain=self.test_domain)
         self.client.domains.create(data=self.post_domain_data)
@@ -215,7 +218,7 @@ def test_get_sending_queues(self) -> None:
         self.assertIn("scheduled", request.json())
 
     @pytest.mark.order(4)
-    @pytest.mark.skip("The test can fail because the domain name is a random string")
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     def test_get_single_domain(self) -> None:
         self.client.domains.create(data=self.post_domain_data)
         req = self.client.domains.get(domain_name=self.post_domain_data["name"])
@@ -224,7 +227,7 @@ def test_get_single_domain(self) -> None:
         self.assertIn("domain", req.json())
 
     @pytest.mark.order(5)
-    @pytest.mark.skip("The test can fail because the domain name is a random string")
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     def test_verify_domain(self) -> None:
         self.client.domains.create(data=self.post_domain_data)
         req = self.client.domains.put(domain=self.post_domain_data["name"], verify=True)
@@ -295,6 +298,233 @@ def test_put_dkim_selector(self) -> None:
         )
         self.assertIn("message", request.json())
 
+    @pytest.mark.order(6)
+    def test_get_dkim_keys(self) -> None:
+        """Test to get keys for all domains: happy path with valid data."""
+        data = {
+            "page": "string",
+            "limit": "0",
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+        }
+
+        req = self.client.dkim_keys.get(data=data)
+
+        expected_keys = [
+            "items",
+            "paging",
+        ]
+
+        expected_items_keys = [
+            "signing_domain",
+            "selector",
+            "dns_record",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_items_keys) for key in req.json()["items"][0]]  # type: ignore[func-returns-value]
+
+    @pytest.mark.order(6)
+    def test_post_dkim_keys(self) -> None:
+        """Test to create a domain key: happy path with valid data."""
+        # Private key PEM file must be generated in PKCS1 format. You need 'openssl' on your machine
+        # openssl genrsa -traditional -out .server.key 2048
+        subprocess.run(["openssl", "genrsa", "-traditional", "-out", ".server.key", "2048"])
+        server_key_path = Path(".server.key")
+        files = [
+            (
+                "pem",
+                ("server.key", server_key_path.read_bytes()),
+            )
+        ]
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": files,
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        req = self.client.dkim_keys.create(data=data, headers=headers, files=files)
+
+        expected_keys = [
+            "signing_domain",
+            "selector",
+            "dns_record",
+        ]
+
+        expected_dns_record_keys = [
+            "is_active",
+            "cached",
+            "name",
+            "record_type",
+            "valid",
+            "value",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_dns_record_keys) for key in req.json()["dns_record"]]  # type: ignore[func-returns-value]
+
+        # Also you can remove a domain key on WEB UI https://app.mailgun.com/mg/sending/domains selecting your "signing_domain"
+        query = {"signing_domain": "python.test.domain5", "selector": "smtp"}
+        req2 = self.client.dkim_keys.delete(filters=query)
+
+        self.assertIsInstance(req2.json(), dict)
+        self.assertEqual(req2.status_code, 200)
+        self.assertIn("success", req2.json()["message"])
+
+        server_key_path.unlink(missing_ok=True)
+        print(f"File {server_key_path} has been removed.")
+
+    @pytest.mark.order(6)
+    def test_post_dkim_keys_invalid_pem_string(self) -> None:
+        """Test to create a domain key: expected failure to parse PEM from string."""
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": "lorem ipsum",
+        }
+
+        req = self.client.dkim_keys.create(data=data)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        self.assertIn("failed to import domain key: failed to parse PEM", req.json()["message"])
+
+    @pytest.mark.order(6)
+    def test_post_dkim_keys_if_duplicate_key_exists(self) -> None:
+        """Test to create a domain key: expected failure because a duplicate key exists"""
+
+        subprocess.run(["openssl", "genrsa", "-traditional", "-out", ".server.key", "2048"])
+        server_key_path = Path(".server.key")
+        files = [
+            (
+                "pem",
+                ("server.key", server_key_path.read_bytes()),
+            )
+        ]
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": files,
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        req = self.client.dkim_keys.create(data=data, headers=headers, files=files)
+
+        expected_keys = [
+            "signing_domain",
+            "selector",
+            "dns_record",
+        ]
+
+        expected_dns_record_keys = [
+            "is_active",
+            "cached",
+            "name",
+            "record_type",
+            "valid",
+            "value",
+        ]
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_dns_record_keys) for key in req.json()["dns_record"]]  # type: ignore[func-returns-value]
+
+        req2 = self.client.dkim_keys.create(data=data, headers=headers, files=files)
+
+        self.assertIsInstance(req2.json(), dict)
+        self.assertEqual(req2.status_code, 400)
+        self.assertIn("failed to create domain key: duplicate key", req2.json()["message"])
+
+    @pytest.mark.order(6)
+    def test_post_dkim_keys_key_must_be_pkcs1_format(self) -> None:
+        """Test to create a domain key: expected failure because a key must be PKCS1 format"""
+
+        subprocess.run(["openssl", "genpkey", "-algorithm", "Ed25519", "-out", ".server.key"])
+        server_key_path = Path(".server.key")
+        files = [
+            (
+                "pem",
+                ("server.key", server_key_path.read_bytes()),
+            )
+        ]
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": files,
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        req = self.client.dkim_keys.create(data=data, headers=headers, files=files)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        self.assertIn(
+            "failed to parse private key: key must be PKCS1 format", req.json()["message"]
+        )
+
+    @pytest.mark.order(7)
+    def test_delete_dkim_keys(self) -> None:
+        """Test to delete a domain key: happy path with valid data."""
+        query = {"signing_domain": "python.test.domain5", "selector": "smtp"}
+
+        req = self.client.dkim_keys.delete(filters=query)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        self.assertIn("success", req.json()["message"])
+
+    @pytest.mark.order(7)
+    def test_delete_non_existing_dkim_keys(self) -> None:
+        """Test to delete a domain key: expected failure if a domain doesn't exist."""
+        subprocess.run(["openssl", "genrsa", "-traditional", "-out", ".server.key", "2048"])
+        server_key_path = Path(".server.key")
+        files = [
+            (
+                "pem",
+                ("server.key", server_key_path.read_bytes()),
+            )
+        ]
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": files,
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        self.client.dkim_keys.create(data=data, headers=headers, files=files)
+
+        query = {"signing_domain": "python.test.domain5", "selector": "smtp"}
+
+        req1 = self.client.dkim_keys.delete(filters=query)
+        self.assertIsInstance(req1.json(), dict)
+        self.assertEqual(req1.status_code, 200)
+        self.assertIn("success", req1.json()["message"])
+
+        req2 = self.client.dkim_keys.delete(filters=query)
+
+        self.assertIsInstance(req2.json(), dict)
+        self.assertEqual(req2.status_code, 404)
+        self.assertIn("domain key not found", req2.json()["message"])
+
     @pytest.mark.order(7)
     def test_delete_domain_creds(self) -> None:
         self.client.domains_credentials.create(
@@ -321,6 +551,7 @@ def test_delete_all_domain_credentials(self) -> None:
                       "All domain credentials have been deleted")
 
     @pytest.mark.order(8)
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     def test_delete_domain(self) -> None:
         self.client.domains.create(data=self.post_domain_data)
         request = self.client.domains.delete(domain=self.test_domain)
@@ -341,7 +572,6 @@ class IpTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -389,7 +619,6 @@ class IpPoolsTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -456,7 +685,6 @@ class EventsTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -488,7 +716,6 @@ class TagsTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -562,7 +789,6 @@ class BouncesTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -640,7 +866,6 @@ class UnsubscribesTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -721,7 +946,6 @@ class ComplaintsTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -807,7 +1031,6 @@ class WhiteListTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -866,7 +1089,6 @@ class RoutesTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1028,7 +1250,6 @@ class WebhooksTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1092,7 +1313,6 @@ class MailingListsTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1287,7 +1507,6 @@ class TemplatesTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1502,7 +1721,6 @@ class EmailValidationTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1562,7 +1780,6 @@ class InboxPlacementTests(unittest.TestCase):
     messages functionality, with authentication and client initialization handled
     in `setUp`. Each test in this suite operates with the configured Mailgun client
     instance to simulate API interactions.
-
     """
     def setUp(self) -> None:
         self.auth: tuple[str, str] = (
@@ -1844,9 +2061,7 @@ def test_post_query_get_account_usage_metrics_invalid_data(self) -> None:
         req = self.client.analytics_usage_metrics.create(
             data=self.invalid_account_usage_metrics_data,
         )
-        from pprint import pprint
 
-        pprint(req.json())
         self.assertIsInstance(req.json(), dict)
         self.assertEqual(req.status_code, 400)
         self.assertNotIn("items", req.json())
@@ -2152,6 +2367,136 @@ def test_get_account_tag_incorrect_url_without_limits_part(self) -> None:
         self.assertIn("not found", req.json()["error"])
 
 
+class BounceClassificationTests(unittest.TestCase):
+    """Tests for Mailgun Bounce Classification API, https://api.mailgun.net/v2/bounce-classification/metrics.
+
+    This class provides setup functionality for tests involving the
+    functionality with authentication and client initialization handled
+    in `setUp`. Each test in this suite operates with the configured Mailgun client
+    instance to simulate API interactions.
+
+    """
+
+    def setUp(self) -> None:
+        self.auth: tuple[str, str] = (
+            "api",
+            os.environ["APIKEY"],
+        )
+        self.client: Client = Client(auth=self.auth)
+        self.domain: str = os.environ["DOMAIN"]
+
+        now = datetime.now()
+        now_formatted = now.strftime("%a, %d %b %Y %H:%M:%S +0000")
+        yesterday = now - timedelta(days=1)
+        yesterday_formatted = yesterday.strftime("%a, %d %b %Y %H:%M:%S +0000")  # noqa: FURB184
+
+        self.payload = {
+            "start": yesterday_formatted,
+            "end": now_formatted,
+            "resolution": "day",
+            "duration": "24h0m0s",
+            "dimensions": ["entity-name", "domain.name"],
+            "metrics": [
+                "critical_bounce_count",
+                "non_critical_bounce_count",
+                "critical_delay_count",
+                "non_critical_delay_count",
+                "delivered_smtp_count",
+                "classified_failures_count",
+                "critical_bounce_rate",
+                "non_critical_bounce_rate",
+                "critical_delay_rate",
+                "non_critical_delay_rate",
+            ],
+            "filter": {
+                "AND": [
+                    {
+                        "attribute": "domain.name",
+                        "comparator": "=",
+                        "values": [{"value": self.domain}],
+                    }
+                ]
+            },
+            "include_subaccounts": True,
+            "pagination": {"sort": "entity-name:asc", "limit": 10},
+        }
+        self.payload_without_dimensions = {
+            "start": yesterday_formatted,
+            "end": now_formatted,
+            "metrics": [
+                "critical_bounce_count",
+            ],
+            "pagination": {"sort": "entity-name:asc", "limit": 10},
+        }
+        self.payload_with_old_dates = {
+            "start": "Wed, 12 Nov 2000 23:00:00 UTC",
+            "end": "Thu, 13 Nov 2000 23:00:00 UTC",
+            "dimensions": ["entity-name", "domain.name"],
+            "metrics": [
+                "critical_bounce_count",
+            ],
+            "pagination": {"sort": "entity-name:asc", "limit": 10},
+        }
+        self.empty_payload: dict[str, str] = {}
+
+    def test_post_list_statistic(self) -> None:
+        """Test to post query to list statistic: Happy Path with valid data."""
+        req = self.client.bounceclassification_metrics.create(data=self.payload)
+
+        expected_keys: list[str] = [
+            "start",
+            "end",
+            "resolution",
+            "duration",
+            "dimensions",
+            "pagination",
+            "items",
+        ]
+        expected_dimensions_elements: list[str] = [
+            "entity-name",
+            "domain.name",
+        ]
+        expected_pagination_keys: list[str] = [
+            "sort",
+            "skip",
+            "limit",
+            "total",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json().keys()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_dimensions_elements) for key in req.json()["dimensions"]]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_pagination_keys) for key in req.json()["pagination"]]  # type: ignore[func-returns-value]
+
+    def test_post_list_statistic_without_dimensions(self) -> None:
+        """Test to post query to list statistic: Wrong Path with invalid data."""
+        req = self.client.bounceclassification_metrics.create(data=self.payload_without_dimensions)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
+        self.assertIn("sort should be either one of metrics or dimensions", req.json()["message"])
+
+    def test_post_list_statistic_with_old_dates(self) -> None:
+        """Test to post query to list statistic: Wrong Path with invalid data."""
+        req = self.client.bounceclassification_metrics.create(data=self.payload_with_old_dates)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
+        self.assertIn("is out of permitted log retention", req.json()["message"])
+
+    def test_post_list_statistic_with_empty_payload(self) -> None:
+        """Test to post query to list statistic: Wrong Path with invalid data."""
+        req = self.client.bounceclassification_metrics.create(data=self.empty_payload)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
+        self.assertIn("is out of permitted log retention", req.json()["message"])
+
+
 class UsersTests(unittest.TestCase):
     """Tests for Mailgun Users API, https://api.mailgun.net/v5/users.
 
@@ -2218,7 +2563,7 @@ def test_get_user_invalid_url(self) -> None:
         """Test to get account's users details: expected failure with invalid URL."""
         query = {"role": "admin", "limit": "0", "skip": "0"}
 
-        with self.assertRaises(KeyError) as cm:
+        with self.assertRaises(KeyError):
             self.client.user.get(filters=query)
 
     @pytest.mark.xfail
@@ -2303,6 +2648,118 @@ def test_get_invalid_user_details(self) -> None:
                 self.assertIsInstance(req2.json(), dict)
                 self.assertEqual(req2.status_code, 404)
 
+
+class KeysTests(unittest.TestCase):
+    """Tests for Mailgun Keys API, https://api.mailgun.net/v1/keys.
+
+    This class provides setup functionality for tests involving
+    with authentication and client initialization handled
+    in `setUp`. Each test in this suite operates with the configured Mailgun client
+    instance to simulate API interactions.
+
+    """
+
+    def setUp(self) -> None:
+        self.auth: tuple[str, str] = (
+            "api",
+            os.environ["APIKEY"],
+        )
+        self.client: Client = Client(auth=self.auth)
+        self.domain: str = os.environ["DOMAIN"]
+        self.mailgun_email = os.environ["MAILGUN_EMAIL"]
+        self.role = os.environ["ROLE"]
+        self.user_id = os.environ["USER_ID"]
+        self.user_name = os.environ["USER_NAME"]
+
+    def test_get_keys(self) -> None:
+        """Test to get the list of Mailgun API keys: happy path with valid data."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
+        req = self.client.keys.get(filters=query)
+
+        expected_keys = [
+            "total_count",
+            "items",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+
+    def test_get_keys_with_invalid_url(self) -> None:
+        """Test to get the list of Mailgun API keys: expected failure with invalid URL."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
+
+        with self.assertRaises(KeyError):
+            self.client.key.get(filters=query)
+
+    def test_get_keys_without_filtering_data(self) -> None:
+        """Test to get the list of Mailgun API keys: Happy Path without filtering data."""
+        req = self.client.keys.get()
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        self.assertGreater(len(req.json()["items"]), 0)
+
+    def test_post_keys(self) -> None:
+        """Test to create the Mailgun API key: happy path with valid data."""
+        data = {
+            "email": self.mailgun_email,
+            "domain_name": "python.test.domain5",
+            "kind": "web",
+            "expiration": "3600",
+            "role": self.role,
+            "user_id": self.user_id,
+            "user_name": self.user_name,
+            "description": "a new key",
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        req = self.client.keys.create(data=data, headers=headers)
+
+        expected_keys = [
+            "message",
+            "key",
+        ]
+
+        expected_key_keys = [
+            "id",
+            "description",
+            "kind",
+            "role",
+            "created_at",
+            "updated_at",
+            "expires_at",
+            "secret",
+            "is_disabled",
+            "domain_name",
+            "requestor",
+            "user_name",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        self.assertEqual(req.json()["message"], "great success")
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_key_keys) for key in req.json()["key"]]  # type: ignore[func-returns-value]
+
+    def test_delete_key(self) -> None:
+        """Test to delete the Mailgun API keys: happy path with valid data."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
+        req1 = self.client.keys.get(filters=query)
+        items = req1.json()["items"]
+
+        for item in items:
+            if self.mailgun_email == item["requestor"]:  # codespell:disable-line
+                req2 = self.client.keys.delete(key_id=item["id"])
+                self.assertEqual(req2.json()["message"], "key deleted")
+
+    @pytest.mark.skip("Don't regenerate a public Mailgun API without a need")
+    def test_regenerate_key(self) -> None:
+        """Test to regenerate the Mailgun API keys: happy path with valid data."""
+        self.client.keys_public.create()
+
+
 # ============================================================================
 # Async Test Classes (using AsyncClient and AsyncEndpoint)
 # ============================================================================
@@ -2402,6 +2859,8 @@ async def asyncTearDown(self) -> None:
         await self.client.domains.delete(domain=self.test_domain)
         await self.client.aclose()
 
+    # Make sure that you can Add New Domain (see https://app.mailgun.com/mg/sending/new-domain) in your Mailgun Plan,
+    # otherwise you get Error 403.
     @pytest.mark.order(1)
     async def test_post_domain(self) -> None:
         await self.client.domains.delete(domain=self.test_domain)
@@ -2451,8 +2910,6 @@ async def test_put_mailboxes_credentials(self) -> None:
         )
         name = "alice_bob"
         req = await self.client.mailboxes.put(domain=self.domain, login=f"{name}@{self.domain}")
-        print(req)
-        print(req.json())
 
         expected_keys = [
             "message",
@@ -2482,6 +2939,7 @@ async def test_get_smtp_creds(self) -> None:
         self.assertIn("items", request.json())
 
     @pytest.mark.order(3)
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     async def test_get_sending_queues(self) -> None:
         await self.client.domains.delete(domain=self.test_domain)
         await self.client.domains.create(data=self.post_domain_data)
@@ -2490,7 +2948,7 @@ async def test_get_sending_queues(self) -> None:
         self.assertIn("scheduled", request.json())
 
     @pytest.mark.order(4)
-    @pytest.mark.skip("The test can fail because the domain name is a random string")
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     async def test_get_single_domain(self) -> None:
         await self.client.domains.create(data=self.post_domain_data)
         req = await self.client.domains.get(domain_name=self.post_domain_data["name"])
@@ -2499,7 +2957,7 @@ async def test_get_single_domain(self) -> None:
         self.assertIn("domain", req.json())
 
     @pytest.mark.order(5)
-    @pytest.mark.skip("The test can fail because the domain name is a random string")
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     async def test_verify_domain(self) -> None:
         await self.client.domains.create(data=self.post_domain_data)
         req = await self.client.domains.put(domain=self.post_domain_data["name"], verify=True)
@@ -2570,14 +3028,60 @@ async def test_put_dkim_selector(self) -> None:
         )
         self.assertIn("message", request.json())
 
+    @pytest.mark.order(6)
+    async def test_get_dkim_keys(self) -> None:
+        """Test to get keys for all domains: happy path with valid data."""
+        data = {
+            "page": "string",
+            "limit": "0",
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+        }
+
+        req = await self.client.dkim_keys.get(data=data)
+
+        expected_keys = [
+            "items",
+            "paging",
+        ]
+
+        expected_items_keys = [
+            "signing_domain",
+            "selector",
+            "dns_record",
+        ]
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 200)
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_items_keys) for key in req.json()["items"][0]]  # type: ignore[func-returns-value]
+
+    @pytest.mark.order(6)
+    async def test_post_dkim_keys_invalid_pem_string(self) -> None:
+        """Test to create a domain key: expected failure to parse PEM from string."""
+
+        data = {
+            "signing_domain": "python.test.domain5",
+            "selector": "smtp",
+            "bits": "2048",
+            "pem": "lorem ipsum",
+        }
+
+        req = await self.client.dkim_keys.create(data=data)
+
+        self.assertIsInstance(req.json(), dict)
+        self.assertEqual(req.status_code, 400)
+        self.assertIn("failed to import domain key: failed to parse PEM", req.json()["message"])
+
     @pytest.mark.order(7)
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     async def test_delete_domain_creds(self) -> None:
         await self.client.domains_credentials.create(
-            domain=self.domain,
+            domain=self.test_domain,
             data=self.post_domain_creds,
         )
         request = await self.client.domains_credentials.delete(
-            domain=self.domain,
+            domain=self.test_domain,
             login="alice_bob",
         )
 
@@ -2594,6 +3098,7 @@ async def test_delete_all_domain_credentials(self) -> None:
         self.assertIn(request.json()["message"], "All domain credentials have been deleted")
 
     @pytest.mark.order(8)
+    @pytest.mark.xfail(reason="The test can fail because the domain name is a random string")
     async def test_delete_domain(self) -> None:
         await self.client.domains.create(data=self.post_domain_data)
         request = await self.client.domains.delete(domain=self.test_domain)
@@ -4076,9 +4581,7 @@ async def test_post_query_get_account_usage_metrics_invalid_data(self) -> None:
         req = await self.client.analytics_usage_metrics.create(
             data=self.invalid_account_usage_metrics_data,
         )
-        from pprint import pprint
 
-        pprint(req.json())
         self.assertIsInstance(req.json(), dict)
         self.assertEqual(req.status_code, 400)
         self.assertNotIn("items", req.json())
@@ -4435,7 +4938,7 @@ async def test_get_user_invalid_url(self) -> None:
         """Test to get account's users details: expected failure with invalid URL."""
         query = {"role": "admin", "limit": "0", "skip": "0"}
 
-        with self.assertRaises(KeyError) as cm:
+        with self.assertRaises(KeyError):
             await self.client.user.get(filters=query)
 
     @pytest.mark.xfail
@@ -4471,10 +4974,7 @@ async def test_own_user_details(self) -> None:
 
     async def test_get_user_details(self) -> None:
         """Test to get user details: happy path."""
-        """
-        GET /v5/users/{user_id}
-        :return:
-        """
+
         query = {"role": "admin", "limit": "0", "skip": "0"}
         req1 = await self.client.users.get(filters=query)
         users = req1.json()["users"]
@@ -4525,134 +5025,112 @@ async def test_get_invalid_user_details(self) -> None:
                 self.assertEqual(req2.status_code, 404)
 
 
-class BounceClassificationTests(unittest.TestCase):
-    """Tests for Mailgun Bounce Classification API, https://api.mailgun.net/v2/bounce-classification/metrics.
-
-    This class provides setup functionality for tests involving the
-    functionality with authentication and client initialization handled
-    in `setUp`. Each test in this suite operates with the configured Mailgun client
-    instance to simulate API interactions.
-
-    """
+class AsyncKeysTests(unittest.IsolatedAsyncioTestCase):
+    """Async tests for Mailgun Users API using AsyncClient."""
 
-    def setUp(self) -> None:
+    async def asyncSetUp(self) -> None:
         self.auth: tuple[str, str] = (
             "api",
             os.environ["APIKEY"],
         )
-        self.client: Client = Client(auth=self.auth)
+        self.client: AsyncClient = AsyncClient(auth=self.auth)
         self.domain: str = os.environ["DOMAIN"]
+        self.mailgun_email = os.environ["MAILGUN_EMAIL"]
+        self.role = os.environ["ROLE"]
+        self.user_id = os.environ["USER_ID"]
+        self.user_name = os.environ["USER_NAME"]
 
-        now = datetime.now()
-        now_formatted = now.strftime("%a, %d %b %Y %H:%M:%S +0000")
-        yesterday = now - timedelta(days=1)
-        yesterday_formatted = yesterday.strftime("%a, %d %b %Y %H:%M:%S +0000")  # noqa: FURB184
-
-        self.payload = {
-            "start": yesterday_formatted,
-            "end": now_formatted,
-            "resolution": "day",
-            "duration": "24h0m0s",
-            "dimensions": ["entity-name", "domain.name"],
-            "metrics": [
-                "critical_bounce_count",
-                "non_critical_bounce_count",
-                "critical_delay_count",
-                "non_critical_delay_count",
-                "delivered_smtp_count",
-                "classified_failures_count",
-                "critical_bounce_rate",
-                "non_critical_bounce_rate",
-                "critical_delay_rate",
-                "non_critical_delay_rate",
-            ],
-            "filter": {
-                "AND": [
-                    {
-                        "attribute": "domain.name",
-                        "comparator": "=",
-                        "values": [{"value": self.domain}],
-                    }
-                ]
-            },
-            "include_subaccounts": True,
-            "pagination": {"sort": "entity-name:asc", "limit": 10},
-        }
-        self.payload_without_dimensions = {
-            "start": yesterday_formatted,
-            "end": now_formatted,
-            "metrics": [
-                "critical_bounce_count",
-            ],
-            "pagination": {"sort": "entity-name:asc", "limit": 10},
-        }
-        self.payload_with_old_dates = {
-            "start": "Wed, 12 Nov 2000 23:00:00 UTC",
-            "end": "Thu, 13 Nov 2000 23:00:00 UTC",
-            "dimensions": ["entity-name", "domain.name"],
-            "metrics": [
-                "critical_bounce_count",
-            ],
-            "pagination": {"sort": "entity-name:asc", "limit": 10},
-        }
-        self.empty_payload: dict[str, str] = {}
+    async def asyncTearDown(self) -> None:
+        await self.client.aclose()
 
-    def test_post_list_statistic(self) -> None:
-        """Test to post query to list statistic: Happy Path with valid data."""
-        req = self.client.bounceclassification_metrics.create(data=self.payload)
+    async def test_get_keys(self) -> None:
+        """Test to get the list of Mailgun API keys: happy path with valid data."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
+        req = await self.client.keys.get(filters=query)
 
-        expected_keys: list[str] = [
-            "start",
-            "end",
-            "resolution",
-            "duration",
-            "dimensions",
-            "pagination",
+        expected_keys = [
+            "total_count",
             "items",
         ]
-        expected_dimensions_elements: list[str] = [
-            "entity-name",
-            "domain.name",
-        ]
-        expected_pagination_keys: list[str] = [
-            "sort",
-            "skip",
-            "limit",
-            "total",
-        ]
 
         self.assertIsInstance(req.json(), dict)
         self.assertEqual(req.status_code, 200)
-        [self.assertIn(key, expected_keys) for key in req.json().keys()]  # type: ignore[func-returns-value]
-        [self.assertIn(key, expected_dimensions_elements) for key in req.json()["dimensions"]]  # type: ignore[func-returns-value]
-        [self.assertIn(key, expected_pagination_keys) for key in req.json()["pagination"]]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
 
-    def test_post_list_statistic_without_dimensions(self) -> None:
-        """Test to post query to list statistic: Wrong Path with invalid data."""
-        req = self.client.bounceclassification_metrics.create(data=self.payload_without_dimensions)
+    @pytest.mark.asyncio
+    async def test_get_keys_with_invalid_url(self) -> None:
+        """Test to get the list of Mailgun API keys: expected failure with invalid URL."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
 
-        self.assertIsInstance(req.json(), dict)
-        self.assertEqual(req.status_code, 400)
-        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
-        self.assertIn("sort should be either one of metrics or dimensions", req.json()["message"])
+        with pytest.raises(KeyError):
+            await self.client.key.get(filters=query)
 
-    def test_post_list_statistic_with_old_dates(self) -> None:
-        """Test to post query to list statistic: Wrong Path with invalid data."""
-        req = self.client.bounceclassification_metrics.create(data=self.payload_with_old_dates)
+    async def test_get_keys_without_filtering_data(self) -> None:
+        """Test to get the list of Mailgun API keys: Happy Path without filtering data."""
+        req = await self.client.keys.get()
 
         self.assertIsInstance(req.json(), dict)
-        self.assertEqual(req.status_code, 400)
-        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
-        self.assertIn("is out of permitted log retention", req.json()["message"])
+        self.assertEqual(req.status_code, 200)
+        self.assertGreater(len(req.json()["items"]), 0)
 
-    def test_post_list_statistic_with_empty_payload(self) -> None:
-        """Test to post query to list statistic: Wrong Path with invalid data."""
-        req = self.client.bounceclassification_metrics.create(data=self.empty_payload)
+    async def test_post_keys(self) -> None:
+        """Test to create the Mailgun API key: happy path with valid data."""
+        data = {
+            "email": self.mailgun_email,
+            "domain_name": "python.test.domain5",
+            "kind": "web",
+            "expiration": "3600",
+            "role": self.role,
+            "user_id": self.user_id,
+            "user_name": self.user_name,
+            "description": "a new key",
+        }
+
+        headers = {"Content-Type": "multipart/form-data"}
+
+        req = await self.client.keys.create(data=data, headers=headers)
+
+        expected_keys = [
+            "message",
+            "key",
+        ]
+
+        expected_key_keys = [
+            "id",
+            "description",
+            "kind",
+            "role",
+            "created_at",
+            "updated_at",
+            "expires_at",
+            "secret",
+            "is_disabled",
+            "domain_name",
+            "requestor",
+            "user_name",
+        ]
 
         self.assertIsInstance(req.json(), dict)
-        self.assertEqual(req.status_code, 400)
-        [self.assertIn(key, "message") for key in req.json().keys()]  # type: ignore[func-returns-value]
-        self.assertIn("is out of permitted log retention", req.json()["message"])
+        self.assertEqual(req.status_code, 200)
+        self.assertEqual(req.json()["message"], "great success")
+        [self.assertIn(key, expected_keys) for key in req.json()]  # type: ignore[func-returns-value]
+        [self.assertIn(key, expected_key_keys) for key in req.json()["key"]]  # type: ignore[func-returns-value]
+
+    async def test_delete_key(self) -> None:
+        """Test to delete the Mailgun API keys: happy path with valid data."""
+        query = {"domain_name": "python.test.domain5", "kind": "web"}
+        req1 = await self.client.keys.get(filters=query)
+        items = req1.json()["items"]
+
+        for item in items:
+            if self.mailgun_email == item["requestor"]:  # codespell:disable-line
+                req2 = await self.client.keys.delete(key_id=item["id"])
+                self.assertEqual(req2.json()["message"], "key deleted")
+
+    @pytest.mark.skip("Don't regenerate a public Mailgun API without a need")
+    async def test_regenerate_key(self) -> None:
+        """Test to regenerate the Mailgun API keys: happy path with valid data."""
+        await self.client.keys_public.create()
 
 
 if __name__ == "__main__":