diff --git a/.github/workflows/pypi.yml b/.github/workflows/pypi.yml
deleted file mode 100644
index 66af8c8..0000000
--- a/.github/workflows/pypi.yml
+++ /dev/null
@@ -1,29 +0,0 @@
-name: Upload Python Package
-
-on:
-#  workflow_dispatch
-  create:
-    tags:
-    - v*
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up Python
-      uses: actions/setup-python@v2
-      with:
-        python-version: '3.x'
-    - name: Install dependencies
-      run: |
-        python -m pip install --upgrade pip
-        pip install setuptools wheel twine
-        pip install -r requirements.txt
-    - name: Build and publish
-      env:
-        TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
-        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
-      run: |
-        python setup.py sdist bdist_wheel
-        twine upload dist/*
diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml
new file mode 100644
index 0000000..bdaab28
--- /dev/null
+++ b/.github/workflows/python-publish.yml
@@ -0,0 +1,39 @@
+# This workflow will upload a Python Package using Twine when a release is created
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries
+
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package
+      uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}
diff --git a/CHANGELOG b/CHANGELOG
index 336027e..f942ff3 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -5,6 +5,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Released]
+## [3.0.0] - 2025-02-06
+### 🚨 **Breaking Changes**
+- **New API Implementation**: Introduced a completely new API structure.
+- **Unified Response Format**: Standardized response format for consistency across endpoints.
+- **Enhanced Performance**: Improved speed and efficiency for a faster, more seamless experience.
+
 ## [2.0.4.6] - 2021-04-09
  - support web search
  - add new CLI command ip [-h][-filter filed=regexp] ip
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..be574f9
--- /dev/null
+++ b/README.md
@@ -0,0 +1,229 @@
+## ZoomEye-python
+
+English | [中文文档](./docs/README_CN.md) 
+
+`ZoomEye` is a cyberspace search engine that allows users to search for network devices through a browser at <https://www.zoomeye.org>.
+
+`ZoomEye-python` is a Python library developed based on the `ZoomEye API`, providing both command-line interface and SDK integration capabilities for other tools. This library enables technical professionals to **search** and **export** ZoomEye data more conveniently.
+
+### 0x01 Installation Steps
+Install directly from `pypi`:
+
+    pip3 install zoomeye
+
+Or install via `github`:
+
+    pip3 install git+https://github.com/knownsec/ZoomEye-python.git
+
+
+### 0x02 Using CLI
+After successfully installing `ZoomEye-python`, you can directly use the `zoomeye` command as follows:
+
+```
+$ zoomeye -h
+usage: zoomeye [-h] [-v] {info,init,search,clear} ...
+
+positional arguments:
+  {info,init,search,clear}
+    info                Show ZoomEye account info
+    init                Initialize the token for ZoomEye-python
+    search              get network asset information based on query conditions.
+    clear               Manually clear the cache and user information
+
+options:
+  -h, --help            show this help message and exit
+  -v, --version         show program's version number and exit
+```
+
+#### 1. Token Initialization
+Before using `ZoomEye-python CLI`, you need to initialize the user `token`. This credential is used to verify user identity for querying data from `ZoomEye`; only API-KEY authentication is supported.
+
+You can view help through `zoomeye init -h`. Here's a demonstration using `APIKEY`:
+
+```
+$ zoomeye init -apikey "01234567-acbd-00000-1111-22222222222"
+Username: your username
+Role: Professional
+Points: 800000
+Zoomeye Points: 0
+```
+
+Users can obtain their `APIKEY` by logging into `ZoomEye` and accessing their profile (<https://www.zoomeye.org/profile>). The `APIKEY` doesn't expire, and users can reset it in their profile as needed.
+
+#### 2. User Information
+Users can retrieve their account information, subscription details, and current points through the `info` command:
+
+```
+$ zoomeye info
+username: <username>
+email: <email>
+phone: <phone number>
+created_at: 2021-01-15
+Subscription:: {'plan': 'Professional', 'end_date': '2025-12-31', 'points': 800000, 'zoomeye_points': 0}
+```
+
+#### 3. Search
+Search is the core functionality of `ZoomEye-python`, accessed through the `search` command. The `search` command requires a search keyword (`dork`). Here's a simple search example:
+
+```
+$ zoomeye search "telnet" 
+search "telnet" 
+ip                            port                          domain                        update_time                   
+134.xx.xx.129                 1901                          [unknown]                     2025-02-06T15:45:20           
+134.xx.xx.138                 1901                          [unknown]                     2025-02-06T15:45:19
+......
+
+total: 20/9976411
+```
+
+Using the `search` command is as simple as searching on `ZoomEye` through a browser. By default, we display the most important fields that users can use to understand target information:
+
+    1.ip             IP address
+    2.port           Port
+    3.domain         Target domain
+    4.update_time    Target scan time
+
+`search` supports the following parameters (`zoomeye search -h`) for data processing:
+
+    -facets facets        Statistics items, comma-separated; supports country, subdivisions, city, product, service, device, os, and port.
+    -fields field=regexp  Return fields, comma-separated; default: ip, port, domain, update_time. For more info, see: https://www.zoomeye.org/doc/
+    -sub_type {v4,v6,web,all}  Data type, supports v4, v6, and web; default is v4.
+    -page page            Default is page 1, sorted by update time.
+    -pagesize pagesize    Number of queries per page, default is 10, maximum is 10,000 per page.
+    -figure {pie,hist}    Parameter for data visualization
+    -save                 Save search results locally
+    -force                Ignore local cache files and fetch data directly from ZoomEye
+
+#### 4. Data Aggregation
+We can use `-facets` for data aggregation statistics. Using `-facets` allows you to query the aggregation status of the full data set for that dork (aggregated by `ZoomEye` and retrieved via `API`)
+
+```
+$ zoomeye search "telnet" -facets product -pagesize 1
+ip                            port                          domain                        update_time                   
+177.xxx.xx.142               2020                          [unknown]                     2025-02-06T15:59:49           
+
+total: 1/9976296
+ ----------------------------------------
+ ZoomEye total data:9976296
+ -------------product Top 10-------------
+ product                            count               
+ MikroTik router config httpd       3326013             
+ [unknown]                          2421245             
+ Apache httpd                       2411293             
+ ProFTPD                            285649              
+ Pulse Secure VPN httpd             182296              
+ Samsung printer telnetd            178147              
+ Huawei telnetd                     144382              
+ Huawei switch telnetd              120421              
+ TP-LINK TL-WR841N WAP httpd        118836              
+ DVR httpd                          100068 
+```
+
+#### 5. Data Export
+The `-save` parameter can be used to export data as follows:
+
+```
+$ zoomeye search "telnet" -pagesize 1 -save
+search "telnet"  -pagesize 1 -save
+ip                            port                          domain                        update_time                   
+88.xx.xxx.78                  3011                          [unknown]                     2025-02-06T16:00:53           
+
+total: 1/9976301
+save file to telnet_1_1738829058.json successful!
+```
+
+#### 6. Data Visualization
+The `-figure` parameter is for data visualization, offering both `pie` and `hist` (histogram) display options. When specified, it must be used together with `-facets`. Data is still displayed without specification. Here's an example of a pie chart:
+
+![](./images/pie.png)
+
+And a histogram:
+
+![](./images/hist.png)
+
+#### 7. Cleanup Function
+Users search for large amounts of data daily, which can lead to increasing storage space in the cache folder. If users use `ZoomEye-python` on public servers, their `API KEY` and `ACCESS TOKEN` might be exposed.
+Therefore, `ZoomEye-python` provides a cleanup command `zoomeye clear` to clear cache data and user configurations. Usage is as follows:
+
+```
+$zoomeye clear -h
+usage: zoomeye clear [-h] [-setting] [-cache]
+
+optional arguments:
+  -h, --help  show this help message and exit
+  -setting    clear user api key and access token
+  -cache      clear local cache file
+```
+
+#### 12. Cache Mechanism
+`ZoomEye-python` provides a caching mechanism in `cli` mode, located at `~/.config/zoomeye/cache`, to conserve user quotas as much as possible. Data sets queried by users are cached locally for 5 days, and when users query the same data set, it won't consume their quota.
+
+### 0x04 Using SDK
+#### 1. Token Initialization
+Similarly, the SDK only supports authentication via `APIKEY`:
+
+**APIKEY**
+```python
+from zoomeye.sdk import ZoomEye
+zm = ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
+```
+
+#### 2. SDK API
+Here are the interfaces provided by the SDK and their descriptions:
+```
+1.userinfo()
+    Get current user information
+
+2.search(dork, qbase64='', page=1, pagesize=20, sub_type='all', fields='', facets='')
+    Get network asset information based on search criteria.
+```
+
+#### 3. Usage Example
+```python
+from zoomeye.sdk import ZoomEye
+>>> dir(ZoomEye)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_check_header', '_request', 'search', 'userinfo']
+>>> zm = ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
+>>> zm.search('country=cn')
+{'code': 60000, 'message': 'success', 'query': 'country=cn', 'total': 823268005, 'data': [{...}], 'facets': {}}
+
+```
+
+### 0x05 Contributions
+[wh0ami1@knownsec 404](https://github.com/wh0ami1)  
+[0x7F@knownsec 404](https://github.com/0x7Fancy)  
+[dawu@knownsec 404](https://github.com/d4wu)  
+[fenix@knownsec 404](https://github.com/13ph03nix)
+
+
+### 0x06 Issues
+**1. How to input dorks containing quotes?**
+
+When using CLI for search queries containing quotes, such as `"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\"index.xhtml\""`, the dork must be wrapped in quotes to represent it as a complete parameter when it contains quotes or multiple quotes. Otherwise, the command-line parameter parsing will have issues. The correct search format for this dork should be: `'"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\"index.xhtml\""'`.
+
+> If there are no spaces or special characters, quotes can be omitted as the parameter parser will consume one set of quotes
+
+![](./images/web_search.png)
+
+![](./images/cli_search.png)
+
+**2. zoomeye-ai**
+
+If you are not a user from mainland China, please use <https://github.com/zoomeye-ai/ZoomEye-python>
+
+### 0x07 404StarLink Project
+
+![](https://github.com/knownsec/404StarLink-Project/raw/master/logo.png)
+
+ZoomEye-python is part of 404Team's [StarLink Project](https://github.com/knownsec/404StarLink-Project). If you have any questions about ZoomEye-python or want to connect with other users, you can refer to the StarLink Project's community joining methods.
+
+- [https://github.com/knownsec/404StarLink-Project#community](https://github.com/knownsec/404StarLink-Project#community)
+
+</br>
+
+---------------------------------
+References:  
+<https://www.zoomeye.org/doc>  
+
+knownsec 404  
+Update Time: 2025.02.06
\ No newline at end of file
diff --git a/README.rst b/README.rst
deleted file mode 100755
index a9fee30..0000000
--- a/README.rst
+++ /dev/null
@@ -1,833 +0,0 @@
-ZoomEye-python
---------------
-English | `中文文档 <docs/README_CN.md>`_
-
-``ZoomEye`` is a cyberspace search engine, users can search for
-network devices using a browser https://www.zoomeye.org.
-
-``ZoomEye-python`` is a Python library developed based on the
-``ZoomEye API``. It provides the ``ZoomEye command line`` mode and can
-also be integrated into other tools as an ``SDK``. The library allows
-technicians to **search**, **filter**, and **export** ``ZoomEye`` data
-more conveniently.
-
-
-
-0x01 installation
-~~~~~~~~~~~~~~~~~
-
-It can be installed directly from ``pypi``:
-
-::
-
-   pip3 install zoomeye
-
-or installed from ``github``:
-
-::
-
-   pip3 install git+https://github.com/knownsec/ZoomEye-python.git
-
-0x02 how to use cli
-~~~~~~~~~~~~~~~~~~~
-
-After successfully installing ``ZoomEye-python``, you can use the
-``zoomeye`` command directly, as follows:
-
-::
-
-   $ zoomeye -h
-   usage: zoomeye [-h] [-v] {info,search,init,ip,history,clear} ...
-    positional arguments:
-      {info,search,init,ip,history,clear}
-        info                Show ZoomEye account info
-        search              Search the ZoomEye database
-        init                Initialize the token for ZoomEye-python
-        ip                  Query IP information
-        history             Query device history
-        clear               Manually clear the cache and user information
-
-    optional arguments:
-      -h, --help            show this help message and exit
-      -v, --version         show program's version number and exit
-
-
-1.initialize token
-^^^^^^^^^^^^^^^^^^
-
-Before using the ``ZoomEye-python cli``, the user ``token`` needs to be
-initialized. The credential is used to verify the user’s identity to
-query data from ``ZoomEye``; only support API-KEY authentication methods.
-
-You can view the help through ``zoomeye init -h``, and use ``APIKEY`` to
-demonstrate below:
-
-::
-
-   $ zoomeye init -apikey "01234567-acbd-00000-1111-22222222222"
-   successfully initialized
-   Role: developer
-   Quota: 10000
-
-Users can login to ``ZoomEye`` and obtain ``APIKEY`` in personal
-information (https://www.zoomeye.org/profile); ``APIKEY`` will not
-expire, users can reset in personal information according to their
-needs.
-
-
-2.query quota
-^^^^^^^^^^^^^
-
-Users can query personal information and data quota through the ``info``
-command, as follows:
-
-::
-
-   $ zoomeye info
-    user_info: {
-        "email": "",
-        "name": "",
-        "nick_name": "",
-        "api_key": "",
-        "role": "",  # service level
-        "phone", "",
-        "expired_at": ""
-    }
-    quota: {
-        "remain_free_quota": "",  # This month remaining free amount
-        "remain_pay_quota": "",  # Amount of remaining payment this month
-        "remain_total_quota": ""  # Total amount remaining by the service date
-    }
-
-3.search
-^^^^^^^^
-
-Search is the core function of ``ZoomEye-python``, which is used through
-the ``search`` command. the ``search`` command needs to specify the
-search keyword (``dork``), let's perform a simple search below:
-
-::
-
-   $ zoomeye search "telnet" -num 1
-   ip:port       service  country  app                 banner                        
-   222.*.*.*:23  telnet   Japan    Pocket CMD telnetd  \xff\xfb\x01\xff\xfb\x03\xff\x...
-
-   total: 1
-
-Using the ``search`` command is as simple as using a browser to search
-in ``ZoomEye``. by default, we display five more important fields. users
-can use these data to understand the target information:
-
-::
-
-   1.ip:port  ip address and port
-   2.service  the service that the port is open
-   3.country  country of this ip address
-   4.app      application type
-   5.banner   characteristic response of the port
-
-In the above example, the number to be displayed is specified using the
-``-num`` parameter. in addition, ``search`` also supports the following
-parameters (``zoomeye search -h``) so that users can handle the data. we
-will explain and demonstrate below.
-
-::
-
-   -num     set the number of displays/searches, support 'all'
-   -count   query the total amount of this dork in the ZoomEye database
-   -facet   query the distribution of the full data of the dork
-   -stat    the distribution of statistical data result sets
-   -filter  query the list of a certain area in the data result set, or filter according to the content
-   -save    the result set can be exported according to the filter conditions
-   -force   ignore the local cache and force the data to be obtained from the API
-   -type    select web or host search
-
-4.number of data
-^^^^^^^^^^^^^^^^
-
-Through the ``-num`` parameter, we can specify the number of search and
-display, and the specified number is the number of consumed quantities.
-you can query the volume of the ``dork`` in the ZoomEye database through
-the ``-count`` parameter, as follows:
-
-::
-
-   $ zoomeye search "telnet" -count
-   56903258
-
-..
-
-   One thing to note, the consumption of the ``-num`` parameter is an
-   integer multiple of 20, because the minimum number of a single query
-   of the ``ZoomEye API`` is 20.
-
-5.statistics
-^^^^^^^^^^^^
-
-We can use ``-facet`` and ``-stat`` to perform data statistics, use
-``-facet`` to query the statistics of the dork's full data (obtained
-through ``API`` after statistics by ``ZoomEye``), and ``-stat`` You can
-perform statistics on the query result set. The fields supported by the
-two commands include:
-
-::
-
-    # host searhc
-    app      statistics by application type
-    device   statistics by device type
-    service  statistics by service type
-    os       statistics by operating system type
-    port     statistics by port
-    country  statistics by country
-    city     statistics by city
-
-    # web search
-    webapp      statistics by Web application
-    component   statistics by Web container
-    framework   statistics by Web framework
-    server      statistics by Web server
-    waf         statistics by Web firewall(WAF)
-    os          statistics by operating system
-    country     statistics by country
-
-use ``-facet`` to count the application types of all ``telnet`` devices:
-
-::
-
-   $ zoomeye search "telnet" -facet app
-   app                                count
-   [unknown]                          28317914
-   BusyBox telnetd                    10176313
-   Linux telnetd                      3054856
-   Cisco IOS telnetd                  1505802
-   Huawei Home Gateway telnetd        1229112
-   MikroTik router config httpd       1066947
-   Huawei telnetd                     965378
-   Busybox telnetd                    962470
-   Netgear broadband router...        593346
-   NASLite-SMB/Sveasoft Alc...        491957
-
-use ``-stat`` to count and query the application types of 20 ``telnet``
-devices:
-
-::
-
-   $ zoomeye search "telnet" -stat app
-   app                                count               
-   Cisco IOS telnetd                  7
-   [unknown]                          5
-   BusyBox telnetd                    4
-   Linux telnetd                      3
-   Pocket CMD telnetd                 1
-
-
-6.data filter
-^^^^^^^^^^^^^
-
-Use the ``-filter`` parameter to query the list of partial segments in
-the data result set, or filter based on content. The segments supported
-by this command include:
-
-::
-
-    # host/search
-    app           show application type details
-    version       show version information details
-    device        show device type details
-    port          show port information details
-    city          show city details
-    country       show country details
-    asn           show as number details
-    banner        show details of characteristic response
-    timestamp     show record data time
-    *             when this symbol is included, show all field details
-
-    # web/search
-    app         show application type details
-    headers     HTTP header
-    keywords    meta keyword
-    title       HTTP Title information
-    site        site search
-    city        show city details
-    country     show country details
-    webapp      Web application
-    component   Web container
-    framework   Web framework
-    server      Web server
-    waf         Web firewall(WAF)
-    os          operating system
-    timestamp   updated timestamp
-    *           when this symbol is included, show all field details
-
-
-Compared to the omitted display by default, the complete data can be
-viewed through ``-filter``, as follows:
-
-::
-
-   $ zoomeye search "telnet" -num 1 -filter banner
-   ip         banner                        
-   222.*.*.*  \xff\xfb\x01\xff\xfb\x03\xff\xfd\x03TELNET session now in ESTABLISHED state\r\n\r\n
-
-   total: 1
-
-When using ``-filter`` to filter, the syntax is: ``key1,key2,key3=value``, where ``key3=value`` is the filter condition, and the displayed content is ``key1,key2`` Example:
-
-::
-
-   $ zoomeye search telnet -num 1 -filter port,app,banner=Telnet
-
-    ip                        port                          app
-    240e:*:*:*::3             23                            LANDesk remote management
-
-In the above example: ``banner=Telnet`` is the filter condition, and ``port,app`` is the displayed content. If you need to display ``banner``, the filter statement is like this
-
-::
-
-    $ zoomeye search telnet -num 1 -filter port,app,banner,banner=Telnet
-
-
-
-7.data export
-^^^^^^^^^^^^^
-
-The ``-save`` parameter can export data. the syntax of this parameter is
-the same as that of ``-filter``, and the result is saved to a file in
-the format of line json, as follows:
-
-::
-
-   $ zoomeye search "telnet" -save banner=telnet
-   save file to telnet_1_1610446755.json successful!
-
-   $ cat telnet_1_1610446755.json
-   {'ip': '218.223.21.91', 'banner': '\\xff\\xfb\\x01\\xff\\xfb\\x03\\xff\\xfd\\x03TELNET session now in ESTABLISHED state\\r\\n\\r\\n'}
-
-..
-
-   if you use ``-save`` without any parameters, the query result will be
-   saved as a file according to the json format of ``ZoomEye API``. this
-   method is generally used to integrate data while retaining metadata;
-   the file can be as input, it is parsed and processed again through
-   ``cli``, such as ``zoomeye search "xxxxx.json"``.
-
-
-8.graphical data
-^^^^^^^^^^^^^^^^
-
-The ``-figure`` parameter is a data visualization parameter. This parameter provides two display methods: ``pie (pie chart)`` and ``hist (histogram)``. The data will still be displayed without specifying it. When ``-figure`` is specified , Only graphics will be displayed. The pie chart is as follows:
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205004653480.png
-    :width: 500px
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205005016399.png
-    :width: 500px
-
-The histogram is as follows:
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205004806739.png
-    :width: 500px
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205005117712.png
-    :width: 500px
-
-
-9. IP history
-^^^^^^^^^^^^^
-
-``ZoomEye-python`` provides the function of querying IP historical device data. Use the command ``history [ip]`` to query the historical data of IP devices. The usage is as follows:
-
-::
-
-    $zoomeye history "207.xx.xx.13" -num 1
-    207.xx.xx.13
-    Hostnames:                    [unknown]
-    Country:                      United States
-    City:                         Lake Charles
-    Organization:                 fulair.com
-    Lastupdated:                  2021-02-18T03:44:06
-    Number of open ports:         1
-    Number of historical probes:  1
-
-    timestamp                  port/service               app                        raw_data
-    2021-02-18 03:44:06        80/http                    Apache httpd               HTTP/1.0 301 Moved Permanently...
-
-
-
-By default, five fields are shown to users:
-
-::
-
-    1. time     recorded time
-    2. service  Open service
-    3. port     port
-    4. app      web application
-    5. raw      fingerprint information
-
-
-Use ``zoomeye history -h`` to view the parameters provided by ``history``.
-
-::
-
-    $zoomeye history -h
-
-    usage: zoomeye history [-h] [-filter filed=regexp] [-force] ip
-
-    positional arguments:
-      ip                    search historical device IP
-
-    optional arguments:
-      -h, --help            show this help message and exit
-      -filter filed=regexp  filter data and print raw data detail. field:
-                            [time,port,service,app,raw]
-      -force                ignore the local cache and force the data to be
-                            obtained from the API
-
-The following is a demonstration of ``-filter``:
-
-
-::
-
-    $zoomeye history "207.xx.xx.13" -filter "time=^2019-08,port,service"
-    207.xx.xx.13
-    Hostnames:                    [unknown]
-    Country:                      United States
-    City:                         Lake Charles
-    Organization:                 fulair.com
-    Lastupdated:                  2019-08-16T10:53:46
-    Number of open ports:         3
-    Number of historical probes:  3
-
-    time                       port                       service
-    2019-08-16 10:53:46        389                        ldap
-    2019-08-08 23:32:30        22                         ssh
-    2019-08-03 01:55:59        80                         http
-
-
-The `-filter` parameter supports the filtering of the following five fields:
-
-::
-
-    1.time      scan time
-    2.port      port information
-    3.service   open service
-    4.app       web application
-    5.banner    original fingerprint information
-    *           when this symbol is included, show all field details
-
-
-A display of the ``id`` field is added during the display. ``id`` is the serial number. For the convenience of viewing, it cannot be used as a filtered field.
-
-..
-
-    Note: At present, only the above five fields are allowed to filter.
-
-    The user quota will also be consumed when using the ``history`` command. The user quota will be deducted for the number of pieces of data returned in the ``history`` command. For example: IP "8.8.8.8" has a total of ``944`` historical records, and the user quota of ``944`` is deducted for one query.
-
-10. search IP information
-^^^^^^^^^^^^^^^^^^^^^^^^^
-You can query the information of the specified IP through the ``zoomeye ip`` command, for example:
-
-::
-
-    $ zoomeye ip 185.*.*.57
-    185.*.*.57
-    Hostnames:                    [unknown]
-    Isp:                          [unknown]
-    Country:                      Saudi Arabia
-    City:                         [unknown]
-    Organization:                 [unknown]
-    Lastupdated:                  2021-03-02T11:14:33
-    Number of open ports:         4{2002, 9002, 123, 25}
-
-    port      service        app                    banner
-    9002      telnet                                \xff\xfb\x01\xff\xfb\x0...
-    123       ntp            ntpd                   \x16\x82\x00\x01\x05\x0...
-    2002      telnet         Pocket CMD telnetd     \xff\xfb\x01\xff\xfb\x0...
-    25        smtp           Cisco IOS NetWor...    220 10.1.10.2 Cisco Net...
-
-
-The ``zoomeye ip`` command also supports the filter parameter ``-filter``, and the syntax is the same as that of ``zoomeye search``. E.g:
-
-::
-
-    $ zoomeye ip "185.*.*.57" -filter "app,app=ntpd"
-    Hostnames:                    [unknown]
-    Isp:                          [unknown]
-    Country:                      Saudi Arabia
-    City:                         [unknown]
-    Organization:                 [unknown]
-    Lastupdated:                  2021-02-17T02:15:06
-    Number of open ports:         0
-    Number of historical probes:  1
-
-    app
-    ntpd
-
-The fields supported by the ``filter`` parameter are:
-
-::
-
-     1.port       port information
-     2.service    open service
-     3.app        web application
-     4.banner     original fingerprint information
-
-
-
-..
-
-    Note: This function limits the number of queries per user per day based on different user levels.
-
-    Registered users and developers can query 10 times a day
-
-    Advanced users can query 20 times a day
-
-    VIP users can query 30 times a day
-
-    After the number of times per day is used up, it will be refreshed after 24 hours, that is, counting from the time of the first IP check, and the number of refreshes after 24 hours.
-
-
-11.cleanup function
-^^^^^^^^^^^^^^^^^^^^
-
-Users search for a large amount of data every day, which causes the storage space occupied by the cache folder to gradually increase; if users use ``ZoomEye-python`` on a public server, it may cause their own ``API KEY`` and ``ACCESS TOKEN`` to leak .
-For this reason, ``ZoomEye-python`` provides the clear command ``zoomeye clear``, which can clear the cached data and user configuration. The usage is as follows:
-
-::
-
-    $zoomeye clear -h
-    usage: zoomeye clear [-h] [-setting] [-cache]
-
-    optional arguments:
-      -h, --help  show this help message and exit
-      -setting    clear user api key and access token
-      -cache      clear local cache file
-
-
-11.data cache
-^^^^^^^^^^^^^
-
-``ZoomEye-python`` provides a caching in ``cli`` mode, which is located
-under ``~/.config/zoomeye/cache`` to save user quota as much as
-possible; the data set that the user has queried will be cached locally
-for 5 days. when users query the same data set, quotas are not consumed.
-
-
-13.domain name query
-^^^^^^^^^^^^^^^^^^^^
-
-``ZoomEye-python`` provides the domain name query function (including associated domain name query and subdomain name query). To query a domain name, run the domain [domain name] [query type] command as follows:
-
-
-::
-
-    $ python cli.py domain baidu.com 0
-    name                                                   timestamp      ip
-    zszelle.baidu30a72.bf.3dtops.com                       2021-06-27     204.11.56.48
-    zpvpcxa.baidu.3dtops.com                               2021-06-27     204.11.56.48
-    zsrob.baidu.3dtops.com                                 2021-06-27     204.11.56.48
-    zw8uch.7928.iwo7y0.baidu82.com                         2021-06-27     59.188.232.88
-    zydsrdxd.baidu.3dtops.com                              2021-06-27     204.11.56.48
-    zycoccz.baidu.3dtops.com                               2021-06-27     204.11.56.48
-    ...
-
-    total: 30/79882
-
-
-
-By default, the user is presented with three more important fields:
-
-
-::
-
-    1. name             域名全称
-    2. timestamp        建立时间戳
-    3. ip               ip地址
-
-
-
-Use ``zoomeye domain -h`` to view parameters provided by the ``domain``.
-
-
-::
-
-    $ python cli.py domain -h
-    usage: zoomeye domain [-h] [-page PAGE] [-dot] q {0,1}
-
-    positional arguments:
-      q           search key word(eg:baidu.com)
-      {0,1}       0: search associated domain;1: search sub domain
-
-    optional arguments:
-      -h, --help  show this help message and exit
-      -page PAGE  view the page of the query result
-      -dot        generate a network map of the domain name
-
-
-
-The following is a demonstration of ``-page`` :(default query for the first page when not specified)
-
-
-::
-
-    $ python cli.py domain baidu.com 0 -page 3
-    name                                                   timestamp      ip
-    zvptcfua.baidu6c7be.mm.3dtops.com                      2021-06-27     204.11.56.48
-    zmukxtd.baidu65c78.iw.3dtops.com                       2021-06-27     204.11.56.48
-    zhengwanghuangguanxianjinkaihu.baidu.fschangshi.com    2021-06-27     23.224.194.175
-    zibo-baidu.com                                         2021-06-27     194.56.78.148
-    zuwxb4.jingyan.baidu.66players.com                     2021-06-27     208.91.197.46
-    zhannei.baidu.com.hypestat.com                         2021-06-27     67.212.187.108
-    zrr.sjz-baidu.com                                      2021-06-27     204.11.56.48
-    zp5hd1.baidu.com.ojsdi.cn                              2021-06-27     104.149.242.155
-
-    ...
-
-    zhidao.baidu.com.39883.wxeve.cn                        2021-06-27     39.98.202.39
-    zhizhao.baidu.com                                      2021-06-27     182.61.45.108
-    zfamnje.baidu.3dtops.com                               2021-06-27     204.11.56.48
-    zjnfza.baidu.3dtops.com                                2021-06-27     204.11.56.48
-
-    total: 90/79882
-
-The ``-dot`` parameter can generate a network map of domain name and IP,Before using this function, you need to install ``grapvhiz``.
-Please refer to `grapvhiz <https://graphviz.org/download/>`_ for the installation tutorial. It is supported on Windows/Linux/Mac.
-The ``-dot`` parameter will generate a picture in ``png`` format and save the original dot language script at the same time.
-
-.. figure:: images/image-20211208112710711.png
-    :width: 500px
-
-0x03 video
-~~~~~~~~~~
-
-`ZoomEye-python is demonstrated under Windows, Mac, Linux, FreeBSD
-<https://weibo.com/tv/show/1034:4597603044884556?from=old_pc_videoshow>`_
-
-|asciicast|
-
-0x04 use SDK
-~~~~~~~~~~~~
-
-.. _initialize-token-1:
-
-1.initialize token
-^^^^^^^^^^^^^^^^^^
-
-Similarly, the SDK also supports API-KEY authentication methods,
- ``APIKEY``, as follows:
-
-**APIKEY**
-
-.. code:: python
-
-   from zoomeye.sdk import ZoomEye
-
-   zm = ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
-
-2.SDK API
-^^^^^^^^^
-
-The following are the interfaces and instructions provided by the SDK:
-
-::
-
-   1.dork_search(dork, page=0, resource="host", facets=None)
-     search the data of the specified page according to dork
-   2.multi_page_search(dork, page=1, resource="host", facets=None)
-     search multiple pages of data according to dork
-   3.resources_info()
-     get current user information
-   4.show_count()
-     get the number of all matching results under the current dork
-   5.dork_filter(keys)
-     extract the data of the specified field from the search results
-   6.get_facet()
-     get statistical results of all data from search results
-   7.history_ip(ip)
-     query historical data information of an ip
-   8.show_site_ip(data)
-     traverse the web-search result set, and output the domain name and ip address
-   9.show_ip_port(data)
-     traverse the host-search result set and output the ip address and port
-   10.generate_dot(self, q, source=0, page=1)
-     Generate graphviz files and pictures written in the domain center
-
-3.SDK example
-^^^^^^^^^^^^^
-
-.. code:: python
-
-   $ python3
-   >>> import zoomeye.sdk as zoomeye
-   >>> dir(zoomeye)
-   ['ZoomEye', 'ZoomEyeDict', '__builtins__', '__cached__', '__doc__',
-   '__file__', '__loader__', '__name__', '__package__', '__spec__',
-   'fields_tables_host', 'fields_tables_web', 'getpass', 'requests',
-   'show_ip_port', 'show_site_ip', 'zoomeye_api_test']
-   >>> # Use API-KEY search
-   >>> zm = zoomeye.ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
-   >>> data = zm.dork_search('apache country:cn')
-   >>> zoomeye.show_site_ip(data)
-   213.***.***.46.rev.vo***one.pt ['46.***.***.213']
-   me*****on.o****e.net.pg ['203.***.***.114']
-   soft********63221110.b***c.net ['126.***.***.110']
-   soft********26216022.b***c.net ['126.***.***.22']
-   soft********5084068.b***c.net ['126.***.***.68']
-   soft********11180040.b***c.net ['126.***.***.40']
-   ...
-
-.. _search-1:
-
-4.search
-^^^^^^^^
-
-As in the above example, we use ``dork_search()`` to search, and we can
-also set the ``facets`` parameter to obtain the aggregated statistical
-results of the full data of the dork. for the fields supported by
-``facets``, please refer to **2.use cli - 5.statistics**. as follows:
-
-.. code:: python
-
-   >>> data = zm.dork_search('telnet', facets='app')
-   >>> zm.get_facet()
-   {'product': [{'name': '', 'count': 28323128}, {'name': 'BusyBox telnetd', 'count': 10180912}, {'name': 'Linux telnetd', ......
-
-..
-
-   ``multi_page_search()`` can also search. use this function when you
-   need to obtain a large amount of data, where the ``page`` field
-   indicates how many pages of data are obtained; and ``dork_search()``
-   only obtains the data of a specified page.
-
-.. _data-filter-1:
-
-5.data filter
-^^^^^^^^^^^^^
-
-the ``dork_filter()`` function is provided in the SDK, we can filter the
-data more conveniently and extract the specified data fields as follows:
-
-.. code:: python
-
-   >>> data = zm.dork_search("telnet")
-   >>> zm.dork_filter("ip,port")
-   [['180.*.*.166', 5357], ['180.*.*.6', 5357], ......
-
-..
-
-   since the fields returned by ``web-search`` and ``host-search``
-   interfaces are different, you need to fill in the correct fields when
-   filtering. the fields included in ``web-search``: app / headers /
-   keywords / title / ip / site / city / country the fields included in
-   ``host-search``: app / version / device / ip / port / hostname / city
-   / country / asn / banner
-
-
-0x05 contributions
-~~~~~~~~~~~~~~~~~~
-
-| `r0oike@knownsec 404 <https://github.com/r0oike>`__
-| `0x7F@knownsec 404 <https://github.com/0x7Fancy>`__
-| `fenix@knownsec 404 <https://github.com/13ph03nix>`__
-| `dawu@knownsec 404 <https://github.com/d4wu>`__
-
-0x06 issue
-~~~~~~~~~~
-
-| **1.The minimum number of requests for SDK and command line tools is
-  20**
-| Due to API limitations, the minimum unit of our query is 20 pieces of
-  data at a time. for a new dork, whether it is to view the total number
-  or specify to search for only 1 piece of data, there will be an
-  overhead of 20 pieces; of course, in the cli, we provide a cache, the
-  data that has been searched is cached locally
-  (``~/.config/zoomeye/cache``), and the validity period is 5 days,
-  which can greatly save quota.
-
-| **2.How to enter dork with quotes?**
-| When using cli to search, you will encounter dork with quotes, for example: ``"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\ "index.xhtml\""``, when dork contains quotation marks or multiple quotation marks, the outermost layer of dork must be wrapped in quotation marks to indicate a parameter as a whole, otherwise command line parameter parsing will cause problems. Then the correct search method for the following dork should be: ``'"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\"index.xhtml\" "'``.
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205131713799.png
-    :width: 500px
-
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210205131802799.png
-    :width: 500px
-
-
-| **3.Why is there inconsistent data in facet?**
-| The following figure shows the full data statistics results of
-  ``telnet``. the result of the first query is that 20 data query
-  requests (including the statistical results) were initiated by cli one
-  day ago by default, and cached in a local folder; the second time We
-  set the number of queries to 21, cli will read 20 cached data and
-  initiate a new query request (actually the smallest unit is 20, which
-  also contains statistical results), the first query and the second
-  query a certain period of time is in between. during this period of
-  time, ``ZoomEye`` periodically scans and updates the data, resulting
-  in the above data inconsistency, so cli will use the newer statistical
-  results.
-  
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210111111035187.png
-    :width: 500px
-
-| **4.Why may the total amount of data in ZoomEye-python and the browser
-  search the same dork be different?**
-| ``ZoomEye`` provides two search interfaces: ``/host/search`` and ``/web/search``. In ``ZoomEye-python``, only ``/host/search`` is used by default, and ``/web/search`` is not used. Users can choose the search method according to their needs by specifying the ``type`` parameter.
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210111141028072.png
-    :width: 500px
-
-.. figure:: https://raw.githubusercontent.com/knownsec/ZoomEye-python/master/images/image-20210111141114558.png
-    :width: 500px
-
-| **5.The quota information obtained by the info command may be
-  inconsistent with the browser side?**
-| The browser side displays the free quota and recharge quota
-  (https://www.zoomeye.org/profile/record), but only the free quota
-  information is displayed in ``ZoomEye-python``, we will fix it in the
-  subsequent version This question.
-
-0x07 404StarLink Project
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. figure:: https://github.com/knownsec/404StarLink-Project/raw/master/logo.png
-
-``ZoomEye-python`` is a part of 404Team `Starlink
-Project <https://github.com/knownsec/404StarLink-Project>`__. If you
-have any questions about ``ZoomEye-python`` or want to talk to a small
-partner, you can refer to The way to join the group of Starlink Project.
-
--  https://github.com/knownsec/404StarLink-Project#community
-
---------------
-
-| References:
-| https://www.zoomeye.org/doc
-
-| knownsec 404
-| Time: 2021.01.12
-
-.. |asciicast| image:: https://asciinema.org/a/qyDaJw9qQc7UjffD04HzMApWa.svg
-   :target: https://asciinema.org/a/qyDaJw9qQc7UjffD04HzMApWa
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/api.md b/api.md
new file mode 100644
index 0000000..0fc56ce
--- /dev/null
+++ b/api.md
@@ -0,0 +1,370 @@
+<h1 class="zoomeye-references">ZoomEye API v2 参考手册</h1>
+
+- [API简介](#api简介)
+- [语法说明](#语法说明)
+- [验证方式](#验证方式)
+- [查询接口](#查询接口)
+  - [用户信息查询接口](#用户信息查询接口)
+    - [接口请求示例](#接口请求示例)
+    - [接口响应示例](#接口响应示例)
+    - [接口返回字段释义](#接口返回字段释义)
+  - [资产搜索接口](#资产搜索接口)
+    - [接口请求示例](#接口请求示例-1)
+    - [接口请求参数](#接口请求参数)
+    - [接口响应示例](#接口响应示例-1)
+    - [接口返回字段释义](#接口返回字段释义-1)
+    - [相关参考](#相关参考)
+        - [base64编码转换](#base64编码转换)
+
+
+# API简介
+**更新时间**：2024-12-04
+
+ZoomEye 平台为网络研究爱好者、开发者和安全极客提供强大且灵活的 RESTful API，让您能够无缝接入平台资源，自动化网络探索，构建丰富的应用场景，通过 ZoomEye API，您可以实现：
+
+① **自动化资产发现**
+
+批量检索全球网络设备、服务和系统，构建全面的网络资产地图。
+
+② **攻击面管理与集成**
+
+结合 API 功能，将网络资产数据无缝集成到现有的攻击面管理平台，精准识别并降低暴露面风险。
+
+③ **实时监控与威胁预警**
+
+持续跟踪暴露在互联网中的敏感资产，第一时间发现潜在风险。
+
+④  **定制化数据分析与工具开发**
+
+使用 ZoomEye 提供的丰富数据，开发自定义工具，如 IoT 安全验证工具、漏洞扫描插件、威胁情报分析系统等。
+
+⑤ **生成可视化报告**
+
+自动提取数据并生成资产或风险报告，为安全决策提供强有力支持。
+
+请求地址: https://api.zoomeye.org
+
+技术支持: <a href="mailto:zoomeye@knownsec.com"> API 支持</a>
+
+# 语法说明
+
+● 搜索范围覆盖设备(IPv4、IPv6)及网站(域名)
+
+● 输入搜索字符串时，系统将按“全局”模式匹配关键词，涵盖HTTP、SSH、FTP等多种协议的内容（如HTTP/HTTPS协议的header、body、ssl、title及其他协议的banner）
+
+● 搜索字符串不区分大小写，会进行分词后匹配(搜索结果页面提供了“分词”测试功能)，使用==搜索时为精准匹配严格限制搜索语法大小写
+
+● 搜索字符串请使用引号（如"Cisco System"或'Cisco System'）， 如果搜索字符串里存在引号可以使用 \ 进行转义 比如: "a\"b",如果搜索字符串里存在括号可以使用 \ 进行转义 比如: portinfo\(\)
+
+**逻辑运算**
+
+| SearchLogic | 说明                                                         | 示例                                                         |
+| :---------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| =           | 搜索包含关键词的资产                                         | [title="知道创宇"](https://www.zoomeye.org/searchResult?q=dGl0bGU9IuefpemBk%2BWIm%2BWuhyI%3D)搜索网站标题包含知道创宇的资产 |
+| ==          | 精准搜索，表示完全匹配关键词(区分大小写)，可搜索值为空的数据 | [title=="知道创宇"](https://www.zoomeye.org/searchResult?q=dGl0bGU9PSLnn6XpgZPliJvlroci)搜索网站标题为知道创宇的资产 |
+| \|\|        | 在搜索框中输入“\|\|”则表示“或”的运算逻辑                     | [service="ssh" \|\| service="http"](https://www.zoomeye.org/searchResult?q=c2VydmljZT0ic3NoIiB8fCBzZXJ2aWNlPSJodHRwIg%3D%3D)搜索ssh或http协议的数据 |
+| &&          | 在搜索框中输入"&&"则表示"且"的运算逻辑                       | [device="router" && after="2020-01-01"](https://www.zoomeye.org/searchResult?q=ZGV2aWNlPSJyb3V0ZXIiICYmIGFmdGVyPSIyMDIwLTAxLTAxIg%3D%3D)搜索2020-01-01后路由器的数据 |
+| !=          | 在搜索框中输入"!="则表示"非"的运算逻辑                       | [country="CN" && subdivisions!="beijing"](https://www.zoomeye.org/searchResult?q=Y291bnRyeT0iQ04iICYmIHN1YmRpdmlzaW9ucyE9ImJlaWppbmci)搜索中国地区内除北京的数据 |
+| ()          | 在搜索框中输入"()"则表示"优先处理"的运算逻辑                 | [(country="CN" && port!=80) \|\| (country="US" && title!="404 Not Found")](https://www.zoomeye.org/searchResult?q=KGNvdW50cnk9IkNOIiAmJiBwb3J0IT04MCkgfHwgKGNvdW50cnk9IlVTIiAmJiB0aXRsZSE9IjQwNCBOb3QgRm91bmQiKQ%3D%3D)搜索中国排除80端口或美国排除"404 Not Found"的数据 |
+| *           | 模糊搜索，使用 * 进行搜索                                    | [title="google*"](https://www.zoomeye.org/searchResult?q=dGl0bGU9Imdvb2dsZSoi)搜索网站标题中包含google的资产，且标题可以以任意字符结尾 |
+
+**地理位置搜索**
+
+地理位置搜索
+
+| 语法                                                         | 说明                     | 注                                                           |
+| :----------------------------------------------------------- | :----------------------- | :----------------------------------------------------------- |
+| [country="CN"](https://www.zoomeye.org/searchResult?q=Y291bnRyeT0iQ04i) | 搜索国家地区资产         | 可以使用国家缩写，也可以使用中/英文全称如[country="中国"](https://www.zoomeye.org/searchResult?q=Y291bnRyeT0i5Lit5Zu9Ig%3D%3D) |
+| [subdivisions="beijing"](https://www.zoomeye.org/searchResult?q=c3ViZGl2aXNpb25zPSJiZWlqaW5nIg%3D%3D) | 搜索相关指定行政区的资产 | 中国省会支持中文及英文描述搜索如[subdivisions="北京"](https://www.zoomeye.org/searchResult?q=c3ViZGl2aXNpb25zPSLljJfkuqwi) |
+| [city="changsha"](https://www.zoomeye.org/searchResult?q=Y2l0eT0iY2hhbmdzaGEi) | 搜索相关城市资产         | 中国城市支持中文及英文描述搜索如[city="长沙"](https://www.zoomeye.org/searchResult?q=Y2l0eT0i6ZW%2F5rKZIg%3D%3D) |
+
+**证书搜索**
+
+| 语法                                                         | 说明                                | 注                                     |
+| :----------------------------------------------------------- | :---------------------------------- | :------------------------------------- |
+| [ssl="google"](https://www.zoomeye.org/searchResult?q=c3NsPSJnb29nbGUi) | 搜索ssl证书存在"google"字符串的资产 | 常常用来提过产品名及公司名搜索对应目标 |
+| [ssl.cert.fingerprint="F3C98F223D82CC41CF83D94671CCC6C69873FABF"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQuZmluZ2VycHJpbnQ9IkYzQzk4RjIyM0Q4MkNDNDFDRjgzRDk0NjcxQ0NDNkM2OTg3M0ZBQkYi) | 搜索证书相关指纹资产                |                                        |
+| [ssl.chain_count=3](https://www.zoomeye.org/searchResult?q=c3NsLmNoYWluX2NvdW50PTM%3D) | 搜索ssl链计数资产                   |                                        |
+| [ssl.cert.alg="SHA256-RSA"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQuYWxnPSJTSEEyNTYtUlNBIg%3D%3D) | 搜索证书支持的签名算法              |                                        |
+| [ssl.cert.issuer.cn="pbx.wildix.com"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQuaXNzdWVyLmNuPSJwYngud2lsZGl4LmNvbSI%3D) | 搜索用户证书签发者通用域名名称      |                                        |
+| [ssl.cert.pubkey.rsa.bits=2048](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQucHVia2V5LnJzYS5iaXRzPTIwNDg%3D) | 搜索rsa_bits证书公钥位数            |                                        |
+| [ssl.cert.pubkey.ecdsa.bits=256](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQucHVia2V5LmVjZHNhLmJpdHM9MjU2) | 搜索ecdsa_bits证书公钥位数          |                                        |
+| [ssl.cert.pubkey.type="RSA"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQucHVia2V5LnR5cGU9IlJTQSI%3D) | 搜索证书的公钥类型                  |                                        |
+| [ssl.cert.serial="18460192207935675900910674501"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQuc2VyaWFsPSIxODQ2MDE5MjIwNzkzNTY3NTkwMDkxMDY3NDUwMSI%3D) | 搜索证书序列号                      |                                        |
+| [ssl.cipher.bits="128"](https://www.zoomeye.org/searchResult?q=c3NsLmNpcGhlci5iaXRzPSIxMjgi) | 搜索加密套件位数                    |                                        |
+| [ssl.cipher.name="TLS_AES_128_GCM_SHA256"](https://www.zoomeye.org/searchResult?q=c3NsLmNpcGhlci5uYW1lPSJUTFNfQUVTXzEyOF9HQ01fU0hBMjU2Ig%3D%3D) | 搜索加密套件名称                    |                                        |
+| [ssl.cipher.version="TLSv1.3"](https://www.zoomeye.org/searchResult?q=c3NsLmNpcGhlci52ZXJzaW9uPSJUTFN2MS4zIg%3D%3D) | 搜索加密套件版本                    |                                        |
+| [ssl.version="TLSv1.3"](https://www.zoomeye.org/searchResult?q=c3NsLnZlcnNpb249IlRMU3YxLjMi) | 搜索证书的ssl版本                   |                                        |
+| [ssl.cert.subject.cn="example.com"](https://www.zoomeye.org/searchResult?q=c3NsLmNlcnQuc3ViamVjdC5jbj0iZXhhbXBsZS5jb20i) | 搜索用户证书持有者通用域名名称      |                                        |
+| [ssl.jarm="29d29d15d29d29d00029d29d29d29dea0f89a2e5fb09e4d8e099befed92cfa"](https://www.zoomeye.org/searchResult?q=c3NsLmphcm09IjI5ZDI5ZDE1ZDI5ZDI5ZDAwMDI5ZDI5ZDI5ZDI5ZGVhMGY4OWEyZTVmYjA5ZTRkOGUwOTliZWZlZDkyY2ZhIg%3D%3D) | 搜索相关jarm内容的资产              |                                        |
+| [ssl.ja3s=45094d08156d110d8ee97b204143db14](https://www.zoomeye.org/searchResult?q=c3NsLmphM3M9NDUwOTRkMDgxNTZkMTEwZDhlZTk3YjIwNDE0M2RiMTQ%3D) | 查找与特定JA3S指纹相关的资产        |                                        |
+
+**IP及域名信息相关搜索**
+
+| 语法                                                         | 说明                                                         | 注                                                           |
+| :----------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------------------------------------- |
+| [ip="8.8.8.8"](https://www.zoomeye.org/searchResult?q=aXA9IjguOC44Ljgi) | 搜索指定IPv4地址相关资产                                     |                                                              |
+| [ip="2600:3c00::f03c:91ff:fefc:574a"](https://www.zoomeye.org/searchResult?q=aXA9IjI2MDA6M2MwMDo6ZjAzYzo5MWZmOmZlZmM6NTc0YSI%3D) | 搜索指定IPv6地址相关资产                                     |                                                              |
+| [cidr="52.2.254.36/24"](https://www.zoomeye.org/searchResult?q=Y2lkcj0iNTIuMi4yNTQuMzYvMjQi) | 搜索IP的C段资产                                              | cidr="52.2.254.36/16"为IP的B段资产，cidr="52.2.254.36/8"为IP的A段资产，如[cidr="52.2.254.36/16"](https://www.zoomeye.org/searchResult?q=Y2lkcj0iNTIuMi4yNTQuMzYvMTYi)[cidr="52.2.254.36/8"](https://www.zoomeye.org/searchResult?q=Y2lkcj0iNTIuMi4yNTQuMzYvOCI%3D) |
+| [org="北京大学"](https://www.zoomeye.org/searchResult?q=b3JnPSLljJfkuqzlpKflraYi)或者[organization="北京大学"](https://www.zoomeye.org/searchResult?q=b3JnYW5pemF0aW9uPSLljJfkuqzlpKflraYi) | 搜索相关组织(Organization)的资产                             | 用来定位大学、结构、大型互联网公司对应IP资产                 |
+| [isp="China Mobile"](https://www.zoomeye.org/searchResult?q=aXNwPSJDaGluYSBNb2JpbGUi) | 搜索相关网络服务提供商的资产                                 | 可结合org数据相互补充                                        |
+| [asn=42893](https://www.zoomeye.org/searchResult?q=YXNuPTQyODkz) | 搜索对应ASN（Autonomous system number）自治系统编号相关IP资产 |                                                              |
+| [port=80](https://www.zoomeye.org/searchResult?q=cG9ydD04MA%3D%3D) | 搜索相关端口资产                                             | 目前不支持同时开放多端口目标搜索                             |
+| [hostname="google.com"](https://www.zoomeye.org/searchResult?q=aG9zdG5hbWU9Imdvb2dsZS5jb20i) |                                                              | 搜索相关IP"主机名"的资产                                     |
+| [domain="baidu.com"](https://www.zoomeye.org/searchResult?q=ZG9tYWluPSJiYWlkdS5jb20i) | 搜索域名相关的资产                                           | 用来搜索域名和子域名数据                                     |
+| [icp.number="京ICP备10040895号-40"](https://www.zoomeye.org/searchResult?q=aWNwLm51bWJlcj0i5LqsSUNQ5aSHMTAwNDA4OTXlj7ctNDAi) | 搜索通过域名关联的ICP备案号包含"京ICP备10040895号-40"的网站资产 | 用来搜索备案域名资产                                         |
+| [icp.name="知道创宇"](https://www.zoomeye.org/searchResult?q=aWNwLm5hbWU9IuefpemBk%2BWIm%2BWuhyI%3D) | 搜索ICP备案企业名称包含"知道创宇"的资产                      | 用来搜索企业备案域名资产                                     |
+| [banner="FTP"](https://www.zoomeye.org/searchResult?q=YmFubmVyPSJGVFAi) | 搜索协议报文相关的数据                                       | 用于搜索非HTTP协议报文数据                                   |
+| [http.header="http"](https://www.zoomeye.org/searchResult?q=aHR0cC5oZWFkZXI9Imh0dHAi) | 搜索HTTP响应头相关的数据                                     | 用于搜索HTTP响应头的数据                                     |
+| [http.header_hash="27f9973fe57298c3b63919259877a84d"](https://www.zoomeye.org/searchResult?q=aHR0cC5oZWFkZXJfaGFzaD0iMjdmOTk3M2ZlNTcyOThjM2I2MzkxOTI1OTg3N2E4NGQi) | 通过HTTP响应头计算的hash值进行搜索                           |                                                              |
+| [http.header.server="Nginx"](https://www.zoomeye.org/searchResult?q=aHR0cC5oZWFkZXIuc2VydmVyPSJOZ2lueCIJ) | 搜索HTTP响应头中server数据                                   | 用于搜索HTTP响应头中Server的数据                             |
+| [http.header.version="1.2"](https://www.zoomeye.org/searchResult?q=aHR0cC5oZWFkZXIudmVyc2lvbj0iMS4yIg%3D%3D) | 搜索HTTP响应头中的服务版本号                                 |                                                              |
+| [http.header.status_code="200"](https://www.zoomeye.org/searchResult?q=aHR0cC5oZWFkZXIuc3RhdHVzX2NvZGU9IjIwMCI%3D) | 搜索HTTP响应头中的状态码                                     | 搜索HTTP响应状态码为200的资产或其他状态码，如302、404等      |
+| [http.body="document"](https://www.zoomeye.org/searchResult?q=aHR0cC5ib2R5PSJkb2N1bWVudCI%3D) | HTML正文进行查询搜索                                         |                                                              |
+| [http.body_hash="84a18166fde3ee7e7c974b8d1e7e21b4"](https://www.zoomeye.org/searchResult?q=aHR0cC5ib2R5X2hhc2g9Ijg0YTE4MTY2ZmRlM2VlN2U3Yzk3NGI4ZDFlN2UyMWI0Igk%3D) | HTML正文计算的hash值搜索                                     |                                                              |
+
+**指纹相关搜索**
+
+| 语法                                                         | 说明                                  | 注                                                           |
+| :----------------------------------------------------------- | :------------------------------------ | :----------------------------------------------------------- |
+| [app="Cisco ASA SSL VPN"](https://www.zoomeye.org/searchResult?q=YXBwPSJDaXNjbyBBU0EgU1NMIFZQTiI%3D) | 搜索思科ASA-SSL-VPN的设备             | 更多的app规则请参考[object Object]，在搜索框输入"思科"等关键词会有相关app提示 |
+| [service="ssh"](https://www.zoomeye.org/searchResult?q=c2VydmljZT0ic3NoIg%3D%3D) | 搜索对应服务协议的资产                | 常见服务协议包括：http、ftp、ssh、telnet等等(其他服务可参考搜索结果域名侧栏聚合展示) |
+| [device="router"](https://www.zoomeye.org/searchResult?q=ZGV2aWNlPSJyb3V0ZXIi) | 搜索路由器相关的设备类型              | 常见类型包括router(路由器)、switch (交换机)、storage- misc(存储设备)等等(其他类型可参考搜索结果域名侧栏聚合展示) |
+| [os="RouterOS"](https://www.zoomeye.org/searchResult?q=b3M9IlJvdXRlck9TIg%3D%3D) | 搜索相关操作系统                      | 常见系统包括Linux、Windows、RouterOS、IOS、JUNOS等等(其他系统可参考搜索结果域名侧栏聚合展示) |
+| [title="Cisco"](https://www.zoomeye.org/searchResult?q=dGl0bGU9IkNpc2NvIg%3D%3D) | 搜索html内容里标题中存在"Cisco"的数据 |                                                              |
+| [industry="政府"](https://www.zoomeye.org/searchResult?q=aW5kdXN0cnk9IuaUv%2BW6nCI%3D) | 搜索行业类型相关的资产                | 常见的行业类型包括科技、能源、金融制造业等等（其他类型可结合org数据相互补充） |
+| [product="Cisco"](https://www.zoomeye.org/searchResult?q=cHJvZHVjdD0iQ2lzY28i) | 搜索组件信息包含Cisco的资产           | 支持主流资产组件搜索                                         |
+| [protocol="TCP"](https://www.zoomeye.org/searchResult?q=cHJvdG9jb2w9IlRDUCI%3D) | 搜索传输协议为TCP的资产               | 常见的传输协议有TCP、UDP、TCP6、SCTP                         |
+| [is_honeypot="True"](https://www.zoomeye.org/searchResult?q=aXNfaG9uZXlwb3Q9IlRydWUi) | 筛选是否包含蜜罐资产                  |                                                              |
+
+**时间节点区间搜索**
+
+| 语法                                                         | 说明                                                  | 注                             |
+| :----------------------------------------------------------- | :---------------------------------------------------- | :----------------------------- |
+| [after="2020-01-01" && port="50050"](https://www.zoomeye.org/searchResult?q=YWZ0ZXI9IjIwMjAtMDEtMDEiICYmIHBvcnQ9IjUwMDUwIg%3D%3D) | 搜索更新时间为"2020-01-01"以后端口为"50050"以后的资产 | 时间过滤器需组合其他过滤器使用 |
+| [before="2020-01-01" && port="50050"](https://www.zoomeye.org/searchResult?q=YmVmb3JlPSIyMDIwLTAxLTAxIiAmJiBwb3J0PSI1MDA1MCI%3D) | 搜索更新时间在"2020-01-01"以前端口为"50050"以前的资产 | 时间过滤器需组合其他过滤器使用 |
+
+**Dig**
+
+| 语法                                                         | 说明                  | 注   |
+| :----------------------------------------------------------- | :-------------------- | :--- |
+| [dig="baidu.com 220.181.38.148"](https://www.zoomeye.org/searchResult?q=ZGlnPSJiYWlkdS5jb20gMjIwLjE4MS4zOC4xNDgi) | 搜索相关dig内容的资产 |      |
+
+**Iconhash**
+
+| 语法                                                         | 说明                                                         | 注                             |
+| :----------------------------------------------------------- | :----------------------------------------------------------- | :----------------------------- |
+| [iconhash="f3418a443e7d841097c714d69ec4bcb8"](https://www.zoomeye.org/searchResult?q=aWNvbmhhc2g9ImYzNDE4YTQ0M2U3ZDg0MTA5N2M3MTRkNjllYzRiY2I4Ig%3D%3D) | 通过 md5 方式对目标数据进行解析，根据图标搜索相关内容的资产  | 搜索包含"google"图标的相关资产 |
+| [iconhash="1941681276"](https://www.zoomeye.org/searchResult?q=aWNvbmhhc2g9IjE5NDE2ODEyNzYi) | 通过 mmh3 方式对目标数据进行解析，根据图标搜索相关内容的资产 | 搜索包含"amazon"图标的相关资产 |
+
+**Filehash**
+
+| 语法                                                         | 说明                                                       | 注                             |
+| :----------------------------------------------------------- | :--------------------------------------------------------- | :----------------------------- |
+| [filehash="0b5ce08db7fb8fffe4e14d05588d49d9"](https://www.zoomeye.org/searchResult?q=ZmlsZWhhc2g9IjBiNWNlMDhkYjdmYjhmZmZlNGUxNGQwNTU4OGQ0OWQ5Ig%3D%3D) | 通过上传方式进行查询，根据解析的文件数据搜索相关内容的资产 | 搜索包含"Gitlab"解析的相关资产 |
+
+# 验证方式
+
+* ZoomEye-API 支持API-KEY验证方式，每个账号在其个人资料页面下方会找到 `API-KEY` 的字符串，将该字符串填入到 ZoomEye-API 的 `API-KEY` 字段即可，您可以从 [这里](https://www.zoomeye.org/v2/profile) 获取 API-KEY。
+
+<img style="max-width: 100%" src="./images/doc-api-key-zh.png" >
+
+# 查询接口
+
+## 用户信息查询接口
+
+获取用户信息、订阅详细信息和当前积分情况。
+
+`POST /v2/userinfo`
+
+### 接口请求示例
+
+```bash
+# Bash
+curl -X POST https://api.zoomeye.org/v2/userinfo -H "API-KEY: $YOUR_API_KEY"
+```
+
+### 接口响应示例
+
+```json
+{
+  "code": 60000,
+  "message": "success",
+  "data": {
+    "username": "abc",
+    "email": "user@example.com",
+    "phone": "+1234567890",
+    "created_at": "2013-01-15T08:00:00Z",
+    "subscription": {
+      "plan": "Premium",
+      "end_date": "2024-01-20T00:00:00Z",
+      "points": "30000",
+      "zoomeye_points": "10000000"
+    }
+  }
+}
+```
+
+### 接口返回字段释义
+
+|字段名称|字段类型|字段描述|
+|---|---|---|
+|code|integer|响应代码|
+|message|string|响应消息|
+|data|object|用户信息和订阅详细信息|
+|username|string|用户名|
+|email|string|用户邮箱地址|
+|phone|string|用户电话号码|
+|created_at|string(date-time)|用户创建时间|
+|subscription|object|用户订阅信息|
+|plan|string|订阅计划|
+|end_date|string(date-time)|订阅结束日期|
+|points|string|可用的普通积分，您也可以从 [这里](https://www.zoomeye.org/v2/profile/record) 查看|
+|zoomeye_points|string|可用的权益积分，您也可以从 [这里](https://www.zoomeye.org/v2/profile/record) 查看|
+
+
+## 资产搜索接口
+
+根据查询条件获取网络资产信息。
+
+`POST /v2/search`
+
+
+### 接口请求示例
+
+```bash
+# Bash
+curl -L 'https://api.zoomeye.org/v2/search' -H "API-KEY: $YOUR_API_KEY" \
+-d '{
+  "qbase64": "dGl0bGU9ImNpc2NvIHZwbiIK",
+  "page": 1
+}'
+```
+
+### 接口请求参数
+
+|参数名称|参数类型|是否为必填项|Description|
+|---|---|---|---|
+|qbase64|string|true|Base64 编码的查询语句。更多信息，请参阅**相关参考-base64编码转换**|
+|fields|string|false|返回的字段，用逗号分隔；默认：ip, port, domain, update_time。更多信息，请参阅**接口返回字段释义**|
+|sub_type|string|false|数据类型，支持 v4、v6 和 web；默认为 v4。|
+|page|integer|false|默认为第1页，按照更新时间排序。|
+|pagesize|integer|false|每页查询数量，默认是10条，最大是10,000条/页。|
+|facets|string|false|统计项，如果有多个，用逗号分隔；支持 country、subdivisions、city、product、service、device、os 和 port。|
+|ignore_cache|boolean|false|是否忽略缓存。false，支持商业版及以上用户。|
+
+### 接口响应示例
+
+```json
+{
+  "code": 60000,
+  "message": "success",
+  "total": 163139107,
+  "query": "title=\"cisco vpn\"",
+  "data": [
+    {
+      "url": "https://1.1.1.1:443",
+      "ssl.jarm": "29d29d15d29d29d00029d29d29d29dea0f89a2e5fb09e4d8e099befed92cfa",
+      "ssl.ja3s": "45094d08156d110d8ee97b204143db14",
+      "iconhash_md5": "f3418a443e7d841097c714d69ec4bcb8",
+      "robots_md5": "0b5ce08db7fb8fffe4e14d05588d49d9",
+      "security_md5": "0b5ce08db7fb8fffe4e14d05588d49d9",
+      "ip": "1.1.1.1",
+      "domain": "www.google.com",
+      "hostname": "SPACEX",
+      "os": "windows",
+      "port": 443,
+      "service": "https",
+      "title": ["GoogleGoogle appsGoogle Search"],
+      "version": "1.1.0",
+      "device": "webcam",
+      "rdns": "c01031-001.cust.wallcloud.ch",
+      "product": "OpenSSD",
+      "header": "HTTP/1.1 302 Found Location: https://www.google.com/?gws_rd=ssl Cache-Control: private...",
+      "header_hash": "27f9973fe57298c3b63919259877a84d",
+      "body": "HTTP/1.1 302 Found Location: https://www.google.com/?gws_rd=ssl Cache-Control: private...",
+      "body_hash": "84a18166fde3ee7e7c974b8d1e7e21b4",
+      "banner": "SSH-2.0-OpenSSH_7.6p1 Ubuntu-4ubuntu0.3",
+      "update_time": "2024-07-03T14:34:10",
+      "header.server.name": "nginx",
+      "header.server.version": "1.8.1",
+      "continent.name": "欧洲",
+      "country.name": "德国",
+      "province.name": "黑森州",
+      "city.name": "法兰克福",
+      "lon": "118.753262",
+      "lat": "32.064838",
+      "isp.name": "aviel.ru",
+      "organization.name": "SERVISFIRST BANK",
+      "zipcode": "210003",
+      "idc": 0,
+      "honeypot": 0,
+      "asn": 4837,
+      "protocol": "tcp",
+      "ssl": "SSL Certificate Version: TLS 1.2 CipherSuit: TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256...",
+      "primary_industry": "金融",
+      "sub_industry": "银行",
+      "rank": 60
+    }
+  ]
+}
+```
+
+### 接口返回字段释义
+
+查询接口支持海量字段，如ip、port、domain、update_time等
+
+| 字段名称           | 类型    | 描述                                 | 权限             |
+| ------------------ | ------- | ------------------------------------ | ---------------- |
+| ip                 | string  | IP 地址（web 资产时不完整时使用）    | 所有用户         |
+| domain             | string  | 域名                                 | 所有用户         |
+| url                | string  | 资产的完整 URL（用于 web 资产）      | 所有用户         |
+| ssl.jarm           | string  | SSL JARM 指纹                        | 所有用户         |
+| ssl.ja3s           | string  | SSL JA3S 指纹                        | 所有用户         |
+| iconhash_md5       | string  | icon 图像的 MD5 值                   | 专业版及以上用户 |
+| robots_md5         | string  | robots.txt 文件的 MD5 值             | 商业版及以上用户 |
+| security_md5       | string  | 安全设置文件的 MD5 值                | 商业版及以上用户 |
+| hostname           | string  | 主机名信息                           | 所有用户         |
+| os                 | string  | 操作系统信息                         | 所有用户         |
+| port               | integer | 端口号                               | 所有用户         |
+| service            | string  | 提供的应用协议（例如 HTTP、SSH）     | 所有用户         |
+| title              | list    | 网页标题                             | 所有用户         |
+| version            | string  | 组件版本信息                         | 所有用户         |
+| device             | string  | 设备名称                             | 所有用户         |
+| rdns               | string  | 反向 DNS 信息                        | 所有用户         |
+| product            | string  | 产品组件信息                         | 所有用户         |
+| header             | string  | HTTP 响应头信息                      | 所有用户         |
+| header_hash        | string  | 从 HTTP 响应头计算的哈希值           | 专业版及以上用户 |
+| banner             | string  | 服务横幅信息                         | 所有用户         |
+| body               | string  | HTML 正文内容                        | 商业版及以上用户 |
+| body_hash          | string  | 从 HTML 正文计算的哈希值             | 专业版及以上用户 |
+| update_time        | string  | 资产更新时间                         | 所有用户         |
+| header.server.name | string  | HTTP 响应头中的 server 名称          | 所有用户         |
+| continent.name     | string  | 所在大洲名称                         | 所有用户         |
+| country.name       | string  | 所在国家名称                         | 所有用户         |
+| province.name      | string  | 所在省份名称                         | 所有用户         |
+| city.name          | string  | 所在城市名称                         | 所有用户         |
+| isp.name           | string  | ISP 名称                             | 所有用户         |
+| organization.name  | string  | 组织信息名称                         | 所有用户         |
+| zipcode            | integer | 邮政编码                             | 所有用户         |
+| idc                | string  | 是否为 IDC（0 表示否，1 表示是）     | 所有用户         |
+| lon                | string  | 地理位置经度                         | 所有用户         |
+| lat                | string  | 地理位置纬度                         | 所有用户         |
+| asn                | string  | 自治系统编号                         | 所有用户         |
+| protocol           | string  | 传输层协议（例如 TCP、UDP）          | 所有用户         |
+| honeypot           | integer | 是否为蜜罐（0 表示否，1 表示是）     | 所有用户         |
+| ssl                | string  | SSL x509 证书信息                    | 所有用户         |
+| primary_industry   | string  | 主行业信息                           | 商业版及以上用户 |
+| sub_industry       | string  | 子行业信息                           | 商业版及以上用户 |
+| rank               | integer | 资产重要性排名，分值越大重要性越高。 | 商业版及以上用户 |
+
+### 相关参考
+
+##### base64编码转换
+
+将查询条件转换为 base64 编码，并将其作为 qbase64 参数传递给 API。
+
+```base64
+#bash
+ echo 'title="knownsec"' | base64
+```
diff --git a/docs/README_CN.md b/docs/README_CN.md
index 4ce8217..ccd23da 100755
--- a/docs/README_CN.md
+++ b/docs/README_CN.md
@@ -1,10 +1,10 @@
 ## ZoomEye-python
 
-[English](../README.rst)｜中文文档
+[English](../README.md)｜中文文档
 
 `ZoomEye` 是一款网络空间搜索引擎，用户可以使用浏览器方式 <https://www.zoomeye.org> 搜索网络设备。
 
-`ZoomEye-python` 是一款基于 `ZoomEye API` 开发的 Python 库，提供了 `ZoomEye` 命令行模式，同时也可以作为 `SDK` 集成到其他工具中。该库可以让技术人员更便捷地**搜索**、**筛选**、**导出** `ZoomEye` 的数据。
+`ZoomEye-python` 是一款基于 `ZoomEye API` 开发的 Python 库，提供了 `ZoomEye` 命令行模式，同时也可以作为 `SDK` 集成到其他工具中。该库可以让技术人员更便捷地**搜索**、**导出** `ZoomEye` 的数据。
 
 ### 0x01 安装步骤
 可直接从 `pypi` 进行安装：
@@ -21,18 +21,16 @@
 
 ```
 $ zoomeye -h
-usage: zoomeye [-h] [-v] {info,search,init,ip,history,clear} ...
+usage: zoomeye [-h] [-v] {info,init,search,clear} ...
 
 positional arguments:
-  {info,search,init,ip,history,clear}
+  {info,init,search,clear}
     info                Show ZoomEye account info
-    search              Search the ZoomEye database
     init                Initialize the token for ZoomEye-python
-    ip                  Query IP information
-    history             Query device history
+    search              get network asset information based on query conditions.
     clear               Manually clear the cache and user information
 
-optional arguments:
+options:
   -h, --help            show this help message and exit
   -v, --version         show program's version number and exit
 
@@ -45,356 +43,113 @@ optional arguments:
 
 ```
 $ zoomeye init -apikey "01234567-acbd-00000-1111-22222222222"
-successfully initialized
-Role: developer
-Quota: 10000
+Username: your username
+Role: Professional
+Points: 800000
+Zoomeye Points: 0
 ```
 
 用户可以通过登陆 `ZoomEye` 在个人信息中(<https://www.zoomeye.org/profile>) 获取 `APIKEY`；`APIKEY` 不会过期，用户可根据需求在个人信息中进行重置。
 
 
-#### 2.查询配额
-用户可以通过 `info` 命令查询个人信息以及数据配额，如下：
+#### 2.用户信息
+用户可以通过 `info` 命令获取用户信息、订阅详细信息和当前积分情况，如下：
 
 ```
 $ zoomeye info
-user_info: {
-    "email": "",  # 用户邮箱
-    "name": "",  # 用户名
-    "nick_name": "",  # 昵称
-    "api_key": "",  # api_key
-    "role": "",  # 服务级别
-    "phone", "",  # 用户注册手机号
-    "expired_at": ""  # 服务期限
-}
-quota: {
-    "remain_free_quota": "",  # 本月剩余免费额度
-    "remain_pay_quota": "",  # 本月剩余支付额度
-    "remain_total_quota": ""  # 截止到服务日期剩余总额度
-}
+username: <username>
+email: <email>
+phone: <phone number>
+created_at: 2021-01-15
+Subscription:: {'plan': 'Professional', 'end_date': '2025-12-31', 'points': 800000, 'zoomeye_points': 0}
 ```
 
 #### 3.搜索
 搜索是 `ZoomEye-python` 最核心的功能，通过 `search` 命令进行使用。`search` 命令需要指定搜索关键词(`dork`)，下面我们进行简单的搜索：
 
 ```
-$ zoomeye search "telnet" -num 1
-ip:port       service  country  app                 banner                        
-222.*.*.*:23  telnet   Japan    Pocket CMD telnetd  \xff\xfb\x01\xff\xfb\x03\xff\x...
+$ zoomeye search "telnet" 
+search "telnet" 
+ip                            port                          domain                        update_time                   
+134.xx.xx.129                 1901                          [unknown]                     2025-02-06T15:45:20           
+134.xx.xx.138                 1901                          [unknown]                     2025-02-06T15:45:19
+......
 
-total: 1/58277850
+total: 20/9976411
 ```
 
-使用 `search` 命令和使用浏览器在 `ZoomEye` 进行搜索一样简单，在默认情况下我们显示了较为重要的 5 个字段，用户可以使用这些数据了解目标信息：
-
-	1.ip:port  ip地址和端口
-	2.service  该端口开放的服务
-	3.country  该ip地址所属国家
-	4.app      识别出的应用类型
-	5.banner   该端口的特征响应报文
+使用 `search` 命令和使用浏览器在 `ZoomEye` 进行搜索一样简单，在默认情况下我们显示了较为重要的字段，用户可以使用这些数据了解目标信息：
 
-在以上演示中，使用 `-num` 参数指定了显示的数量，除此之外，`search` 还支持以下参数(`zoomeye search -h`)，以便用户对数据进行处理，我们将在下文进行说明和演示：
+	1.ip             ip 地址
+    2.port           端口
+    3.domain         目标域名
+    4.update_time    目标扫描时间
 
-	-num     设置显示/搜索的数量，支持 all
-	-count   查询该 dork 在 ZoomEye 数据库的总量
-	-facet   查询该 dork 全量数据的分布情况
-	-stat    统计数据结果集的分布情况
-	-filter  查询数据结果集中某个字段的详情，或根据内容进行筛选
-	-save    可按照筛选条件将结果集进行导出
-	-force	 忽略本地缓存文件，直接从 ZoomEye 获取数据
-	-type    指定搜索源，host 或 web
+`search` 支持以下参数(`zoomeye search -h`)，以便用户对数据进行处理，我们将在下文进行说明和演示：
 
-#### 4.数据数量
-通过 `-num` 参数可以指定我们搜索和显示的数量，指定的数目即消耗的配额数量。而通过 `-count` 参数可以查询该 `dork` 在 ZoomEye 数据库的总量，如下：
+    -facets facets        统计项，如果有多个，用逗号分隔；支持 country、subdivisions、city、product、service、device、os 和 port。
+    -fields field=regexp  返回的字段，用逗号分隔；默认：ip, port, domain, update_time。更多信息，请参阅: https://www.zoomeye.org/doc/
+    -sub_type {v4,v6,web,all}  数据类型，支持 v4、v6 和 web；默认为 v4。
+    -page page            默认为第1页，按照更新时间排序。
+    -pagesize pagesize    每页查询数量，默认是10条，最大是10,000条/页。
+    -figure {pie,hist}    参数为数据图像化参数
+    -save                 将搜索结果保存到本地
+    -force                忽略本地缓存文件，直接从 ZoomEye 获取数据
 
-```
-$ zoomeye search "telnet" -count
-56903258
-```
 
->需要注意一点，`-num` 参数消耗的配额为 20 的整数倍，这是因为 `ZoomEye API` 单次查询的最小数量为 20 条。
-
-#### 5.数据聚合
-我们可以通过 `-facet` 和 `-stat` 进行数据的聚合统计，使用 `-facet` 可以查询该 dork 全量数据的聚合情况(由 `ZoomEye` 聚合统计后通过 `API` 获取)，而 `-stat` 可以对查询到的结果集进行聚合统计。两个命令支持的聚合字段包括：
-    
-    # host search 
-    app      按应用类型进行统计
-    device   按设备类型进行统计
-    service  按照服务类型进行统计
-    os       按照操作系统类型进行统计
-    port     按照端口进行统计
-    country  按照国家进行统计
-    city     按照城市进行统计
-    
-    # web search
-    webapp      按照 Web 应用进行统计
-    component   按照 Web 容器进行统计
-    framework   按照 Web 框架进行统计
-    server      按照 Web 服务器进行统计
-    waf         按照 Web 防火墙(WAF)进行统计
-    os          按照操作系统进行统计
-    country     按照国家进行统计
-
-使用 `-facet` 统计全量 `telnet` 设备的应用类型：
+#### 4.数据聚合
+我们可以通过 `-facets`  进行数据的聚合统计，使用 `-facets` 可以查询该 dork 全量数据的聚合情况(由 `ZoomEye` 聚合统计后通过 `API` 获取)
 
 ```
-$ zoomeye search "telnet" -facet app
-app                                count
-[unknown]                          28317914
-BusyBox telnetd                    10176313
-Linux telnetd                      3054856
-Cisco IOS telnetd                  1505802
-Huawei Home Gateway telnetd        1229112
-MikroTik router config httpd       1066947
-Huawei telnetd                     965378
-Busybox telnetd                    962470
-Netgear broadband router...        593346
-NASLite-SMB/Sveasoft Alc...        491957
-```
-
-使用 `-stat` 统计查询出来的 20 条 `telnet` 设备的应用类型：
+$ zoomeye search "telnet" -facets product -pagesize 1
+ip                            port                          domain                        update_time                   
+177.xxx.xx.142               2020                          [unknown]                     2025-02-06T15:59:49           
 
-```
-$ zoomeye search "telnet" -stat app
-app                                count               
-Cisco IOS telnetd                  7
-[unknown]                          5
-BusyBox telnetd                    4
-Linux telnetd                      3
-Pocket CMD telnetd                 1
+total: 1/9976296
+ ----------------------------------------
+ ZoomEye total data:9976296
+ -------------product Top 10-------------
+ product                            count               
+ MikroTik router config httpd       3326013             
+ [unknown]                          2421245             
+ Apache httpd                       2411293             
+ ProFTPD                            285649              
+ Pulse Secure VPN httpd             182296              
+ Samsung printer telnetd            178147              
+ Huawei telnetd                     144382              
+ Huawei switch telnetd              120421              
+ TP-LINK TL-WR841N WAP httpd        118836              
+ DVR httpd                          100068 
 ```
 
-#### 6.数据筛选
-
-使用 `-filter` 参数可以查询数据结果集中某个字段的详情，或根据内容进行筛选，该命令支持的字段包括：
-
-    # host/search
-    app          显示应用类型详情
-    version      显示版本信息详情
-    device       显示设备类型详情
-    port         显示端口信息详情
-    city         显示城市详情
-    country      显示国家详情
-    asn          显示as number详情
-    banner       显示特征响应报文详情
-    timestamp    显示数据更新时间
-    *            在包含该符号时，显示所有字段详情
-    
-    # web/search
-    app         显示应用类型详情
-    headers     HTTP 头
-    keywords    meta 属性关键词
-    title       HTTP Title 标题信息
-    site        site 搜索
-    city        显示城市详情
-    country     显示国家详情
-    webapp      Web 应用
-    component   Web 容器
-    framework   Web 框架
-    server      Web 服务
-    waf         Web 防火墙(WAF)
-    os          操作系统
-    timestamp   显示数据更新时间
-    *           在包含该符号时，显示所有字段详情
-
-
-相比较默认情况下的省略显示，所以通过 `-filter` 可以查看完整的数据，如下：
 
-```
-$ zoomeye search "telnet" -num 1 -filter banner
-ip         banner                        
-222.*.*.*  \xff\xfb\x01\xff\xfb\x03\xff\xfd\x03TELNET session now in ESTABLISHED state\r\n\r\n
-
-total: 1
-```
+#### 5.数据导出
+`-save` 参数可以对数据进行导出如下：
 
-使用 `-filter` 进行筛选时，语法为：`key1,key2,key3=value`，其中 `key3=value` 为筛选条件，而展示的内容为 `key1,key2` 例：
 ```
-$ zoomeye search telnet -num 1 -filter port,app,banner=Telnet
+$ zoomeye search "telnet" -pagesize 1 -save
+search "telnet"  -pagesize 1 -save
+ip                            port                          domain                        update_time                   
+88.xx.xxx.78                  3011                          [unknown]                     2025-02-06T16:00:53           
 
-ip                        port                          app                           
-240e:*:*:*::3             23                            LANDesk remote management     
+total: 1/9976301
+save file to telnet_1_1738829058.json successful!
 
-total: 1
 ```
 
-在上面的示例中：`banner=Telnet` 为筛选的条件，而 `port,app` 为展示的内容。如果需要展示 `banner`，筛选语句则是这样
-
-```
-$ zoomeye search telnet -num 1 -filter port,app,banner,banner=Telnet
-```
 
+#### 6. 数据图像化
 
-#### 7.数据导出
-`-save` 参数可以对数据进行导出，该参数的语法和 `-filter` 一样，并将结果按行 json 的格式保存到文件中，如下：
+`-figure` 参数为数据图像化参数，该参数提供了 `pie(饼图)` 和  `hist(柱状图)` 两种展示方式，在没有进行指定依旧显示数据，在指定  `-figure` 时，需要和 `-facets` 一起使用。饼图如下：
 
-```
-$ zoomeye search "telnet" -save banner=telnet
-save file to telnet_1_1610446755.json successful!
-
-$ cat telnet_1_1610446755.json
-{'ip': '218.223.21.91', 'banner': '\\xff\\xfb\\x01\\xff\\xfb\\x03\\xff\\xfd\\x03TELNET session now in ESTABLISHED state\\r\\n\\r\\n'}
-```
-
->如果使用 `-save` 但不带任何参数，则会将查询结果按照 `ZoomEye API` 的 json 格式保存成文件，这种方式一般用于在保留元数据的情况下进行整合数据；该文件可以作为输入通过 `cli` 再次解析处理，如 `zoomeye search "xxxxx.json"`。
-
-#### 8. 数据图像化
-
-`-figure` 参数为数据图像化参数，该参数提供了 `pie(饼图)` 和  `hist(柱状图)` 两种展示方式，在没有进行指定依旧显示数据，在指定  `-figure` 时，只会显示图形。饼图如下：
-
-![image-20210205004653480](../images/image-20210205004653480.png)
-
-![image-20210205005016399](../images/image-20210205005016399.png)
+![](./images/pie.png)
 
 柱状图如下：
 
-![image-20210205004806739](../images/image-20210205004806739.png)
+![](./images/hist.png)
 
-![image-20210205005117712](../images/image-20210205005117712.png)
-
-> 注意：仅能在 `-facet` 和 `-stat` 数据聚合的情况使用。
-
-#### 9. IP 历史数据查看
-
-`ZoomEye-python` 提供了 IP 历史设备数据查询功能，使用命令 `history [ip]` 便能查询 IP 设备历史数据，使用方式如下：
-
-```
-$zoomeye history "207.xx.xx.13" -num 1
-207.xx.xx.13
-Hostnames:                    [unknown]
-Country:                      United States
-City:                         Lake Charles
-Organization:                 fulair.com
-Lastupdated:                  2021-02-18T03:44:06
-Number of open ports:         1
-Number of historical probes:  1
-
-timestamp                  port/service               app                        raw_data                   
-2021-02-18 03:44:06        80/http                    Apache httpd               HTTP/1.0 301 Moved Permanently...
-```
 
-在默认情况下向用户较为重要的六个字段：
-
-```
-1. time		记录的时间
-2. service	开放的服务
-3. port		端口
-4. app  	Web 应用
-5. banner   原始的指纹信息 
-```
-
-使用 `zoomeye history -h`  可以查看 `history` 提供的参数。
-
-```
-$zoomeye history -h
-
-usage: zoomeye history [-h] [-filter filed=regexp] [-force] ip
-
-positional arguments:
-  ip                    search historical device IP
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -filter filed=regexp  filter data and print raw data detail. field:
-                        [time,port,service,app,raw]
-  -force                ignore the local cache and force the data to be
-                        obtained from the API
-```
-
-下面对 `-filter` 进行演示：
-
-```
-$zoomeye history "207.xx.xx.13" -filter "time=^2019-08,port,service"
-207.xx.xx.13
-Hostnames:                    [unknown]
-Country:                      United States
-City:                         Lake Charles
-Organization:                 fulair.com
-Lastupdated:                  2019-08-16T10:53:46
-Number of open ports:         3
-Number of historical probes:  3
-
-time                       port                       service                    
-2019-08-16 10:53:46        389                        ldap                       
-2019-08-08 23:32:30        22                         ssh                        
-2019-08-03 01:55:59        80                         http 
-```
-
-`-filter` 参数支持以下五个字段的筛选：
-
-```
-1.time      扫描时间
-2.port      端口信息
-3.service   开放的服务
-4.app       Web 应用
-5.banner    原始指纹信息
-6.ssl       证书信息
-7.*         在包含该符号时，显示所有字段详情
-```
-
-在展示时添加了一个 `id` 字段的展示，`id` 为序号，为了方便查看，并不能作为筛选的字段。
-
-> 注意：目前只开放了上述五个字段的筛选。   
-> 使用 `history` 命令时同样会消耗用户配额，在 `history` 命令中返回多少条数据，用户配额就相应扣除多少。例如：IP "8.8.8.8" 共有 944 条历史记录，查询一次扣除 944 的用户配额。
-
-
-#### 10.查询 IP 信息
-可以通过 `zoomeye ip` 命令查询指定 IP 的信息，例如：
-```
-$ zoomeye ip 185.*.*.57
-185.*.*.57
-Hostnames:                    [unknown]
-Isp:                          [unknown]
-Country:                      Saudi Arabia
-City:                         [unknown]
-Organization:                 [unknown]
-Lastupdated:                  2021-03-02T11:14:33
-Number of open ports:         4{2002, 9002, 123, 25}
-
-port      service        app                    banner                        
-9002      telnet                                \xff\xfb\x01\xff\xfb\x0...    
-123       ntp            ntpd                   \x16\x82\x00\x01\x05\x0...    
-2002      telnet         Pocket CMD telnetd     \xff\xfb\x01\xff\xfb\x0...    
-25        smtp           Cisco IOS NetWor...    220 10.1.10.2 Cisco Net...   
-```
-
-`zoomeye ip` 命令同样支持筛选参数 `-filter`, 语法和 `zoomeye search` 的筛选语法一致。例如：
-```
-$ zoomeye ip "185.*.*.57" -filter "app,app=ntpd"
-Hostnames:                    [unknown]
-Isp:                          [unknown]
-Country:                      Saudi Arabia
-City:                         [unknown]
-Organization:                 [unknown]
-Lastupdated:                  2021-02-17T02:15:06
-Number of open ports:         0
-Number of historical probes:  1
-
-app                        
-ntpd              
-```
-
-`filter` 参数支持的字段有:
-
-```
-    port        端口信息
-    service     运行服务
-    app         应用
-    banner      指纹信息
-```
-
-> 注意：此功能根据不同用户等级，对每个用户每天查询次数做了一定的限制。
->
-> **注册用户和开发者每天能够查询 10 次**
-> 
-> **高级用户每天可查询 20 次**
-> 
-> **VIP 用户每天可以查询 30 次**
-> 
-> 每天的次数使用完之后，24小时后刷新，即从第一次查 IP 的时间开始计算，24小时后刷新次数。
-
-
-#### 11.清理功能
+#### 7.清理功能
 用户每天都会搜索大量的数据，这样就导致缓存文件夹所占的存储空间逐渐增大；如果用户在公共服务器上使用 `ZoomEye-python` 可能会导致自己的 `API KEY` 和 `ACCESS TOKEN` 泄漏。
 为此 `ZoomEye-python` 提供了清理命令 `zoomeye clear`，清理命令可以缓存数据和用户配置进行清空。使用方式如下：
 
@@ -413,81 +168,6 @@ optional arguments:
 
 `ZoomEye-python` 在 `cli` 模式下提供了缓存机制，位于 `~/.config/zoomeye/cache` 下，尽可能的节约用户配额；用户查询过的数据集将在本地缓存 5 天，当用户查询相同的数据集时，不会消耗配额。
 
-#### 13.域名查询
-`ZoomEye-python` 提供了域名查询功能(包括关联域名查询和子域名查询功能), 使用命令 `domain [域名] [查询类型]` 便能进行域名查询，使用方式如下：
-
-```
-$ python cli.py domain baidu.com 0
-name                                                   timestamp      ip
-zszelle.baidu30a72.bf.3dtops.com                       2021-06-27     204.11.56.48
-zpvpcxa.baidu.3dtops.com                               2021-06-27     204.11.56.48
-zsrob.baidu.3dtops.com                                 2021-06-27     204.11.56.48
-zw8uch.7928.iwo7y0.baidu82.com                         2021-06-27     59.188.232.88
-zydsrdxd.baidu.3dtops.com                              2021-06-27     204.11.56.48
-zycoccz.baidu.3dtops.com                               2021-06-27     204.11.56.48
-...
-
-total: 30/79882
-```
-
-在默认情况下为用户展示较为重要的三个字段：
-```
-1. name             域名全称
-2. timestamp        建立时间戳
-3. ip               ip地址
-```
-
-使用 `zoomeye domain -h` 可以查看 `domain` 提供的参数。
-```
-$ python cli.py domain -h
-usage: zoomeye domain [-h] [-page PAGE] [-dot] q {0,1}
-
-positional arguments:
-  q           search key word(eg:baidu.com)
-  {0,1}       0: search associated domain;1: search sub domain
-
-optional arguments:
-  -h, --help  show this help message and exit
-  -page PAGE  view the page of the query result
-  -dot        generate a network map of the domain name
-```
-
-下面对 `-page` 进行演示：(不指定时默认查询第一页)
-
-```
-$ python cli.py domain baidu.com 0 -page 3
-name                                                   timestamp      ip
-zvptcfua.baidu6c7be.mm.3dtops.com                      2021-06-27     204.11.56.48
-zmukxtd.baidu65c78.iw.3dtops.com                       2021-06-27     204.11.56.48
-zhengwanghuangguanxianjinkaihu.baidu.fschangshi.com    2021-06-27     23.224.194.175
-zibo-baidu.com                                         2021-06-27     194.56.78.148
-zuwxb4.jingyan.baidu.66players.com                     2021-06-27     208.91.197.46
-zhannei.baidu.com.hypestat.com                         2021-06-27     67.212.187.108
-zrr.sjz-baidu.com                                      2021-06-27     204.11.56.48
-zp5hd1.baidu.com.ojsdi.cn                              2021-06-27     104.149.242.155
-
-...
-
-zhidao.baidu.com.39883.wxeve.cn                        2021-06-27     39.98.202.39
-zhizhao.baidu.com                                      2021-06-27     182.61.45.108
-zfamnje.baidu.3dtops.com                               2021-06-27     204.11.56.48
-zjnfza.baidu.3dtops.com                                2021-06-27     204.11.56.48
-
-total: 90/79882
-```
-
-`-dot` 参数可以生成域名和 IP 的网络图，在使用该功能的之前需要安装 `grapvhiz`，安装教程请参考 [grapvhiz](https://graphviz.org/download/) 支持在Windows/Linux/Mac上使用。`-dot` 参数会生成 `png` 格式的图片，同时保存原始 dot 语言脚本。
-
-`-dot`使用效果如下：
-
-![image-20211208112710711](../images/image-20211208112710711.png)
-
-### 0x03 演示视频
-
-[在 Windows、Mac、Linux、FreeBSD 演示视频](https://video.weibo.com/show?fid=1034:4597603044884556)
-
-[![asciicast](https://asciinema.org/a/qyDaJw9qQc7UjffD04HzMApWa.svg)](https://asciinema.org/a/qyDaJw9qQc7UjffD04HzMApWa)
-
 
 ### 0x04 使用SDK
 #### 1.初始化token
@@ -497,80 +177,31 @@ total: 90/79882
 
 ```python
 from zoomeye.sdk import ZoomEye
-
 zm = ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
 ```
 
 #### 2.SDK API
 以下是 SDK 提供的接口以及说明：
-
-	1.dork_search(dork, page=0, resource="host", facets=None)
-	  根据 dork 搜索指定页的数据
-	2.multi_page_search(dork, page=1, resource="host", facets=None)
-	  根据 dork 搜索多页数据
-	3.resources_info()
-	  获取当前用户的信息
-	4.show_count()
-	  获取当前 dork 下全部匹配结果的数量
-	5.dork_filter(keys)
-	  从搜索结果中提取指定字段的数据
-	6.get_facet()
-	  从搜索结果中获取全量数据的聚合结果
-	7.history_ip(ip)
-	  查询某个 ip 的历史数据信息
-	8.show_site_ip(data)
-	  遍历 web-search 结果集，并输出域名和ip地址
-	9.show_ip_port(data)
-	  遍历 host-search 结果集，并输出ip地址和端口
-	10.generate_dot(self, q, source=0, page=1)
-		生成以域名中心写出graphviz文件和图片
-
-#### 3.使用示例
-
-```python
-$ python3
->>> import zoomeye.sdk as zoomeye
->>> dir(zoomeye)
-['ZoomEye', 'ZoomEyeDict', '__builtins__', '__cached__', '__doc__',
-'__file__', '__loader__', '__name__', '__package__', '__spec__',
-'fields_tables_host', 'fields_tables_web', 'getpass', 'requests',
-'show_ip_port', 'show_site_ip', 'zoomeye_api_test']
->>> # Use API-KEY search dork
->>> zm = zoomeye.ZoomEye()
->>> data = zm.dork_search('apache country:cn')
->>> zoomeye.show_site_ip(data)
-213.***.***.46.rev.vo***one.pt ['46.***.***.213']
-me*****on.o****e.net.pg ['203.***.***.114']
-soft********63221110.b***c.net ['126.***.***.110']
-soft********26216022.b***c.net ['126.***.***.22']
-soft********5084068.b***c.net ['126.***.***.68']
-soft********11180040.b***c.net ['126.***.***.40']
-...
 ```
+1.userinfo()
+    获取当前用户信息
 
-#### 4.数据搜索
-如上示例，我们使用 `dork_search()` 进行搜索，我们还可以设置 `facets` 参数，以便获得该 dork 全量数据的聚合统计结果，`facets` 支持的字段请参考 **2.cli使用-4数据聚合**。示例如下：
-
-```python
->>> data = zm.dork_search('telnet', facets='app')
->>> zm.get_facet()
-{'product': [{'name': '', 'count': 28323128}, {'name': 'BusyBox telnetd', 'count': 10180912}, {'name': 'Linux telnetd', ......
+2.search(dork, qbase64='', page=1, pagesize=20, sub_type='all', fields='', facets='')
+    根据查询条件获取网络资产信息。
 ```
 
->`multi_page_search()` 同样也可以进行搜索，当需要获取大量数据时使用该函数，其中 `page` 字段表示获取多少页的数据；而 `dork_search()` 仅获取指定页的数据。
 
-#### 5.数据筛选
-在 SDK 中提供了 `dork_filter()` 函数，我们可以更加方便对数据进行筛选，提取指定的数据字段，如下：
+#### 3.使用示例
 
 ```python
->>> data = zm.dork_search("telnet")
->>> zm.dork_filter("ip,port")
-[['180.*.*.166', 5357], ['180.*.*.6', 5357], ......
-```
 
->由于通过 `web-search` 和 `host-search` 返回的字段不同，在进行过滤时需要填写正确的字段。
->`web-search` 包含的字段有：app / headers / keywords / title / ip / site / city / country
->`host-search` 包含的字段有：app / version / device / ip / port / hostname / city / country / asn / banner
+from zoomeye.sdk import ZoomEye
+>>> dir(ZoomEye)
+['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_check_header', '_request', 'search', 'userinfo']
+>>> zm = ZoomEye(api_key="01234567-acbd-00000-1111-22222222222")
+>>> zm.search('country=cn')
+{'code': 60000, 'message': 'success', 'query': 'country=cn', 'total': 823268005, 'data': [{...}], 'facets': {}}
+```
 
 
 ### 0x05 contributions
@@ -581,32 +212,19 @@ soft********11180040.b***c.net ['126.***.***.40']
 
 
 ### 0x06 issue
-**1.SDK和命令行工具的最小请求数量为 20 条**  
-由于 API 的限制导致我们的查询最小单位一次为 20 条数据，对于一个新的 dork 来讲，无论是查看总数量，还是指定只搜索 1 条数据，都将会产生 20 条的开销；当然在命令行模式下我们提供了缓存机制，对于已经搜索过的数据缓存到本地(`~/.config/zoomeye/cache`)，有效期为 5 天，可以大幅度的节省配额。
-
-**2.如何输入带有引号的 dork ？**
+**1.如何输入带有引号的 dork ？**
 
 在使用 cli 进行搜索时会遇到带有引号的 dork， 例如：`"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\"index.xhtml\""` ，在 dork 中含有引号或者多个引号时，dork 的最外层必需要使用引号进行包裹，表示一个参数整体，否则命令行参数解析会出问题。那么下面这个 dork 正确搜索方式应该是: `'"<body style=\"margin:0;padding:0\"> <p align=\"center\"> <iframe src=\"index.xhtml\""'` 。
 
 > 如果不包含空格等特殊字符引号也可以省略，即参数解析会吃掉一组引号
 
-![image-20210205131713799](../images/image-20210205131713799.png)
-
-![image-20210205131802799](../images/image-20210205131802799.png)
-
-**3. 为什么在 facet 会出现数据会不一致？**  
-下图进行 `telnet` 的全数据统计结果，第一次查询的结果是一天前由命令行工具默认发起 20 条数据的查询请求(其中包含统计结果)，并缓存至本地文件夹中；第二次查询我们设置数量为 21 条，命令行工具将读取缓存的 20 条数据，并发起新的查询请求 1 条(实际为最小单位 20 条，其中也包含统计结果)，第一次查询和第二次查询中间间隔一定的时间，这段时间间隔内由于 ZoomEye 周期性的扫描可能更新了该数据，导致出现了如上的数据不一致的情况，因此命令行工具将以新的统计结果为准。
-
-![image-20210111111035187](../images/image-20210111111035187.png?lastModify=1610354602)
+![](./images/web_search.png)
 
-**4.为什么 ZoomEye-python 和浏览器搜索同一个 dork 数据总量可能会不一样？**  
-`ZoomEye` 提供了两个搜索接口分别是 :  `/host/search` 和 `/web/search` ，在 `ZoomEye-python` 中默认只使用了 `/host/search` ，没有使用 `/web/search`。用户可以在根据自己的需要，通过指定 `type` 参数来选择搜索的方式。
+![](./images/cli_search.png)
 
-![image-20210111141028072](../images/image-20210111141028072.png?lastModify=1610354602)  
-![image-20210111141114558](../images/image-20210111141114558.png?lastModify=1610354602)
+**2.zoomeye-ai**
 
-**5.通过 info 命令获取配额信息可能和浏览器端不一致？**   
-浏览器端显示了免费额度和充值额度(<https://www.zoomeye.org/profile/record>)，而在 `ZoomEye-python` 中仅显示了免费额度的信息，我们将在后续版本修复这一问题。
+如果你是海外用户请使用 <https://github.com/zoomeye-ai/ZoomEye-python>
 
 ### 0x07 404StarLink Project
 
@@ -623,4 +241,4 @@ References:
 <https://www.zoomeye.org/doc>  
 
 knownsec 404  
-Time: 2021.01.12
+Update Time: 2025.02.06
diff --git a/images/cli_search.png b/images/cli_search.png
new file mode 100644
index 0000000..ff85832
Binary files /dev/null and b/images/cli_search.png differ
diff --git a/images/doc-api-key-zh.png b/images/doc-api-key-zh.png
new file mode 100644
index 0000000..39b5f5d
Binary files /dev/null and b/images/doc-api-key-zh.png differ
diff --git a/images/hist.png b/images/hist.png
new file mode 100644
index 0000000..2af788e
Binary files /dev/null and b/images/hist.png differ
diff --git a/images/image-20210111111035187.png b/images/image-20210111111035187.png
deleted file mode 100644
index d387d66..0000000
Binary files a/images/image-20210111111035187.png and /dev/null differ
diff --git a/images/image-20210111141028072.png b/images/image-20210111141028072.png
deleted file mode 100644
index d9008a8..0000000
Binary files a/images/image-20210111141028072.png and /dev/null differ
diff --git a/images/image-20210111141114558.png b/images/image-20210111141114558.png
deleted file mode 100644
index abfb8cc..0000000
Binary files a/images/image-20210111141114558.png and /dev/null differ
diff --git a/images/image-20210205004653480.png b/images/image-20210205004653480.png
deleted file mode 100644
index b220dff..0000000
Binary files a/images/image-20210205004653480.png and /dev/null differ
diff --git a/images/image-20210205004806739.png b/images/image-20210205004806739.png
deleted file mode 100644
index f2fadef..0000000
Binary files a/images/image-20210205004806739.png and /dev/null differ
diff --git a/images/image-20210205005016399.png b/images/image-20210205005016399.png
deleted file mode 100644
index a1db565..0000000
Binary files a/images/image-20210205005016399.png and /dev/null differ
diff --git a/images/image-20210205005117712.png b/images/image-20210205005117712.png
deleted file mode 100644
index 34263e5..0000000
Binary files a/images/image-20210205005117712.png and /dev/null differ
diff --git a/images/image-20210205131713799.png b/images/image-20210205131713799.png
deleted file mode 100644
index a62c6ec..0000000
Binary files a/images/image-20210205131713799.png and /dev/null differ
diff --git a/images/image-20210205131802799.png b/images/image-20210205131802799.png
deleted file mode 100644
index ee16f02..0000000
Binary files a/images/image-20210205131802799.png and /dev/null differ
diff --git a/images/image-20211208112710711.png b/images/image-20211208112710711.png
deleted file mode 100644
index 5e0fd0d..0000000
Binary files a/images/image-20211208112710711.png and /dev/null differ
diff --git a/images/pie.png b/images/pie.png
new file mode 100644
index 0000000..4c323a4
Binary files /dev/null and b/images/pie.png differ
diff --git a/images/web_search.png b/images/web_search.png
new file mode 100644
index 0000000..6372636
Binary files /dev/null and b/images/web_search.png differ
diff --git a/images/yMvlV76xyVuwjuiTJtRPKrHS2.svg b/images/yMvlV76xyVuwjuiTJtRPKrHS2.svg
deleted file mode 100644
index 1df30ef..0000000
--- a/images/yMvlV76xyVuwjuiTJtRPKrHS2.svg
+++ /dev/null
@@ -1,395 +0,0 @@
-<?xml version="1.0"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="1104.766666623" height="627.1999999999999" font-family="Consolas, Menlo, 'Bitstream Vera Sans Mono', monospace, 'Powerline Symbols'" font-size="14px">
-<style>
-<!-- asciinema theme -->
-
-.default-text-fill {fill: #cccccc}
-.default-bg-fill {fill: #121314}
-
-.c-0 {fill: #000000}
-.c-1 {fill: #dd3c69}
-.c-2 {fill: #4ebf22}
-.c-3 {fill: #ddaf3c}
-.c-4 {fill: #26b0d7}
-.c-5 {fill: #b954e1}
-.c-6 {fill: #54e1b9}
-.c-7 {fill: #d9d9d9}
-.c-8 {fill: #4d4d4d}
-.c-9 {fill: #dd3c69}
-.c-10 {fill: #4ebf22}
-.c-11 {fill: #ddaf3c}
-.c-12 {fill: #26b0d7}
-.c-13 {fill: #b954e1}
-.c-14 {fill: #54e1b9}
-.c-15 {fill: #ffffff}
-.c-8, .c-9, .c-10, .c-11, .c-12, .c-13, .c-14, .c-15 {font-weight: bold}
-
-<!-- 256 colors -->
-
-.c-16 {fill: #000000}
-.c-17 {fill: #00005f}
-.c-18 {fill: #000087}
-.c-19 {fill: #0000af}
-.c-20 {fill: #0000d7}
-.c-21 {fill: #0000ff}
-.c-22 {fill: #005f00}
-.c-23 {fill: #005f5f}
-.c-24 {fill: #005f87}
-.c-25 {fill: #005faf}
-.c-26 {fill: #005fd7}
-.c-27 {fill: #005fff}
-.c-28 {fill: #008700}
-.c-29 {fill: #00875f}
-.c-30 {fill: #008787}
-.c-31 {fill: #0087af}
-.c-32 {fill: #0087d7}
-.c-33 {fill: #0087ff}
-.c-34 {fill: #00af00}
-.c-35 {fill: #00af5f}
-.c-36 {fill: #00af87}
-.c-37 {fill: #00afaf}
-.c-38 {fill: #00afd7}
-.c-39 {fill: #00afff}
-.c-40 {fill: #00d700}
-.c-41 {fill: #00d75f}
-.c-42 {fill: #00d787}
-.c-43 {fill: #00d7af}
-.c-44 {fill: #00d7d7}
-.c-45 {fill: #00d7ff}
-.c-46 {fill: #00ff00}
-.c-47 {fill: #00ff5f}
-.c-48 {fill: #00ff87}
-.c-49 {fill: #00ffaf}
-.c-50 {fill: #00ffd7}
-.c-51 {fill: #00ffff}
-.c-52 {fill: #5f0000}
-.c-53 {fill: #5f005f}
-.c-54 {fill: #5f0087}
-.c-55 {fill: #5f00af}
-.c-56 {fill: #5f00d7}
-.c-57 {fill: #5f00ff}
-.c-58 {fill: #5f5f00}
-.c-59 {fill: #5f5f5f}
-.c-60 {fill: #5f5f87}
-.c-61 {fill: #5f5faf}
-.c-62 {fill: #5f5fd7}
-.c-63 {fill: #5f5fff}
-.c-64 {fill: #5f8700}
-.c-65 {fill: #5f875f}
-.c-66 {fill: #5f8787}
-.c-67 {fill: #5f87af}
-.c-68 {fill: #5f87d7}
-.c-69 {fill: #5f87ff}
-.c-70 {fill: #5faf00}
-.c-71 {fill: #5faf5f}
-.c-72 {fill: #5faf87}
-.c-73 {fill: #5fafaf}
-.c-74 {fill: #5fafd7}
-.c-75 {fill: #5fafff}
-.c-76 {fill: #5fd700}
-.c-77 {fill: #5fd75f}
-.c-78 {fill: #5fd787}
-.c-79 {fill: #5fd7af}
-.c-80 {fill: #5fd7d7}
-.c-81 {fill: #5fd7ff}
-.c-82 {fill: #5fff00}
-.c-83 {fill: #5fff5f}
-.c-84 {fill: #5fff87}
-.c-85 {fill: #5fffaf}
-.c-86 {fill: #5fffd7}
-.c-87 {fill: #5fffff}
-.c-88 {fill: #870000}
-.c-89 {fill: #87005f}
-.c-90 {fill: #870087}
-.c-91 {fill: #8700af}
-.c-92 {fill: #8700d7}
-.c-93 {fill: #8700ff}
-.c-94 {fill: #875f00}
-.c-95 {fill: #875f5f}
-.c-96 {fill: #875f87}
-.c-97 {fill: #875faf}
-.c-98 {fill: #875fd7}
-.c-99 {fill: #875fff}
-.c-100 {fill: #878700}
-.c-101 {fill: #87875f}
-.c-102 {fill: #878787}
-.c-103 {fill: #8787af}
-.c-104 {fill: #8787d7}
-.c-105 {fill: #8787ff}
-.c-106 {fill: #87af00}
-.c-107 {fill: #87af5f}
-.c-108 {fill: #87af87}
-.c-109 {fill: #87afaf}
-.c-110 {fill: #87afd7}
-.c-111 {fill: #87afff}
-.c-112 {fill: #87d700}
-.c-113 {fill: #87d75f}
-.c-114 {fill: #87d787}
-.c-115 {fill: #87d7af}
-.c-116 {fill: #87d7d7}
-.c-117 {fill: #87d7ff}
-.c-118 {fill: #87ff00}
-.c-119 {fill: #87ff5f}
-.c-120 {fill: #87ff87}
-.c-121 {fill: #87ffaf}
-.c-122 {fill: #87ffd7}
-.c-123 {fill: #87ffff}
-.c-124 {fill: #af0000}
-.c-125 {fill: #af005f}
-.c-126 {fill: #af0087}
-.c-127 {fill: #af00af}
-.c-128 {fill: #af00d7}
-.c-129 {fill: #af00ff}
-.c-130 {fill: #af5f00}
-.c-131 {fill: #af5f5f}
-.c-132 {fill: #af5f87}
-.c-133 {fill: #af5faf}
-.c-134 {fill: #af5fd7}
-.c-135 {fill: #af5fff}
-.c-136 {fill: #af8700}
-.c-137 {fill: #af875f}
-.c-138 {fill: #af8787}
-.c-139 {fill: #af87af}
-.c-140 {fill: #af87d7}
-.c-141 {fill: #af87ff}
-.c-142 {fill: #afaf00}
-.c-143 {fill: #afaf5f}
-.c-144 {fill: #afaf87}
-.c-145 {fill: #afafaf}
-.c-146 {fill: #afafd7}
-.c-147 {fill: #afafff}
-.c-148 {fill: #afd700}
-.c-149 {fill: #afd75f}
-.c-150 {fill: #afd787}
-.c-151 {fill: #afd7af}
-.c-152 {fill: #afd7d7}
-.c-153 {fill: #afd7ff}
-.c-154 {fill: #afff00}
-.c-155 {fill: #afff5f}
-.c-156 {fill: #afff87}
-.c-157 {fill: #afffaf}
-.c-158 {fill: #afffd7}
-.c-159 {fill: #afffff}
-.c-160 {fill: #d70000}
-.c-161 {fill: #d7005f}
-.c-162 {fill: #d70087}
-.c-163 {fill: #d700af}
-.c-164 {fill: #d700d7}
-.c-165 {fill: #d700ff}
-.c-166 {fill: #d75f00}
-.c-167 {fill: #d75f5f}
-.c-168 {fill: #d75f87}
-.c-169 {fill: #d75faf}
-.c-170 {fill: #d75fd7}
-.c-171 {fill: #d75fff}
-.c-172 {fill: #d78700}
-.c-173 {fill: #d7875f}
-.c-174 {fill: #d78787}
-.c-175 {fill: #d787af}
-.c-176 {fill: #d787d7}
-.c-177 {fill: #d787ff}
-.c-178 {fill: #d7af00}
-.c-179 {fill: #d7af5f}
-.c-180 {fill: #d7af87}
-.c-181 {fill: #d7afaf}
-.c-182 {fill: #d7afd7}
-.c-183 {fill: #d7afff}
-.c-184 {fill: #d7d700}
-.c-185 {fill: #d7d75f}
-.c-186 {fill: #d7d787}
-.c-187 {fill: #d7d7af}
-.c-188 {fill: #d7d7d7}
-.c-189 {fill: #d7d7ff}
-.c-190 {fill: #d7ff00}
-.c-191 {fill: #d7ff5f}
-.c-192 {fill: #d7ff87}
-.c-193 {fill: #d7ffaf}
-.c-194 {fill: #d7ffd7}
-.c-195 {fill: #d7ffff}
-.c-196 {fill: #ff0000}
-.c-197 {fill: #ff005f}
-.c-198 {fill: #ff0087}
-.c-199 {fill: #ff00af}
-.c-200 {fill: #ff00d7}
-.c-201 {fill: #ff00ff}
-.c-202 {fill: #ff5f00}
-.c-203 {fill: #ff5f5f}
-.c-204 {fill: #ff5f87}
-.c-205 {fill: #ff5faf}
-.c-206 {fill: #ff5fd7}
-.c-207 {fill: #ff5fff}
-.c-208 {fill: #ff8700}
-.c-209 {fill: #ff875f}
-.c-210 {fill: #ff8787}
-.c-211 {fill: #ff87af}
-.c-212 {fill: #ff87d7}
-.c-213 {fill: #ff87ff}
-.c-214 {fill: #ffaf00}
-.c-215 {fill: #ffaf5f}
-.c-216 {fill: #ffaf87}
-.c-217 {fill: #ffafaf}
-.c-218 {fill: #ffafd7}
-.c-219 {fill: #ffafff}
-.c-220 {fill: #ffd700}
-.c-221 {fill: #ffd75f}
-.c-222 {fill: #ffd787}
-.c-223 {fill: #ffd7af}
-.c-224 {fill: #ffd7d7}
-.c-225 {fill: #ffd7ff}
-.c-226 {fill: #ffff00}
-.c-227 {fill: #ffff5f}
-.c-228 {fill: #ffff87}
-.c-229 {fill: #ffffaf}
-.c-230 {fill: #ffffd7}
-.c-231 {fill: #ffffff}
-.c-232 {fill: #080808}
-.c-233 {fill: #121212}
-.c-234 {fill: #1c1c1c}
-.c-235 {fill: #262626}
-.c-236 {fill: #303030}
-.c-237 {fill: #3a3a3a}
-.c-238 {fill: #444444}
-.c-239 {fill: #4e4e4e}
-.c-240 {fill: #585858}
-.c-241 {fill: #626262}
-.c-242 {fill: #6c6c6c}
-.c-243 {fill: #767676}
-.c-244 {fill: #808080}
-.c-245 {fill: #8a8a8a}
-.c-246 {fill: #949494}
-.c-247 {fill: #9e9e9e}
-.c-248 {fill: #a8a8a8}
-.c-249 {fill: #b2b2b2}
-.c-250 {fill: #bcbcbc}
-.c-251 {fill: #c6c6c6}
-.c-252 {fill: #d0d0d0}
-.c-253 {fill: #dadada}
-.c-254 {fill: #e4e4e4}
-.c-255 {fill: #eeeeee}
-
-.br { font-weight: bold }
-.it { font-style: italic }
-.un { text-decoration: underline }
-</style>
-
-<rect width="100%" height="100%" class="default-bg-fill" rx="4" ry="4" />
-
-<svg x="0.763%" y="1.563%" class="default-text-fill">
-<g style="shape-rendering: optimizeSpeed">
-<rect x="69.466%" y="93.750%" width="0.763%" height="19.7" class="c-7" />
-</g>
-
-<text class="default-text-fill">
-<tspan y="0.000%">
-<tspan dy="1em" x="0.000%" class="c-7">L</tspan><tspan x="0.763%" class="c-7">i</tspan><tspan x="1.527%" class="c-7">n</tspan><tspan x="2.290%" class="c-7">u</tspan><tspan x="3.053%" class="c-7">x</tspan><tspan x="4.580%" class="c-7">t</tspan><tspan x="5.344%" class="c-7">e</tspan><tspan x="6.107%" class="c-7">l</tspan><tspan x="6.870%" class="c-7">n</tspan><tspan x="7.634%" class="c-7">e</tspan><tspan x="8.397%" class="c-7">t</tspan><tspan x="9.160%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">3</tspan><tspan x="27.481%" class="c-7">0</tspan><tspan x="28.244%" class="c-7">5</tspan><tspan x="29.008%" class="c-7">4</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">5</tspan><tspan x="31.298%" class="c-7">6</tspan>
-</tspan>
-<tspan y="3.125%">
-<tspan dy="1em" x="0.000%" class="c-7">C</tspan><tspan x="0.763%" class="c-7">i</tspan><tspan x="1.527%" class="c-7">s</tspan><tspan x="2.290%" class="c-7">c</tspan><tspan x="3.053%" class="c-7">o</tspan><tspan x="4.580%" class="c-7">I</tspan><tspan x="5.344%" class="c-7">O</tspan><tspan x="6.107%" class="c-7">S</tspan><tspan x="7.634%" class="c-7">t</tspan><tspan x="8.397%" class="c-7">e</tspan><tspan x="9.160%" class="c-7">l</tspan><tspan x="9.924%" class="c-7">n</tspan><tspan x="10.687%" class="c-7">e</tspan><tspan x="11.450%" class="c-7">t</tspan><tspan x="12.214%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">5</tspan><tspan x="28.244%" class="c-7">0</tspan><tspan x="29.008%" class="c-7">5</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">0</tspan><tspan x="31.298%" class="c-7">2</tspan>
-</tspan>
-<tspan y="6.250%">
-<tspan dy="1em" x="0.000%" class="c-7">H</tspan><tspan x="0.763%" class="c-7">u</tspan><tspan x="1.527%" class="c-7">a</tspan><tspan x="2.290%" class="c-7">w</tspan><tspan x="3.053%" class="c-7">e</tspan><tspan x="3.817%" class="c-7">i</tspan><tspan x="5.344%" class="c-7">H</tspan><tspan x="6.107%" class="c-7">o</tspan><tspan x="6.870%" class="c-7">m</tspan><tspan x="7.634%" class="c-7">e</tspan><tspan x="9.160%" class="c-7">G</tspan><tspan x="9.924%" class="c-7">a</tspan><tspan x="10.687%" class="c-7">t</tspan><tspan x="11.450%" class="c-7">e</tspan><tspan x="12.214%" class="c-7">w</tspan><tspan x="12.977%" class="c-7">a</tspan><tspan x="13.740%" class="c-7">y</tspan><tspan x="15.267%" class="c-7">t</tspan><tspan x="16.031%" class="c-7">e</tspan><tspan x="16.794%" class="c-7">l</tspan><tspan x="17.557%" class="c-7">n</tspan><tspan x="18.321%" class="c-7">e</tspan><tspan x="19.084%" class="c-7">t</tspan><tspan x="19.847%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">2</tspan><tspan x="28.244%" class="c-7">2</tspan><tspan x="29.008%" class="c-7">9</tspan><tspan x="29.771%" class="c-7">1</tspan><tspan x="30.534%" class="c-7">1</tspan><tspan x="31.298%" class="c-7">2</tspan>
-</tspan>
-<tspan y="9.375%">
-<tspan dy="1em" x="0.000%" class="c-7">M</tspan><tspan x="0.763%" class="c-7">i</tspan><tspan x="1.527%" class="c-7">k</tspan><tspan x="2.290%" class="c-7">r</tspan><tspan x="3.053%" class="c-7">o</tspan><tspan x="3.817%" class="c-7">T</tspan><tspan x="4.580%" class="c-7">i</tspan><tspan x="5.344%" class="c-7">k</tspan><tspan x="6.870%" class="c-7">r</tspan><tspan x="7.634%" class="c-7">o</tspan><tspan x="8.397%" class="c-7">u</tspan><tspan x="9.160%" class="c-7">t</tspan><tspan x="9.924%" class="c-7">e</tspan><tspan x="10.687%" class="c-7">r</tspan><tspan x="12.214%" class="c-7">c</tspan><tspan x="12.977%" class="c-7">o</tspan><tspan x="13.740%" class="c-7">n</tspan><tspan x="14.504%" class="c-7">f</tspan><tspan x="15.267%" class="c-7">i</tspan><tspan x="16.031%" class="c-7">g</tspan><tspan x="17.557%" class="c-7">h</tspan><tspan x="18.321%" class="c-7">t</tspan><tspan x="19.084%" class="c-7">t</tspan><tspan x="19.847%" class="c-7">p</tspan><tspan x="20.611%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">0</tspan><tspan x="28.244%" class="c-7">6</tspan><tspan x="29.008%" class="c-7">6</tspan><tspan x="29.771%" class="c-7">9</tspan><tspan x="30.534%" class="c-7">4</tspan><tspan x="31.298%" class="c-7">7</tspan>
-</tspan>
-<tspan y="12.500%">
-<tspan dy="1em" x="0.000%" class="c-7">H</tspan><tspan x="0.763%" class="c-7">u</tspan><tspan x="1.527%" class="c-7">a</tspan><tspan x="2.290%" class="c-7">w</tspan><tspan x="3.053%" class="c-7">e</tspan><tspan x="3.817%" class="c-7">i</tspan><tspan x="5.344%" class="c-7">t</tspan><tspan x="6.107%" class="c-7">e</tspan><tspan x="6.870%" class="c-7">l</tspan><tspan x="7.634%" class="c-7">n</tspan><tspan x="8.397%" class="c-7">e</tspan><tspan x="9.160%" class="c-7">t</tspan><tspan x="9.924%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">9</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">5</tspan><tspan x="29.008%" class="c-7">3</tspan><tspan x="29.771%" class="c-7">7</tspan><tspan x="30.534%" class="c-7">8</tspan>
-</tspan>
-<tspan y="15.625%">
-<tspan dy="1em" x="0.000%" class="c-7">B</tspan><tspan x="0.763%" class="c-7">u</tspan><tspan x="1.527%" class="c-7">s</tspan><tspan x="2.290%" class="c-7">y</tspan><tspan x="3.053%" class="c-7">b</tspan><tspan x="3.817%" class="c-7">o</tspan><tspan x="4.580%" class="c-7">x</tspan><tspan x="6.107%" class="c-7">t</tspan><tspan x="6.870%" class="c-7">e</tspan><tspan x="7.634%" class="c-7">l</tspan><tspan x="8.397%" class="c-7">n</tspan><tspan x="9.160%" class="c-7">e</tspan><tspan x="9.924%" class="c-7">t</tspan><tspan x="10.687%" class="c-7">d</tspan><tspan x="26.718%" class="c-7">9</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">2</tspan><tspan x="29.008%" class="c-7">4</tspan><tspan x="29.771%" class="c-7">7</tspan><tspan x="30.534%" class="c-7">0</tspan>
-</tspan>
-<tspan y="18.750%">
-<tspan dy="1em" x="0.000%" class="c-7">N</tspan><tspan x="0.763%" class="c-7">e</tspan><tspan x="1.527%" class="c-7">t</tspan><tspan x="2.290%" class="c-7">g</tspan><tspan x="3.053%" class="c-7">e</tspan><tspan x="3.817%" class="c-7">a</tspan><tspan x="4.580%" class="c-7">r</tspan><tspan x="6.107%" class="c-7">b</tspan><tspan x="6.870%" class="c-7">r</tspan><tspan x="7.634%" class="c-7">o</tspan><tspan x="8.397%" class="c-7">a</tspan><tspan x="9.160%" class="c-7">d</tspan><tspan x="9.924%" class="c-7">b</tspan><tspan x="10.687%" class="c-7">a</tspan><tspan x="11.450%" class="c-7">n</tspan><tspan x="12.214%" class="c-7">d</tspan><tspan x="13.740%" class="c-7">r</tspan><tspan x="14.504%" class="c-7">o</tspan><tspan x="15.267%" class="c-7">u</tspan><tspan x="16.031%" class="c-7">t</tspan><tspan x="16.794%" class="c-7">e</tspan><tspan x="17.557%" class="c-7">r</tspan><tspan x="19.084%" class="c-7">o</tspan><tspan x="19.847%" class="c-7">r</tspan><tspan x="21.374%" class="c-7">Z</tspan><tspan x="22.137%" class="c-7">y</tspan><tspan x="22.901%" class="c-7">X</tspan><tspan x="23.664%" class="c-7">e</tspan><tspan x="24.427%" class="c-7">l</tspan><tspan x="25.954%" class="c-7">V</tspan><tspan x="26.718%" class="c-7">o</tspan><tspan x="27.481%" class="c-7">I</tspan><tspan x="28.244%" class="c-7">P</tspan><tspan x="29.771%" class="c-7">a</tspan><tspan x="30.534%" class="c-7">d</tspan><tspan x="31.298%" class="c-7">a</tspan><tspan x="32.061%" class="c-7">p</tspan><tspan x="32.824%" class="c-7">t</tspan><tspan x="33.588%" class="c-7">e</tspan><tspan x="34.351%" class="c-7">r</tspan><tspan x="35.878%" class="c-7">t</tspan><tspan x="36.641%" class="c-7">e</tspan><tspan x="37.405%" class="c-7">l</tspan><tspan x="38.168%" class="c-7">n</tspan><tspan x="38.931%" class="c-7">e</tspan><tspan x="39.695%" class="c-7">t</tspan><tspan x="40.458%" class="c-7">d</tspan><tspan x="41.221%" class="c-7">5</tspan><tspan x="41.985%" class="c-7">9</tspan><tspan x="42.748%" class="c-7">3</tspan><tspan x="43.511%" class="c-7">3</tspan><tspan x="44.275%" class="c-7">4</tspan><tspan x="45.038%" class="c-7">6</tspan>
-</tspan>
-<tspan y="21.875%">
-<tspan dy="1em" x="0.000%" class="c-7">N</tspan><tspan x="0.763%" class="c-7">A</tspan><tspan x="1.527%" class="c-7">S</tspan><tspan x="2.290%" class="c-7">L</tspan><tspan x="3.053%" class="c-7">i</tspan><tspan x="3.817%" class="c-7">t</tspan><tspan x="4.580%" class="c-7">e</tspan><tspan x="5.344%" class="c-7">-</tspan><tspan x="6.107%" class="c-7">S</tspan><tspan x="6.870%" class="c-7">M</tspan><tspan x="7.634%" class="c-7">B</tspan><tspan x="8.397%" class="c-7">/</tspan><tspan x="9.160%" class="c-7">S</tspan><tspan x="9.924%" class="c-7">v</tspan><tspan x="10.687%" class="c-7">e</tspan><tspan x="11.450%" class="c-7">a</tspan><tspan x="12.214%" class="c-7">s</tspan><tspan x="12.977%" class="c-7">o</tspan><tspan x="13.740%" class="c-7">f</tspan><tspan x="14.504%" class="c-7">t</tspan><tspan x="16.031%" class="c-7">A</tspan><tspan x="16.794%" class="c-7">l</tspan><tspan x="17.557%" class="c-7">c</tspan><tspan x="18.321%" class="c-7">h</tspan><tspan x="19.084%" class="c-7">e</tspan><tspan x="19.847%" class="c-7">m</tspan><tspan x="20.611%" class="c-7">y</tspan><tspan x="22.137%" class="c-7">f</tspan><tspan x="22.901%" class="c-7">i</tspan><tspan x="23.664%" class="c-7">r</tspan><tspan x="24.427%" class="c-7">m</tspan><tspan x="25.191%" class="c-7">w</tspan><tspan x="25.954%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">r</tspan><tspan x="27.481%" class="c-7">e</tspan><tspan x="29.008%" class="c-7">t</tspan><tspan x="29.771%" class="c-7">e</tspan><tspan x="30.534%" class="c-7">l</tspan><tspan x="31.298%" class="c-7">n</tspan><tspan x="32.061%" class="c-7">e</tspan><tspan x="32.824%" class="c-7">t</tspan><tspan x="33.588%" class="c-7">d</tspan><tspan x="34.351%" class="c-7">4</tspan><tspan x="35.115%" class="c-7">9</tspan><tspan x="35.878%" class="c-7">1</tspan><tspan x="36.641%" class="c-7">9</tspan><tspan x="37.405%" class="c-7">5</tspan><tspan x="38.168%" class="c-7">7</tspan>
-</tspan>
-<tspan y="25.000%">
-<tspan dy="1em" x="0.000%" class="c-2">p</tspan><tspan x="0.763%" class="c-2">o</tspan><tspan x="1.527%" class="c-2">r</tspan><tspan x="2.290%" class="c-2">t</tspan><tspan x="26.718%" class="c-2">c</tspan><tspan x="27.481%" class="c-2">o</tspan><tspan x="28.244%" class="c-2">u</tspan><tspan x="29.008%" class="c-2">n</tspan><tspan x="29.771%" class="c-2">t</tspan>
-</tspan>
-<tspan y="28.125%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">3</tspan><tspan x="26.718%" class="c-7">4</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">2</tspan><tspan x="29.008%" class="c-7">5</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">5</tspan><tspan x="31.298%" class="c-7">4</tspan><tspan x="32.061%" class="c-7">6</tspan>
-</tspan>
-<tspan y="31.250%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">6</tspan><tspan x="1.527%" class="c-7">0</tspan><tspan x="2.290%" class="c-7">0</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">5</tspan><tspan x="28.244%" class="c-7">0</tspan><tspan x="29.008%" class="c-7">6</tspan><tspan x="29.771%" class="c-7">7</tspan><tspan x="30.534%" class="c-7">8</tspan><tspan x="31.298%" class="c-7">5</tspan>
-</tspan>
-<tspan y="34.375%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">3</tspan><tspan x="1.527%" class="c-7">2</tspan><tspan x="2.290%" class="c-7">3</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">1</tspan><tspan x="28.244%" class="c-7">1</tspan><tspan x="29.008%" class="c-7">0</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">2</tspan><tspan x="31.298%" class="c-7">9</tspan>
-</tspan>
-<tspan y="37.500%">
-<tspan dy="1em" x="0.000%" class="c-7">8</tspan><tspan x="0.763%" class="c-7">0</tspan><tspan x="26.718%" class="c-7">7</tspan><tspan x="27.481%" class="c-7">9</tspan><tspan x="28.244%" class="c-7">5</tspan><tspan x="29.008%" class="c-7">4</tspan><tspan x="29.771%" class="c-7">6</tspan><tspan x="30.534%" class="c-7">9</tspan>
-</tspan>
-<tspan y="40.625%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">0</tspan><tspan x="1.527%" class="c-7">0</tspan><tspan x="2.290%" class="c-7">2</tspan><tspan x="26.718%" class="c-7">5</tspan><tspan x="27.481%" class="c-7">0</tspan><tspan x="28.244%" class="c-7">4</tspan><tspan x="29.008%" class="c-7">9</tspan><tspan x="29.771%" class="c-7">2</tspan><tspan x="30.534%" class="c-7">9</tspan>
-</tspan>
-<tspan y="43.750%">
-<tspan dy="1em" x="0.000%" class="c-7">9</tspan><tspan x="0.763%" class="c-7">0</tspan><tspan x="1.527%" class="c-7">0</tspan><tspan x="2.290%" class="c-7">2</tspan><tspan x="26.718%" class="c-7">4</tspan><tspan x="27.481%" class="c-7">7</tspan><tspan x="28.244%" class="c-7">3</tspan><tspan x="29.008%" class="c-7">7</tspan><tspan x="29.771%" class="c-7">9</tspan><tspan x="30.534%" class="c-7">2</tspan>
-</tspan>
-<tspan y="46.875%">
-<tspan dy="1em" x="0.000%" class="c-7">8</tspan><tspan x="0.763%" class="c-7">0</tspan><tspan x="1.527%" class="c-7">8</tspan><tspan x="2.290%" class="c-7">1</tspan><tspan x="26.718%" class="c-7">4</tspan><tspan x="27.481%" class="c-7">2</tspan><tspan x="28.244%" class="c-7">8</tspan><tspan x="29.008%" class="c-7">0</tspan><tspan x="29.771%" class="c-7">5</tspan><tspan x="30.534%" class="c-7">3</tspan>
-</tspan>
-<tspan y="50.000%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">3</tspan><tspan x="1.527%" class="c-7">0</tspan><tspan x="2.290%" class="c-7">2</tspan><tspan x="3.053%" class="c-7">3</tspan><tspan x="26.718%" class="c-7">2</tspan><tspan x="27.481%" class="c-7">7</tspan><tspan x="28.244%" class="c-7">7</tspan><tspan x="29.008%" class="c-7">2</tspan><tspan x="29.771%" class="c-7">7</tspan><tspan x="30.534%" class="c-7">2</tspan>
-</tspan>
-<tspan y="53.125%">
-<tspan dy="1em" x="0.000%" class="c-7">2</tspan><tspan x="0.763%" class="c-7">3</tspan><tspan x="1.527%" class="c-7">3</tspan><tspan x="2.290%" class="c-7">2</tspan><tspan x="26.718%" class="c-7">2</tspan><tspan x="27.481%" class="c-7">4</tspan><tspan x="28.244%" class="c-7">0</tspan><tspan x="29.008%" class="c-7">1</tspan><tspan x="29.771%" class="c-7">3</tspan><tspan x="30.534%" class="c-7">0</tspan>
-</tspan>
-<tspan y="56.250%">
-<tspan dy="1em" x="0.000%" class="c-7">9</tspan><tspan x="0.763%" class="c-7">9</tspan><tspan x="1.527%" class="c-7">2</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">9</tspan><tspan x="28.244%" class="c-7">9</tspan><tspan x="29.008%" class="c-7">8</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">1</tspan>
-</tspan>
-<tspan y="59.375%">
-<tspan dy="1em" x="0.000%" class="c-2">c</tspan><tspan x="0.763%" class="c-2">o</tspan><tspan x="1.527%" class="c-2">u</tspan><tspan x="2.290%" class="c-2">n</tspan><tspan x="3.053%" class="c-2">t</tspan><tspan x="3.817%" class="c-2">r</tspan><tspan x="4.580%" class="c-2">y</tspan><tspan x="26.718%" class="c-2">c</tspan><tspan x="27.481%" class="c-2">o</tspan><tspan x="28.244%" class="c-2">u</tspan><tspan x="29.008%" class="c-2">n</tspan><tspan x="29.771%" class="c-2">t</tspan>
-</tspan>
-<tspan y="62.500%">
-<tspan dy="1em" x="0.000%" class="c-7">C</tspan><tspan x="0.763%" class="c-7">h</tspan><tspan x="1.527%" class="c-7">i</tspan><tspan x="2.290%" class="c-7">n</tspan><tspan x="3.053%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">9</tspan><tspan x="28.244%" class="c-7">7</tspan><tspan x="29.008%" class="c-7">0</tspan><tspan x="29.771%" class="c-7">9</tspan><tspan x="30.534%" class="c-7">2</tspan><tspan x="31.298%" class="c-7">5</tspan><tspan x="32.061%" class="c-7">9</tspan>
-</tspan>
-<tspan y="65.625%">
-<tspan dy="1em" x="0.000%" class="c-7">U</tspan><tspan x="0.763%" class="c-7">n</tspan><tspan x="1.527%" class="c-7">i</tspan><tspan x="2.290%" class="c-7">t</tspan><tspan x="3.053%" class="c-7">e</tspan><tspan x="3.817%" class="c-7">d</tspan><tspan x="5.344%" class="c-7">S</tspan><tspan x="6.107%" class="c-7">t</tspan><tspan x="6.870%" class="c-7">a</tspan><tspan x="7.634%" class="c-7">t</tspan><tspan x="8.397%" class="c-7">e</tspan><tspan x="9.160%" class="c-7">s</tspan><tspan x="26.718%" class="c-7">4</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">7</tspan><tspan x="29.008%" class="c-7">0</tspan><tspan x="29.771%" class="c-7">4</tspan><tspan x="30.534%" class="c-7">8</tspan><tspan x="31.298%" class="c-7">6</tspan>
-</tspan>
-<tspan y="68.750%">
-<tspan dy="1em" x="0.000%" class="c-7">B</tspan><tspan x="0.763%" class="c-7">r</tspan><tspan x="1.527%" class="c-7">a</tspan><tspan x="2.290%" class="c-7">z</tspan><tspan x="3.053%" class="c-7">i</tspan><tspan x="3.817%" class="c-7">l</tspan><tspan x="26.718%" class="c-7">3</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">0</tspan><tspan x="29.008%" class="c-7">3</tspan><tspan x="29.771%" class="c-7">1</tspan><tspan x="30.534%" class="c-7">8</tspan><tspan x="31.298%" class="c-7">2</tspan>
-</tspan>
-<tspan y="71.875%">
-<tspan dy="1em" x="0.000%" class="c-7">R</tspan><tspan x="0.763%" class="c-7">e</tspan><tspan x="1.527%" class="c-7">p</tspan><tspan x="2.290%" class="c-7">u</tspan><tspan x="3.053%" class="c-7">b</tspan><tspan x="3.817%" class="c-7">l</tspan><tspan x="4.580%" class="c-7">i</tspan><tspan x="5.344%" class="c-7">c</tspan><tspan x="6.870%" class="c-7">o</tspan><tspan x="7.634%" class="c-7">f</tspan><tspan x="9.160%" class="c-7">K</tspan><tspan x="9.924%" class="c-7">o</tspan><tspan x="10.687%" class="c-7">r</tspan><tspan x="11.450%" class="c-7">e</tspan><tspan x="12.214%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">2</tspan><tspan x="27.481%" class="c-7">4</tspan><tspan x="28.244%" class="c-7">8</tspan><tspan x="29.008%" class="c-7">1</tspan><tspan x="29.771%" class="c-7">0</tspan><tspan x="30.534%" class="c-7">5</tspan><tspan x="31.298%" class="c-7">2</tspan>
-</tspan>
-<tspan y="75.000%">
-<tspan dy="1em" x="0.000%" class="c-7">A</tspan><tspan x="0.763%" class="c-7">r</tspan><tspan x="1.527%" class="c-7">g</tspan><tspan x="2.290%" class="c-7">e</tspan><tspan x="3.053%" class="c-7">n</tspan><tspan x="3.817%" class="c-7">t</tspan><tspan x="4.580%" class="c-7">i</tspan><tspan x="5.344%" class="c-7">n</tspan><tspan x="6.107%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">7</tspan><tspan x="28.244%" class="c-7">0</tspan><tspan x="29.008%" class="c-7">5</tspan><tspan x="29.771%" class="c-7">7</tspan><tspan x="30.534%" class="c-7">8</tspan><tspan x="31.298%" class="c-7">9</tspan>
-</tspan>
-<tspan y="78.125%">
-<tspan dy="1em" x="0.000%" class="c-7">I</tspan><tspan x="0.763%" class="c-7">n</tspan><tspan x="1.527%" class="c-7">d</tspan><tspan x="2.290%" class="c-7">i</tspan><tspan x="3.053%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">6</tspan><tspan x="28.244%" class="c-7">4</tspan><tspan x="29.008%" class="c-7">4</tspan><tspan x="29.771%" class="c-7">0</tspan><tspan x="30.534%" class="c-7">1</tspan><tspan x="31.298%" class="c-7">1</tspan>
-</tspan>
-<tspan y="81.250%">
-<tspan dy="1em" x="0.000%" class="c-7">R</tspan><tspan x="0.763%" class="c-7">u</tspan><tspan x="1.527%" class="c-7">s</tspan><tspan x="2.290%" class="c-7">s</tspan><tspan x="3.053%" class="c-7">i</tspan><tspan x="3.817%" class="c-7">a</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">5</tspan><tspan x="28.244%" class="c-7">2</tspan><tspan x="29.008%" class="c-7">2</tspan><tspan x="29.771%" class="c-7">0</tspan><tspan x="30.534%" class="c-7">5</tspan><tspan x="31.298%" class="c-7">1</tspan>
-</tspan>
-<tspan y="84.375%">
-<tspan dy="1em" x="0.000%" class="c-7">I</tspan><tspan x="0.763%" class="c-7">t</tspan><tspan x="1.527%" class="c-7">a</tspan><tspan x="2.290%" class="c-7">l</tspan><tspan x="3.053%" class="c-7">y</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">2</tspan><tspan x="28.244%" class="c-7">9</tspan><tspan x="29.008%" class="c-7">9</tspan><tspan x="29.771%" class="c-7">3</tspan><tspan x="30.534%" class="c-7">8</tspan><tspan x="31.298%" class="c-7">3</tspan>
-</tspan>
-<tspan y="87.500%">
-<tspan dy="1em" x="0.000%" class="c-7">J</tspan><tspan x="0.763%" class="c-7">a</tspan><tspan x="1.527%" class="c-7">p</tspan><tspan x="2.290%" class="c-7">a</tspan><tspan x="3.053%" class="c-7">n</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">2</tspan><tspan x="28.244%" class="c-7">4</tspan><tspan x="29.008%" class="c-7">6</tspan><tspan x="29.771%" class="c-7">2</tspan><tspan x="30.534%" class="c-7">9</tspan><tspan x="31.298%" class="c-7">5</tspan>
-</tspan>
-<tspan y="90.625%">
-<tspan dy="1em" x="0.000%" class="c-7">M</tspan><tspan x="0.763%" class="c-7">e</tspan><tspan x="1.527%" class="c-7">x</tspan><tspan x="2.290%" class="c-7">i</tspan><tspan x="3.053%" class="c-7">c</tspan><tspan x="3.817%" class="c-7">o</tspan><tspan x="26.718%" class="c-7">1</tspan><tspan x="27.481%" class="c-7">0</tspan><tspan x="28.244%" class="c-7">6</tspan><tspan x="29.008%" class="c-7">9</tspan><tspan x="29.771%" class="c-7">8</tspan><tspan x="30.534%" class="c-7">0</tspan><tspan x="31.298%" class="c-7">8</tspan>
-</tspan>
-<tspan y="93.750%">
-<tspan dy="1em" x="0.000%" class="br c-10">➜</tspan><tspan x="2.290%" class="br c-14">Z</tspan><tspan x="3.053%" class="br c-14">o</tspan><tspan x="3.817%" class="br c-14">o</tspan><tspan x="4.580%" class="br c-14">m</tspan><tspan x="5.344%" class="br c-14">E</tspan><tspan x="6.107%" class="br c-14">y</tspan><tspan x="6.870%" class="br c-14">e</tspan><tspan x="7.634%" class="br c-14">-</tspan><tspan x="8.397%" class="br c-14">p</tspan><tspan x="9.160%" class="br c-14">y</tspan><tspan x="9.924%" class="br c-14">t</tspan><tspan x="10.687%" class="br c-14">h</tspan><tspan x="11.450%" class="br c-14">o</tspan><tspan x="12.214%" class="br c-14">n</tspan><tspan x="13.740%" class="br c-12">g</tspan><tspan x="14.504%" class="br c-12">i</tspan><tspan x="15.267%" class="br c-12">t</tspan><tspan x="16.031%" class="br c-12">:</tspan><tspan x="16.794%" class="br c-12">(</tspan><tspan x="17.557%" class="br c-9">m</tspan><tspan x="18.321%" class="br c-9">a</tspan><tspan x="19.084%" class="br c-9">s</tspan><tspan x="19.847%" class="br c-9">t</tspan><tspan x="20.611%" class="br c-9">e</tspan><tspan x="21.374%" class="br c-9">r</tspan><tspan x="22.137%" class="br c-12">)</tspan><tspan x="23.664%" class="br c-11">✗</tspan><tspan x="25.191%" class="c-2">z</tspan><tspan x="25.954%" class="c-2">o</tspan><tspan x="26.718%" class="c-2">o</tspan><tspan x="27.481%" class="c-2">m</tspan><tspan x="28.244%" class="c-2">e</tspan><tspan x="29.008%" class="c-2">y</tspan><tspan x="29.771%" class="c-2">e</tspan><tspan x="31.298%">s</tspan><tspan x="32.061%">e</tspan><tspan x="32.824%">a</tspan><tspan x="33.588%">r</tspan><tspan x="34.351%">c</tspan><tspan x="35.115%">h</tspan><tspan x="36.641%">-</tspan><tspan x="37.405%">n</tspan><tspan x="38.168%">u</tspan><tspan x="38.931%">m</tspan><tspan x="40.458%">3</tspan><tspan x="41.221%">0</tspan><tspan x="42.748%">t</tspan><tspan x="43.511%">e</tspan><tspan x="44.275%">l</tspan><tspan x="45.038%">n</tspan><tspan x="45.802%">e</tspan><tspan x="46.565%">t</tspan><tspan x="48.092%">-</tspan><tspan x="48.855%">f</tspan><tspan x="49.618%">i</tspan><tspan x="50.382%">l</tspan><tspan x="51.145%">t</tspan><tspan x="51.908%">e</tspan><tspan x="52.672%">r</tspan><tspan x="54.198%" class="c-3">&quot;</tspan><tspan x="54.962%" class="c-3">c</tspan><tspan x="55.725%" class="c-3">o</tspan><tspan x="56.489%" class="c-3">u</tspan><tspan x="57.252%" class="c-3">n</tspan><tspan x="58.015%" class="c-3">t</tspan><tspan x="58.779%" class="c-3">r</tspan><tspan x="59.542%" class="c-3">y</tspan><tspan x="60.305%" class="c-3">=</tspan><tspan x="61.069%" class="c-3">C</tspan><tspan x="61.832%" class="c-3">h</tspan><tspan x="62.595%" class="c-3">i</tspan><tspan x="63.359%" class="c-3">n</tspan><tspan x="64.122%" class="c-3">a</tspan><tspan x="64.885%" class="c-3">,</tspan><tspan x="65.649%" class="c-3">p</tspan><tspan x="66.412%" class="c-3">o</tspan><tspan x="67.176%" class="c-3">r</tspan><tspan x="67.939%" class="c-3">t</tspan><tspan x="68.702%" class="c-3">&quot;</tspan>
-</tspan>
-
-</text>
-
-<g transform="translate(-50 -50)">
-<svg x="50%" y="50%" width="100" height="100">
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 866.0254037844387 866.0254037844387">
-  <defs>
-    <mask id="small-triangle-mask">
-      <rect width="100%" height="100%" fill="white"/>
-      <polygon points="508.01270189221935 433.01270189221935, 208.0127018922194 259.8076211353316, 208.01270189221927 606.217782649107" fill="black"></polygon>
-    </mask>
-  </defs>
-  <polygon points="808.0127018922194 433.01270189221935, 58.01270189221947 -1.1368683772161603e-13, 58.01270189221913 866.0254037844386" mask="url(#small-triangle-mask)" fill="white"></polygon>
-  <polyline points="481.2177826491071 333.0127018922194, 134.80762113533166 533.0127018922194" stroke="white" stroke-width="90"></polyline>
-</svg>
-
-</svg>
-</g>
-</svg>
-</svg>
diff --git a/setup.py b/setup.py
index 14ca04c..e311c06 100644
--- a/setup.py
+++ b/setup.py
@@ -6,7 +6,7 @@
 * Filename: setup.py
 * Description:
 * Time: 2020.11.27
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 from setuptools import setup
@@ -15,16 +15,16 @@
 
 
 DEPENDENCIES = open('requirements.txt', 'r', encoding='utf-8').read().split('\n')
-README = open('README.rst', 'r', encoding='utf-8').read()
+README = open('README.md', 'r', encoding='utf-8').read()
 
 setup(
     name='zoomeye',
     version=__version__,
     description='Python library and command-line tool for ZoomEye (https://www.zoomeye.org/doc)',
     long_description=README,
-    long_description_content_type='text/x-rst',
+    long_description_content_type='text/markdown',
     author='404 Team@Knownsec',
-    url='https://github.com/knownsec/zoomeye-python',
+    url='https://github.com/knownsec/zoomeye-python',  #
     packages=['zoomeye'],
     entry_points={'console_scripts': ['zoomeye=zoomeye.cli:main']},
     install_requires=DEPENDENCIES,
@@ -41,6 +41,9 @@
         'Programming Language :: Python :: 3.7',
         'Programming Language :: Python :: 3.8',
         'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
         'Topic :: Software Development :: Libraries :: Python Modules',
     ],
 )
diff --git a/zoomeye/__init__.py b/zoomeye/__init__.py
index 44a965c..688c7be 100644
--- a/zoomeye/__init__.py
+++ b/zoomeye/__init__.py
@@ -5,11 +5,11 @@
 * Filename: __init__.py.py
 * Description:
 * Time: 2020.11.25
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 
 __name__ = 'zoomeye'
 __package__ = 'zoomeye'
-__version__ = 'v2.2.0'
+__version__ = '3.0.0'
 __site__ = "https://www.zoomeye.org/doc"
diff --git a/zoomeye/cli.py b/zoomeye/cli.py
index 9d5fe14..6b3c02c 100644
--- a/zoomeye/cli.py
+++ b/zoomeye/cli.py
@@ -5,7 +5,7 @@
 * Filename: cli.py
 * Description: cli program entry
 * Time: 2020.11.30
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 
@@ -50,96 +50,56 @@ def main():
     parser_info = subparsers.add_parser("info", help="Show ZoomEye account info")
     parser_info.set_defaults(func=core.info)
 
+    # initial account configuration related commands
+    parser_init = subparsers.add_parser("init", help="Initialize the token for ZoomEye-python")
+    parser_init.add_argument("-apikey", help="ZoomEye API Key", default=None, metavar='[api key]')
+    parser_init.set_defaults(func=core.init)
+
     # query zoomeye data
-    parser_search = subparsers.add_parser(
-        "search",
-        help="Search the ZoomEye database"
-    )
+    search_v2_parser = subparsers.add_parser("search",
+                                             help="get network asset information based on query conditions.")
+    search_v2_parser.add_argument("dork", type=str, help="search key word(eg=baidu.com)", default=None)
 
-    parser_search.add_argument(
-        "dork",
-        help="The ZoomEye search keyword or ZoomEye exported file"
-    )
-    parser_search.add_argument(
-        "-num",
-        default=20,
-        help="The number of search results that should be returned, support 'all'",
-        type=str,
-        metavar='value'
-    )
-    parser_search.add_argument(
-        "-facet",
-        default=None,
-        nargs='?',
-        const='country',
+    search_v2_parser.add_argument(
+        "-facets",
+        default='',
         type=str,
         help=('''
-            Perform statistics on ZoomEye database,
-            host field: [app,device,service,os,port,country,city]
-            web field: [webapp,component,framework,server,waf,os,country]
-        '''),
-        metavar='field'
-    )
-    parser_search.add_argument(
-        "-filter",
-        default=None,
+                  if this parameter is specified,
+                         the corresponding data will be displayed
+                         at the end of the returned result.
+                         supported : 'product', 'device', 'service', 'os', 'port', 'country', 'subdivisions', 'city'
+              '''),
+        metavar='facets'
+    )
+    search_v2_parser.add_argument(
+        "-fields",
+        default='',
         metavar='field=regexp',
-        nargs='?',
-        const='app',
-        type=str,
-        help=('''
-              Output more clearer search results by set filter field,
-              host field: [app,version,device,port,city,country,asn,banner,timestamp,*]
-              web field: [app,headers,keywords,title,site,city,country,webapp,component,framework,server,waf,os,timestamp,*]
-        ''')
-    )
-    parser_search.add_argument(
-        '-stat',
-        default=None,
-        metavar='field',
-        nargs='?',
-        const='app,device,service,os,port,country,city',
         type=str,
         help=('''
-              Perform statistics on search results,
-              host field: [app,device,service,os,port,country,city]
-              web field: [webapp,component,framework,server,waf,os,country]
-        ''')
-    )
-    parser_search.add_argument(
-        "-save",
-        default=None,
-        metavar='field=regexp',
-        help=('''
-              Save the search results with ZoomEye json format,
-              if you specify the field, it will be saved with JSON Lines
-        '''),
-        nargs='?',
-        type=str,
-        const='all'
-    )
-    parser_search.add_argument(
-        "-count",
-        help="The total number of results in ZoomEye database for a search",
-        action="store_true"
-    )
-    parser_search.add_argument(
+                   display data based on input fields
+                   please see: https://www.zoomeye.org/doc/
+              ''')
+    )
+    search_v2_parser.add_argument("-sub_type", type=str, help="specify the type of data to search",
+                                  choices=('v4', 'v6', 'web', 'all'), default='all')
+    search_v2_parser.add_argument("-page", metavar='page', type=int, help="view the page of the query result",
+                                  default=1)
+    search_v2_parser.add_argument('-pagesize', metavar='pagesize', type=int,
+                                  help="specify the number of pagesize to search", default=20)
+    search_v2_parser.add_argument(
         "-figure",
         help="Pie chart or bar chart showing data，can only be used under facet and stat",
         choices=('pie', 'hist'),
         default=None
     )
-    parser_search.add_argument(
-        "-type",
-        help=(
-            """
-            Select web search or host search(default host) 
-            """
-        ),
-        choices={'web', 'host'},
-        default="host"
+    search_v2_parser.add_argument(
+        "-save",
+        help="Save search to local file",
+        action='store_true',
     )
-    parser_search.add_argument(
+    search_v2_parser.add_argument(
         "-force",
         help=(
             """
@@ -148,54 +108,7 @@ def main():
         ),
         action="store_true"
     )
-    parser_search.set_defaults(func=core.search)
-
-    # initial account configuration related commands
-    parser_init = subparsers.add_parser("init", help="Initialize the token for ZoomEye-python")
-    parser_init.add_argument("-apikey", help="ZoomEye API Key", default=None, metavar='[api key]')
-    parser_init.set_defaults(func=core.init)
-
-    parser_ip_info = subparsers.add_parser("ip", help="Query IP information")
-    parser_ip_info.add_argument("ip", help="search device IP", metavar='ip', type=str)
-    parser_ip_info.add_argument(
-        "-filter",
-        help="output more clearer search results by set filter field,field:[port,service,app,banner,ssl]",
-        default=None,
-        metavar="key=value")
-    parser_ip_info.set_defaults(func=core.information_ip)
-
-    # query ip history
-    parser_history = subparsers.add_parser("history", help="Query device history")
-    parser_history.add_argument("ip", help="search historical device IP", metavar='ip', type=str)
-    parser_history.add_argument(
-        "-filter",
-        help=("""
-            filter data and print raw data detail.
-            field: [timestamp,port,service,country,banner,*]
-        """),
-        metavar='filed=regexp',
-        type=str,
-        default=None,
-        const="app",
-        nargs='?'
-    )
-    parser_history.add_argument(
-        "-force",
-        help=(
-            """
-            ignore the local cache and force the data to be obtained from the API
-            """
-        ),
-        action="store_true"
-    )
-    parser_history.add_argument(
-        '-num',
-        help='The number of search results that should be returned',
-        type=int,
-        default=None,
-        metavar='value'
-    )
-    parser_history.set_defaults(func=core.ip_history)
+    search_v2_parser.set_defaults(func=core.search)
 
     parser_clear = subparsers.add_parser("clear", help="Manually clear the cache and user information")
     parser_clear.add_argument(
@@ -210,14 +123,6 @@ def main():
     )
     parser_clear.set_defaults(func=core.clear_file)
 
-    parser_domain = subparsers.add_parser("domain", help="search associated domain or sub domain")
-    parser_domain.add_argument("q", type=str, help="search key word(eg:baidu.com)", default=None)
-    parser_domain.add_argument("type", type=int, help="0: search associated domain;1: search sub domain",
-                               choices=(0, 1), default=0)
-    parser_domain.add_argument("-page", type=int, help="view the page of the query result", default=1)
-    parser_domain.add_argument('-dot', help="generate a network map of the domain name", action='store_true')
-    parser_domain.set_defaults(func=core.associated_domain_query)
-
     args = parser.parse_args()
 
     if args.version:
diff --git a/zoomeye/config.py b/zoomeye/config.py
index e8bdd0d..db691b5 100644
--- a/zoomeye/config.py
+++ b/zoomeye/config.py
@@ -6,25 +6,26 @@
 * Filename: config.py
 * Description: command tool config
 * Time: 2020.11.30
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 from zoomeye import __version__, __site__
 
+seconds_of_fiveday = 60 * 60 * 24 * 5
 
-# save api key file and json web token file path
+# save api key file and json web token file path 保存API密钥文件和json web令牌文件路径
 ZOOMEYE_CONFIG_PATH = "~/.config/zoomeye/setting"
 
-# save search dork data path
+# save search dork data path 保存搜索节点数据路径
 ZOOMEYE_CACHE_PATH = "~/.config/zoomeye/cache"
 
-# cache expired time, five day
-EXPIRED_TIME = 60 * 60 * 24 * 5
+# cache expired time, five day 缓存过期时间，5天
+EXPIRED_TIME = seconds_of_fiveday
 
-# print data max length
+# print data max length 打印数据
 STRING_MAX_LENGTH = 23
 
-# cache file name
+# cache file name缓存文件名
 FILE_NAME = "/{}_{}.json"
 
 
diff --git a/zoomeye/core.py b/zoomeye/core.py
index c96472e..223bf83 100644
--- a/zoomeye/core.py
+++ b/zoomeye/core.py
@@ -2,21 +2,23 @@
 * Filename: core.py
 * Description: cli core function, processing various requests
 * Time: 2020.11.30
-* Author: liuf5
+* Author: wh0am1i
 */
 """
-
 import re
 import os
+import time
+import json
 from zoomeye import config, file, show
+from zoomeye.tools import Cache
 from zoomeye.sdk import ZoomEye
-from zoomeye.data import CliZoomEye, HistoryDevice, IPInformation, DomainSearch
 
 # save zoomeye config folder
 zoomeye_dir = os.path.expanduser(config.ZOOMEYE_CONFIG_PATH)
 
 
-def key_init(key):
+def init_key(key):
+
     """
     initialize through the api key, write the api key to the local configuration file,
     theoretically it will never expire unless you remake the api key
@@ -32,9 +34,13 @@ def key_init(key):
     # api key save path
     key_file = zoomeye_dir + "/apikey"
     # display the remaining resources of the current account
-    user_data = zoom.resources_info()
-    show.printf("Role: {}".format(user_data["plan"]))
-    show.printf("Quota: {}".format(user_data["resources"].get("search")))
+    user_data = zoom.userinfo()
+    if user_data.get("code") == 60000:
+        show.printf("Username: {}".format(user_data.get('data', {}).get('username', {})))
+        show.printf("Role: {}".format(user_data.get('data', {}).get('subscription', {}).get('plan', '')))
+        show.printf("Points: {}".format(user_data.get('data', {}).get('subscription', {}).get("points", 0)))
+        show.printf("Zoomeye Points: {}".format(user_data.get('data', {}).get('subscription', {}).
+                                                get("zoomeye_points", 0)))
     # save api key
     with open(key_file, 'w') as f:
         f.write(key)
@@ -52,93 +58,83 @@ def init(args):
     api_key = args.apikey
     # use api key init
     if api_key:
-        key_init(api_key)
+        init_key(api_key)
         return
     # invalid parameter
-    show.printf("input parameter error", color="red")
+    show.printf("input parameter error!", color="red")
     show.printf("please run <zoomeye init -h> for help.", color="red")
 
 
 def search(args):
     dork = args.dork
-    num = int(args.num)
-    facet = args.facet
-    filters = args.filter
-    stat = args.stat
-    save = args.save
-    count_total = args.count
+    page = int(args.page)
+    pagesize = int(args.pagesize)
+    facets = args.facets
+    fields = args.fields
+    sub_type = args.sub_type
     figure = args.figure
+    save = args.save
     force = args.force
-    resource = args.type
 
-    cli_zoom = CliZoomEye(dork, num, resource=resource, facet=facet, force=force)
-    if filters:
-        cli_zoom.filter_data(filters, save)
-        return
-    if facet:
-        cli_zoom.facets_data(facet, figure)
-        return
-    if count_total:
-        cli_zoom.count()
-        return
-    if stat:
-        cli_zoom.statistics(stat, figure)
-        return
-    if save:
-        cli_zoom.save(save)
-        return
-    if filters is None and facet is None and stat is None:
-        cli_zoom.default_show()
-        return
-    show.printf("please run <zoomeye search -h> for help.")
+    api_key = file.get_auth_key()
+    zm = ZoomEye(api_key=api_key)
+    cahce = Cache(dork, page=page, pagesize=pagesize, facets=facets, fields=fields, sub_type=sub_type)
+    if cahce.check() and force is False:
+        data = cahce.load()
+    else:
+        data = zm.search(dork, page=page, pagesize=pagesize, facets=facets, fields=fields, sub_type=sub_type)
+        cahce.save(data)
+
+    data_list = data.get('data', [])
+    facets_data = data.get('facets', {})
+    total = data.get('total', {})
+
+    if len(data_list) > 0:
+        keys = data_list[0].keys()
+        show.print_filter(",".join(keys), [[i.get(key) for key in keys] for i in data_list], total)
+        # save file to local file, json fire
+        if save:
+            name = re.findall(r"[a-zA-Z0-9_\u4e00-\u9fa5]+", dork)
+            re_name = '_'.join(name)
+            filename = "{}_{}_{}.json".format(re_name, pagesize, int(time.time()))
+            with open(filename, 'w') as f:
+                f.write(json.dumps(data_list))
+            show.printf("save file to {}/{} successful!".format(os.getcwd(), filename), color='green')
+
+    if facets_data:
+        show.print_facets(facets, facets_data, total, figure, {
+            'type': 'type',
+            'product': 'product',
+            'device': 'device',
+            'service': 'service',
+            'os': 'os',
+            'port': 'port',
+            'subdivisions': 'subdivisions',
+            'country': 'country',
+            'city': 'city',
+        })
+
+    # show.printf("please run <zoomeye search -h> for help.")
 
 
 def info(args):
     """
     used to print the current identity of the user and the remaining data quota for the month
-    :param args:
     :return:
     """
     api_key = file.get_auth_key()
     zm = ZoomEye(api_key=api_key)
     # get user information
-    user_data = zm.resources_info()
-    if user_data:
-        # show in the terminal
-        show.printf("Role: {}".format(user_data["plan"]))
-        show.printf("Quota: {}".format(user_data["resources"].get("search")))
-        show.printf("user_info: {}".format(user_data["user_info"]))
-        show.printf("quota_info: {}".format(user_data["quota_info"]))
-
+    user_response = zm.userinfo()
 
-def ip_history(args):
-    """
-    query device history
-    please see: https://www.zoomeye.org/doc#history-ip-search
-    :param args:
-    :return:
-    """
-    ip = args.ip
-    filters = args.filter
-    force = args.force
-    number = args.num
-    # determine whether the input is an IP address by regular
-    compile_ip = re.compile('^(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.'
-                             '(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)$')
-    # IP format error，exit program
-    if not compile_ip.match(ip):
-        show.printf("[{}] it is not an IP address, please check!".format(ip), color='red')
-        return
-
-    zm = HistoryDevice(ip, force, number)
-    # user input filter field
-    if filters:
-        filter_list = filters.split(',')
-        zm.filter_fields(filter_list)
-        return
-    # no filter field,
-    # print [timestamp,service,port,country,raw_data] fields
-    zm.show_fields()
+    if user_response and user_response.get('code') == 60000:
+        user_data = user_response.get('data')
+        # show in the terminal
+        show.printf("username: {}".format(user_data["username"]))
+        show.printf("email: {}".format(user_data["email"]))
+        show.printf("phone: {}".format(user_data["phone"]))
+        show.printf("created_at: {}".format(user_data["created_at"]))
+        show.printf("Subscription:: {}".format(user_data["subscription"]))
 
 
 def clear_file(args):
@@ -163,38 +159,3 @@ def clear_file(args):
     for item in file_list:
         os.remove(os.path.join(target_dir, item))
     show.printf("clear complete!", color='green')
-
-
-def information_ip(args):
-    ip = args.ip
-    filters = args.filter
-    # determine whether the input is an IP address by regular
-    compile_ip = re.compile('^(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|[1-9])\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.'
-                            '(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)\.(1\d{2}|2[0-4]\d|25[0-5]|[1-9]\d|\d)$')
-    # IP format error，exit program
-    if not compile_ip.match(ip):
-        show.printf("[{}] it is not an IP address, please check!".format(ip), color='red')
-        return
-
-    infor = IPInformation(ip)
-    if filters:
-        filter_list = filters.split(',')
-        infor.filter_information(filter_list)
-        return
-
-    infor.show_information()
-
-
-def associated_domain_query(args):
-    q = args.q
-    resource = args.type
-    page = args.page
-    dot = args.dot
-    if dot:
-        # generate network map
-        DomainSearch(q, resource, page).generate_dot()
-    else:
-        # show information for user
-        DomainSearch(q, resource, page).show_information()
-    return None
-
diff --git a/zoomeye/data.py b/zoomeye/data.py
deleted file mode 100644
index 5dcda3b..0000000
--- a/zoomeye/data.py
+++ /dev/null
@@ -1,777 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-
-"""
-* Filename: data.py
-* Description: used to process various data.
-* Time: 2020.11.30
-* Author: liuf5
-*/
-"""
-import re
-import json
-import os
-import time
-import datetime
-import hashlib
-from zoomeye import config, file
-from zoomeye.sdk import ZoomEye, fields_tables_host, fields_tables_web
-from zoomeye.sdk import ZoomEyeDict
-from zoomeye import show
-
-zoomeye_dir = os.path.expanduser(config.ZOOMEYE_CONFIG_PATH)
-
-stat_host_table = {
-    'app': 'portinfo.app',
-    'device': 'portinfo.device',
-    'service': 'portinfo.service',
-    'os': 'portinfo.os',
-    'port': 'portinfo.port',
-    'country': 'geoinfo.country.names.en',
-    'city': 'geoinfo.city.names.en',
-    'ssl': 'ssl'
-}
-
-stat_web_table = {
-    "webapp": "webapp",
-    "component": "component",
-    "framework": "framework",
-    "server": "server.name",
-    "waf": "waf",
-    "os": "system",
-    "country": "geoinfo.country.names.en",
-    "city": "geoinfo.city.names.en",
-}
-
-facets_table_host = {
-    'app': 'product',
-    'device': 'device',
-    'service': 'service',
-    'os': 'os',
-    'port': 'port',
-    'country': 'country',
-    'city': 'city',
-    'ssl': 'ssl'
-}
-
-facets_table_web = {
-    "webapp": "webapp",
-    "component": "component",
-    "framework": "framework",
-    "server": "server",
-    "waf": "waf",
-    "os": "os",
-    "country": "country",
-}
-
-fields_tables_history_host = {
-    "timestamp": "timestamp",
-    "port": "portinfo.port",
-    "service": "portinfo.service",
-    "app": "portinfo.product",
-    "banner": "raw_data",
-    "ssl": "ssl"
-}
-
-fields_ip = {
-    "port": "portinfo.port",
-    "service": "portinfo.service",
-    "app": "portinfo.app",
-    "banner": "portinfo.banner",
-    "ssl": "ssl"
-}
-
-tables_history_info = {
-    "Hostnames": 'portinfo.hostname',
-    'Isp': 'geoinfo.isp',
-    "Country": 'geoinfo.country.names.en',
-    "City": 'geoinfo.city.names.en',
-    "Organization": 'geoinfo.organization',
-    "LastUpdated": 'timestamp'
-}
-
-default_table_web = {
-    "site": "site",
-    "title": "title",
-    "country": "geoinfo.country.names.en",
-    "banner": "raw_data",
-}
-
-
-def md5_convert(string):
-    """
-    calculate the md5 of a string
-    :param string: input string
-    :return: md5 string
-    """
-    m = hashlib.md5()
-    m.update(string.encode('utf-8'))
-    return m.hexdigest()
-
-
-def get_host_item(data):
-    if data:
-        ip = data.get('ip')
-        country = data.get("geoinfo").get("country").get("names").get("en")
-        port = data.get("portinfo").get("port")
-        app = data.get("portinfo").get("app")
-        banner = data.get("portinfo").get("banner")
-        service = data.get("portinfo").get("service")
-        return ip, country, port, app, banner, service
-    else:
-        show.printf("data cannot be empty", color='red')
-        exit(0)
-
-
-def regexp(keys, field_table, data_list):
-    """
-    match the corresponding data through regular
-    """
-    result = []
-    for key in keys:
-        result = []
-        for da in data_list:
-            zmdict = ZoomEyeDict(da)
-            input_key, input_value = key.split("=")
-            if field_table.get(input_key.strip()) is None:
-                # check filed effectiveness
-                support_fields = ','.join(list(field_table.keys()))
-                show.printf("filter command has unsupport fields [{}], support fields has [{}]"
-                            .format(input_key, support_fields), color='red')
-                exit(0)
-            # the value obtained here is of type int, and the user's input is of type str,
-            # so it needs to be converted.
-            if input_key == "port":
-                input_value = str(input_value)
-            find_value = zmdict.find(field_table.get(input_key.strip()))
-            # get the value through regular matching
-            try:
-                regexp_result = re.search(str(input_value), str(find_value), re.I)
-            except re.error:
-                show.printf('the regular expression you entered is incorrect, please check!', color='red')
-                exit(0)
-            except Exception as e:
-                show.printf(e, color='red')
-                exit(0)
-            # the matched value is neither None nor empty
-            if regexp_result and regexp_result.group(0) != '':
-                result.append(da)
-        # AND operation
-        data_list = result
-    return result
-
-
-def filter_search_data(keys, field_table, data):
-    """
-    get the data of the corresponding field
-    :param keys: list, user input field
-    :param field_table: dict, fileds
-    :param data: list, zoomeye api data
-    :return: list, ex: [[1,2,3...],[1,2,3...],[1,2,3...]...]
-    """
-    result = []
-    for d in data:
-        item = []
-        zmdict = ZoomEyeDict(d)
-        for key in keys:
-            if field_table.get(key.strip()) is None:
-                support_fields = ','.join(list(field_table.keys()))
-                show.printf("filter command has unsupport fields [{}], support fields has [{}]"
-                            .format(key, support_fields), color='red')
-                exit(0)
-            res = zmdict.find(field_table.get(key.strip()))
-            if key == "timestamp":
-                utc_time = datetime.datetime.strptime(res, "%Y-%m-%dT%H:%M:%S")
-                res = str(utc_time + datetime.timedelta(hours=8))
-            item.append(res)
-        result.append(item)
-    return result
-
-
-def filter_ip_information(fileds, tables, host_data, omit=True):
-    """
-    filter historical data based on user input
-    :param fileds: list, user input
-    :param host_data: list, exclude web data
-    :param omit: bool, omit string flag
-    return: all_data,list matched data
-    return: port_count, set, count open ports non-repeating
-    """
-    all_data = []
-    port_count = set()
-
-    for host_item in host_data:
-        every_item = []
-        host_dict = ZoomEyeDict(host_item)
-        for filed_item in fileds:
-            host_result = host_dict.find(tables.get(filed_item.strip()))
-            # count ports
-            if filed_item == 'port':
-                port_count.add(host_result)
-            # format timestamp
-            if filed_item == 'timestamp':
-                utc_time = datetime.datetime.strptime(host_result[:19], "%Y-%m-%dT%H:%M:%S")
-                host_result = str(utc_time)
-            # omit raw data, is too long
-            if filed_item == 'banner':
-                if omit:
-                    host_result = show.omit_str(show.convert_str(host_result))
-                else:
-                    host_result = show.convert_str(host_result)
-            if filed_item.lower() == 'ssl':
-                host_result = host_dict.find(tables.get(filed_item.lower().strip()))
-                ssl_new = host_dict.find("ssl_new")
-                if host_result is None and ssl_new:
-                    host_result = ssl_new.replace("\n\n\n", "")
-            # replace None --> [unknown]
-            if host_result is None:
-                host_result = "[unknown]"
-            every_item.append(host_result)
-        all_data.append(every_item)
-    return all_data, port_count
-
-
-def process_filter(fields, data, tables):
-    has_equal = []
-    not_equal = []
-
-    if not data:
-        return
-    # resolve specific filter items
-    for field_item in fields:
-        field_split = field_item.split('=')
-        if len(field_split) == 2:
-            has_equal.append(field_item)
-            # not_equal.append(field_split[0])
-        if len(field_split) == 1:
-            if field_item == "*":
-                not_equal = list(tables.keys())
-                continue
-            else:
-                not_equal.append(field_item)
-    # match filters that contain specific data
-    if len(has_equal) != 0:
-        result_data = regexp(has_equal, tables, data)
-    else:
-        result_data = data
-
-    return result_data, has_equal, not_equal
-
-
-class Cache:
-    """
-    used to cache the data obtained from the api to the local,
-    or directly clip the file from the local.
-    """
-
-    def __init__(self, dork, resource, page=0):
-        self.dork = dork
-        self.page = page
-        self.resource = resource
-        self.cache_folder = os.path.expanduser(config.ZOOMEYE_CACHE_PATH)
-        self.filename = self.cache_folder + config.FILE_NAME.format(md5_convert(dork + self.resource), page)
-
-    def check(self):
-        """
-        used to detect whether there is a local cache file,
-        and check whether the local cache file expires.
-        :return: bool
-        """
-        # exist?
-        if not os.path.exists(self.filename):
-            return False
-        # check expired
-        file_create_time = os.path.getatime(self.filename)
-        # expired time is five day, time stamp = 60 * 60 * 24 * 5
-        if int(time.time()) - int(file_create_time) > config.EXPIRED_TIME:
-            # delete expired cache file
-            os.remove(self.filename)
-            return False
-        # the cache file exists and has not expired
-        else:
-            return True
-
-    def save(self, data):
-        # folder is exists?
-        if not os.path.isdir(self.cache_folder):
-            try:
-                # create folder when folder does not exists
-                os.makedirs(self.cache_folder)
-            except OSError:
-                raise Exception("init dirs failed {}".format(self.cache_folder))
-        # write to local
-        with open(self.filename, 'w') as f:
-            f.write(data)
-
-    def load(self):
-        """
-        files in the cache from the local folder
-        :return:
-        """
-        result_data = []
-        facet_data = None
-        with open(self.filename, 'r') as f:
-            read_data = f.read()
-        data_json = json.loads(read_data)
-        """
-        process the data loaded from the cache file, 
-        the processed data structure is list. like:
-        [{...}, {...},{...}...]
-        """
-        for i in data_json.get("matches"):
-            result_data.append(i)
-        # get facet
-        if data_json.get("facets"):
-            facet_data = data_json.get("facets")
-        # get data total
-        total = data_json.get("total")
-        # return
-        return result_data, facet_data, total
-
-    def update(self):
-        pass
-
-
-class CliZoomEye:
-
-    def __init__(self, dork, num, resource, facet=None, force=False):
-        self.dork = dork
-        self.num = num
-        self.resource = resource
-        self.facet = facet
-        self.force = force
-
-        self.dork_data = list()
-        self.facet_data = None
-        self.total = 0
-
-        self.api_key = file.get_auth_key()
-        self.zoomeye = ZoomEye(api_key=self.api_key)
-
-    def handle_page(self):
-        try:
-            num = int(self.num)
-            if num % 20 == 0:
-                return int(num / 20)
-            return int(num / 20) + 1
-        except ValueError:
-            if self.num == 'all':
-                for i in range(3):
-                    user_confirm = input("The data may exceed your quota. "
-                                         "If the quota is exceeded, all quota data will be returned. "
-                                         "Are you sure you want to get all the data?(y/N)\n")
-                    if user_confirm == 'y':
-                        self.zoomeye.dork_search(
-                            dork=self.dork,
-                            page=1,
-                            resource=self.resource,
-                            facets=self.facet
-                        )
-                        self.num = self.zoomeye.total
-                        cache = Cache(self.dork, page=1, resource=self.resource)
-                        cache.save(json.dumps(self.zoomeye.raw_data))
-                        if self.num % 20 == 0:
-                            return int(self.num / 20)
-                        return int(self.num / 20) + 1
-                    elif user_confirm == "N":
-                        user_num = input("Please enter the required amount of data:")
-                        return int(user_num)
-                    else:
-                        continue
-                show.printf("more than the number of errors!", color='red')
-        except Exception as e:
-            show.printf(e, color='red')
-            exit(0)
-
-    def cache_dork(self, page, data):
-        cache_file = Cache(self.dork, page=page, resource=self.resource)
-        cache_file.save(json.dumps(data))
-
-    def request_data(self):
-        if os.path.exists(self.dork):
-            self.load()
-        else:
-            page_count = self.handle_page()
-            for page in range(page_count):
-                cache_file = Cache(self.dork, self.resource, page)
-                if cache_file.check() and self.force is False:
-                    dork_data_list, self.facet_data, self.total = cache_file.load()
-                    self.dork_data.extend(dork_data_list)
-                else:
-                    if self.resource == 'host':
-                        self.facet = ['app', 'device', 'service', 'os', 'port', 'country', 'city']
-                    if self.resource == 'web':
-                        self.facet = ['webapp', 'component', 'framework', 'frontend',
-                                      'server', 'waf', 'os', 'country', 'city']
-                    try:
-                        dork_data_list = self.zoomeye.dork_search(
-                            dork=self.dork,
-                            page=page + 1,
-                            resource=self.resource,
-                            facets=self.facet
-                        )
-                    except ValueError:
-                        print("the access token expires, please re-run [zoomeye init] command."
-                              "it is recommended to use API KEY for initialization!")
-                        exit(0)
-                    self.facet_data = self.zoomeye.facet_data
-                    self.total = self.zoomeye.total
-                    self.dork_data.extend(dork_data_list)
-                    self.cache_dork(page, self.zoomeye.raw_data)
-
-    def default_show(self):
-        self.request_data()
-        if self.resource == 'host':
-            show.show_host_default_data(self.dork_data, self.total)
-        if self.resource == 'web':
-            show.show_web_default_data(self.dork_data, self.total)
-
-    def filter_data(self, keys, save=False):
-        """
-        according to web/search or host/search select filter field
-        """
-        if save is not True:
-            self.request_data()
-        if self.resource == 'host':
-            tables = fields_tables_host
-        if self.resource == 'web':
-            tables = fields_tables_web
-        has_equal = []
-        not_equal = []
-        # set the ip field to be displayed by default and in the first place
-        key_list = keys.split(',')
-        try:
-            # set ip field in the first place
-            key_index = key_list.index("ip")
-            key_list.pop(key_index)
-            key_list.insert(0, 'ip')
-        # add IP to the first item when there is no IP
-        except ValueError:
-            key_list.insert(0, 'ip')
-        # process user input fields, separating single fields from fields with equal signs.
-        for key in key_list:
-            res = key.split('=')
-            # field with equal sign
-            if len(res) == 2:
-                has_equal.append(key)
-                # not_equal.append(res[0])
-            # No field with equal sign
-            if len(res) == 1:
-                # handle the case where the wildcard character * is included in the filed
-                # that is, query all fields
-                if key == "*":
-                    not_equal = list(tables.keys())
-                    continue
-                else:
-                    not_equal.append(key)
-        # the filter condition is port, banner, app=**
-        # ex:port,banner,app=MySQL
-        if len(has_equal) != 0:
-            equal_data = regexp(has_equal, tables, self.dork_data)
-        # the filter condition is app, port
-        # ex: ip,port,app
-        else:
-            equal_data = self.dork_data
-        # get result
-        result = filter_search_data(not_equal, tables, equal_data)
-        equal = ','.join(not_equal)
-        if save:
-            return equal, result
-        show.print_filter(equal, result[:self.num], has_equal)
-
-    def facets_data(self, facet, figure):
-        """
-        according to web/search or host/search select facet field
-        """
-        self.request_data()
-        if self.resource == 'host':
-            tables = facets_table_host
-        if self.resource == 'web':
-            tables = facets_table_web
-        show.print_facets(facet, self.facet_data, self.total, figure, tables)
-
-    def save(self, fields):
-        """
-        save api response raw data
-        """
-        self.request_data()
-        name = re.findall(r"[a-zA-Z0-9_\u4e00-\u9fa5]+", self.dork)
-        re_name = '_'.join(name)
-
-        if fields == 'all':
-            filename = "{}_{}_{}_{}.json".format(re_name, self.num, self.resource, int(time.time()))
-            data = {
-                'total': self.total,
-                'matches': self.dork_data,
-                'facets': self.facet_data
-            }
-            with open(filename, 'w') as f:
-                f.write(json.dumps(data))
-            show.printf("save file to {}/{} successful!".format(os.getcwd(), filename), color='green')
-        # -save xx=xxxx, save the filtered data. data format ex:
-        # {app:"xxx", "app":"httpd",.....}
-        else:
-            key, value = self.filter_data(fields, save=True)
-            filename = "{}_{}_{}.json".format(re_name, len(value), int(time.time()))
-            # parser data
-            for v in value:
-                dict_save = {}
-                for index in range(len(key.split(','))):
-                    dict_key = key.split(',')[index]
-                    if isinstance(v[index], dict):
-                        v[index] = v[index].get('name', 'unknown')
-                    dict_value = v[index]
-                    dict_save[dict_key] = dict_value
-                # write to local file
-                file.add_to_file(filename, str(dict_save))
-            show.printf("save file to {}/{} successful!".format(os.getcwd(), filename), color='green')
-
-    def load(self):
-        """
-        load local json file,must be save file
-        """
-        with open(self.dork, 'r') as f:
-            data = f.read()
-        try:
-            json_data = json.loads(data)
-        except json.decoder.JSONDecodeError:
-            show.printf('json format error', color='red')
-            exit(0)
-        self.total = json_data.get("total", 0)
-        self.dork_data = json_data.get("matches", "")
-        self.facet_data = json_data.get("facets", "")
-        self.num = len(self.dork_data)
-
-    def statistics(self, keys, figure):
-        """
-        local data statistics
-        """
-        self.request_data()
-        if self.resource == 'web':
-            tables = stat_web_table
-        if self.resource == 'host':
-            tables = stat_host_table
-        data = {}
-        key_list = keys.split(',')
-        # cycle key
-        for key in key_list:
-            count = {}
-            for item in self.dork_data[:self.num]:
-                zmdict = ZoomEyeDict(item)
-                if tables.get(key.strip()) is None:
-                    # check filed effectiveness
-                    support_fields = ','.join(list(tables.keys()))
-                    show.printf("filter command has unsupport fields [{}], support fields has [{}]"
-                                .format(key, support_fields), color='red')
-                    exit(0)
-                fields = zmdict.find(tables.get(key.strip()))
-                # the value of the result field returned by the API may be empty
-                if fields == '' or isinstance(fields, list):
-                    fields = '[unknown]'
-                r = count.get(fields)
-                if not r:
-                    count[fields] = 1
-                else:
-                    count[fields] = count[fields] + 1
-            data[key] = count
-        # print result for current data aggregation
-        show.print_stat(keys, data, self.num, figure)
-
-    def count(self):
-        """
-        show dock count number
-        """
-        self.request_data()
-        show.printf(self.total)
-
-
-class HistoryDevice:
-    """
-    obtain the user's identity information and determine whether to use the IP history search function
-    """
-
-    def __init__(self, ip, force, num):
-        self.ip = ip
-        self.force = force
-        self.num = num
-        self.cache_path = os.path.expanduser(config.ZOOMEYE_CACHE_PATH) + "/" + self.ip
-
-    def cache_data(self, history_data):
-        """
-        save ip history data to local
-        :param history_data: dict, ip history data
-        """
-        try:
-            # write data
-            # if file path not exists
-            with open(self.cache_path, 'w') as f:
-                f.write(json.dumps(history_data))
-        except FileNotFoundError:
-            # create fold
-            # retry write to local file
-            os.makedirs(os.path.expanduser(config.ZOOMEYE_CACHE_PATH))
-            with open(self.cache_path, 'w') as f:
-                f.write(json.dumps(history_data))
-        except Exception as e:
-            show.printf("unknown error: {}".format(e))
-            exit(0)
-
-    def get_data_from_cache(self):
-        """
-        get data from local file
-        """
-        # cache file exists
-        if os.path.exists(self.cache_path):
-            # file exists check expired time
-            # expired time five day
-            create_time = os.path.getatime(self.cache_path)
-            if int(time.time()) - int(create_time) > config.EXPIRED_TIME:
-                # over expired time remove file
-                os.remove(self.cache_path)
-                return None
-            # read local file
-            with open(self.cache_path, 'r') as f:
-                history_data = f.read()
-            return history_data
-        # cache file not exists
-        else:
-            return None
-
-    def drop_web_data(self):
-        host_data = []
-        not_split_data = self.get_data()
-        for item in not_split_data.get('data'):
-            if "component" in item.keys():
-                continue
-            host_data.append(item)
-        return host_data
-
-    def get_data(self):
-        """
-        get user level and IP historical data
-        """
-        normal_user = ['user', 'developer']
-        api_key = file.get_auth_key()
-        zm = ZoomEye(api_key=api_key)
-        role = zm.resources_info()
-        # permission restrictions
-        if role["plan"] in normal_user:
-            show.printf("this function is only open to advanced users and VIP users.", color='red')
-            exit(0)
-        # the user chooses to force data from the API
-        if self.force:
-            history_data = zm.history_ip(self.ip)
-        else:
-            # from local cache get data
-            history_data_str = self.get_data_from_cache()
-            # local cache not exists from API get data
-            if history_data_str is None:
-                history_data = zm.history_ip(self.ip)
-            else:
-                history_data = json.loads(history_data_str)
-        # cache data
-        self.cache_data(history_data)
-        return history_data
-
-    def show_fields(self):
-        """
-        print some field in terminal
-        """
-        host_data = self.drop_web_data()
-        if self.num is not None and self.num >= len(host_data):
-            self.num = len(host_data)
-        show.print_host_data(host_data[:self.num])
-
-    def filter_fields(self, fields):
-        """
-        filter historical IP data
-        :param fields: list, user input filter fields
-        """
-        data = self.drop_web_data()
-        result_data, has_equal, not_equal = process_filter(fields, data, fields_tables_history_host)
-        # no regexp data
-        if len(result_data) == 0:
-            return
-        # check user input filed is or not support
-        for item in not_equal:
-            if fields_tables_history_host.get(item.strip()) is None:
-                support_fields = ','.join(list(fields_tables_history_host.keys()))
-                show.printf(
-                    "filter command has unsupport fields [{}], support fields has [{}]".format(item, support_fields),
-                    color='red')
-                exit(0)
-        show.print_filter_history(not_equal, result_data[:self.num], has_equal)
-
-
-class IPInformation:
-    """
-    query IP information
-    """
-
-    def __init__(self, dork):
-        self.dork = "ip:{}".format(dork)
-
-    def request_data(self):
-        """
-        get api data
-        """
-        api_key = file.get_auth_key()
-        zm = ZoomEye(api_key=api_key)
-        data = zm.dork_search(self.dork)
-        return data
-
-    def show_information(self):
-        """
-        show default fields: port,service,app,banner
-        """
-        info_data = self.request_data()
-        show.print_information(info_data)
-
-    def filter_information(self, filters):
-        """
-        filter IP information, filter like key or key,key=value
-        """
-        info_data = self.request_data()
-        result_data, has_equal, not_equal = process_filter(filters, info_data, fields_ip)
-        if len(result_data) == 0:
-            return
-        for item in not_equal:
-            if fields_ip.get(item.strip()) is None:
-                support_fields = ','.join(list(fields_ip.keys()))
-                show.printf(
-                    "filter command has unsupport fields [{}], support fields has [{}]".format(item, support_fields),
-                    color='red')
-                exit(0)
-        show.print_info_filter(not_equal, result_data, has_equal)
-
-
-class DomainSearch:
-    """
-    query relation domain or sub domain
-    """
-
-    def __init__(self, q, source, page):
-        self.q = q
-        self.source = source
-        self.page = page
-        api_key = file.get_auth_key()
-        self.zm = ZoomEye(api_key=api_key)
-
-    def show_information(self):
-        """show domain search data"""
-
-        info_data, total = self.zm.domain_search(self.q, self.source, self.page)
-        show.show_domain_info(info_data, total, self.page)
-        # return None
-
-    def generate_dot(self):
-        result, msg = self.zm.generate_dot(self.q, self.source, self.page)
-        if result:
-            show.printf(msg, color='green')
-        else:
-            show.printf(msg, color='red')
-
-
-
-
diff --git a/zoomeye/file.py b/zoomeye/file.py
index e65b4c1..0bd0537 100644
--- a/zoomeye/file.py
+++ b/zoomeye/file.py
@@ -6,7 +6,7 @@
 * Filename: file.py
 * Description: here is used to process operation files
 * Time: 2020.11.30
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 import os
@@ -16,23 +16,25 @@
 zoomeye_dir = os.path.expanduser(config.ZOOMEYE_CONFIG_PATH)
 
 
+
+
 def get_api_key(path) -> str:
     """
     obtain api key from local configuration when querying data
     :param path:
     :return:
     """
-    key_file = zoomeye_dir + "/apikey"
+    key_fl = zoomeye_dir + "/apikey"
     # api key config does not exits
     # raise FileNotFoundError
-    if not os.path.exists(key_file):
+    if not os.path.exists(key_fl):
         raise FileNotFoundError("not found api key config")
     # determine whether the permission of the configuration file is read-only,
     # if not, set it to read-only
-    if not oct(os.stat(key_file).st_mode).endswith("600"):
-        os.chmod(key_file, 0o600)
+    if not oct(os.stat(key_fl).st_mode).endswith("600"):
+        os.chmod(key_fl, 0o600)
     # return read file content
-    with open(key_file, 'r') as f:
+    with open(key_fl, 'r') as f:
         return f.read().strip()
 
 
@@ -42,18 +44,19 @@ def get_jwt_token(path) -> str:
     :param path:
     :return:
     """
-    key_file = zoomeye_dir + "/jwt"
+    key_fl = zoomeye_dir + "/jwt"
     # json web token does not exits
     # raise FileNotFoundError
-    if not os.path.exists(key_file):
+    if not os.path.exists(key_fl):
         raise FileNotFoundError("not found access token config")
 
+
     # determine whether the permission of the configuration file is read-only,
     # if not, set it to read-only
-    if not oct(os.stat(key_file).st_mode).endswith("600"):
-        os.chmod(key_file, 0o600)
+    if not oct(os.stat(key_fl).st_mode).endswith("600"):
+        os.chmod(key_fl, 0o600)
     # return read config content
-    with open(key_file, 'r') as f:
+    with open(key_fl, 'r') as f:
         return f.read().strip()
 
 
diff --git a/zoomeye/plotlib.py b/zoomeye/plotlib.py
index b1a06b0..e649ab9 100644
--- a/zoomeye/plotlib.py
+++ b/zoomeye/plotlib.py
@@ -7,17 +7,17 @@
 * Description: display the statistical graph on the terminal,
     refer to:https://github.com/nschloe/termplotlib
 * Time: 2021.02.03
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 import sys
 import math
-
+import re
 
 from zoomeye import config
 
 
-def char_by_atan(stat, at, color):
+def char_by_atan(stat, at, color):#用于根据给定的百分比值(at)和颜色(color)，返回相应的字符，用于绘制饼状图的每个部分
     """
     :param stat: list, all data and label
     :param at: float, percentage
@@ -31,7 +31,7 @@ def char_by_atan(stat, at, color):
     return char_by_atan(stat[1:], at - stat[0][1], color[1:])
 
 
-def show_pie_chart(stat):
+def show_pie_chart(stat):#用于显示饼状图
     """
     print pie chart in terminal
     :param stat: list, all data and label
@@ -65,7 +65,7 @@ def show_pie_chart(stat):
         count += 1
 
 
-def unicode_output():
+def unicode_output():#用于检查当前的标准输出是否支持Unicode
     """
     unicode standard output
     """
@@ -75,7 +75,7 @@ def unicode_output():
     )
 
 
-def trim_zeros(lst):
+def trim_zeros(lst):#用于去除列表(lst)末尾的零元素
     """
 
     """
@@ -87,7 +87,7 @@ def trim_zeros(lst):
     return lst[:-k] if k > 0 else lst
 
 
-def get_matrix(counts, max_size, bar_width):
+def get_matrix(counts, max_size, bar_width):#用于生成直方图的矩阵表示，用于绘制直方图
     """
     get the length of the histogram corresponding to each data
     :param counts: list, all data
@@ -117,7 +117,7 @@ def get_matrix(counts, max_size, bar_width):
     return out
 
 
-def generate_histogram(values, labels=None, force_ascii=False):
+def generate_histogram(values, labels=None, force_ascii=False):#用于生成直方图
     """
     print histogram in terminal
     take the largest data as the standard, that is, the largest data is the longest
diff --git a/zoomeye/sdk.py b/zoomeye/sdk.py
index 3a9d03b..73779b2 100644
--- a/zoomeye/sdk.py
+++ b/zoomeye/sdk.py
@@ -5,50 +5,14 @@
 * Filename: zoomeye.py
 * Description:
 * Time: 2020.11.25
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 
-import getpass
-import os
+import base64
 
 import requests
 
-import graphviz
-
-fields_tables_host = {
-    "ip": "ip",
-    "app": "portinfo.app",
-    "version": "portinfo.version",
-    "device": "portinfo.device",
-    "port": "portinfo.port",
-    "city": "geoinfo.city.names.en",
-    "country": "geoinfo.country.names.en",
-    "service": "portinfo.service",
-    "asn": "asn",
-    "banner": "portinfo.banner",
-    "time": "timestamp",
-    "ssl": "ssl"
-}
-
-fields_tables_web = {
-    "ip": "ip",
-    "app": "webapp",
-    "headers": "headers",
-    "keywords": "keywords",
-    "title": "title",
-    "site": "site",
-    "city": "geoinfo.city.names.en",
-    "country": "geoinfo.country.names.en",
-    "webapp": "webapp",
-    "component": "component",
-    "framework": "framework",
-    "server": "server",
-    "waf": "waf",
-    "os": "os",
-    "timestamp": "timestamp"
-}
-
 
 class ZoomEyeDict:
 
@@ -61,25 +25,25 @@ def find(self, key):
         :param key: str, dictionary key like: "a.b.c"
         :return:
         """
-        value = None
+        values = None
         # is dict?
         if isinstance(self.dict, dict):
             keys = key.split(".")
-            input_data = self.dict
+            inputData = self.dict
             for k in keys:
-                if k == 'geoinfo' and input_data.get(k) == None:
-                    k = "aiweninfo" if input_data.get("aiweninfo") else "ipipinfo"
-                if input_data.get(k) is not None:
-                    value = input_data.get(k)
+                if k == 'geoinfo' and inputData.get(k) == None:
+                    k = "aiweninfo" if inputData.get("aiweninfo") else "ipipinfo"
+                if inputData.get(k) is not None:
+                    values = inputData.get(k)
                 else:
-                    value = None
-                if isinstance(value, list):
-                    if len(value) != 0:
-                        value = value[0]
+                    values = None
+                if isinstance(values, list):
+                    if len(values) != 0:
+                        values = values[0]
                     else:
-                        value = '[unknown]'
-                input_data = value
-            return value
+                        values = '[unknown]'
+                inputData = values
+            return values
         else:
             raise TypeError("the parameter you pass in must be a dictionary, not a {}".format(type(self.dict)))
 
@@ -89,17 +53,9 @@ class ZoomEye:
     def __init__(self, api_key=""):
         self.api_key = api_key
 
-        self.raw_data = None
-        # process data, list
-        self.data_list = None
-        self.total = None
-        self.search_type = None
-        self.facet_data = None
-
-        self.login_api = "https://api.zoomeye.org/user/login"
-        self.search_api = "https://api.zoomeye.org/{}/search"
-        self.user_info_api = "https://api.zoomeye.org/resources-info"
-        self.history_api = "https://api.zoomeye.org/both/search?history=true&ip={}"
+        # 3.0.0
+        self.search_api = "https://api.zoomeye.org/v2/search"
+        self.userinfo_api = "https://api.zoomeye.org/v2/userinfo"
 
     def _request(self, url, params=None, headers=None, method='GET'):
         """
@@ -113,10 +69,13 @@ def _request(self, url, params=None, headers=None, method='GET'):
         # if method is "GET" use requests.get
         if method == "GET":
             resp = requests.get(url, params=params, headers=headers)
+        # post json body
+        elif method == "POST" and headers.get("Content-Type", "") == "application/json":
+            resp = requests.post(url, json=params, headers=headers)
         # request method is "POST"
         else:
             resp = requests.post(url, data=params, headers=headers)
-            print(resp.text)
+            # print(resp.text)
         # if response succeed and status code is 200 return json data
         if resp and resp.status_code == 200:
             data = resp.json()
@@ -142,260 +101,78 @@ def _check_header(self):
         else:
             headers = {}
         # add user agent
-        headers["User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36"
+        headers[
+            "User-Agent"] = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.0.0 Safari/537.36"
         return headers
 
-    def dork_search(self, dork, page=0, resource="host", facets=None):
-        """
-        Search records with ZoomEye dorks.
-        param: dork
-               ex: country:cn
-               access https://www.zoomeye.org/search/dorks for more details.
-        param: page
-               total page(s) number
-        param: resource
-               set a search resource type, ex: [web, host]
-        param: facet
-               ex: [app, device]
-               A comma-separated list of properties to get summary information
-        """
+    """
+    version: 3.0.0
+    """
 
-        result = []
-        self.search_type = resource
-        search_api = self.search_api.format(resource)
-        if isinstance(facets, (tuple, list)):
-            facets = ','.join(facets)
+    def userinfo(self):
         headers = self._check_header()
-        params = {'query': dork, 'page': page, 'facets': facets}
-        resp = self._request(search_api, params=params, headers=headers)
-        if resp and "matches" in resp:
-            matches = resp.get('matches')
-            result = matches
-            self.raw_data = resp
-            self.data_list = matches
-            self.facet_data = resp.get("facets")
-            self.total = resp.get("total")
+        resp = self._request(self.userinfo_api,
+                             method='POST',
+                             params={},
+                             headers=headers)
+        return resp
 
-        return result
-
-    def multi_page_search(self, dork, page=1, resource="host",
-                          facets=None) -> list:
+    def search(self, dork, qbase64='', page=1, pagesize=20, sub_type='all', fields='', facets='') -> dict:
         """
-        mainly used to search dork data from zoomeye data.
-        please see: https://www.zoomeye.org/doc#host-search and
-                    https://www.zoomeye.org/doc#web-search
+         get network asset information based on query conditions.
+         mainly used to search asset data from zoomeye.
+        please see: https://www.zoomeye.org/doc
         :param dork:str,
-                    ex:apache:cn
+                    ex: country=cn
                     dork to search
+        :param qbase64:str,
+                    ex: country=cn
+                    base64 dork to search
+        :param sub_type:str,
+                    specify the type of data to search
+                    supported : 'v4', 'v6', 'web', 'all
         :param page: int,
                     specify the number of pages to return data, each page contains 20 data
-        :param resource: str,
-                        host search or web search
-        :param facets: list or tuple
+        :param pagesize: int,
+                    specify the number of pagesize to search
+        :param fields: str,
+                        display data based on input fields
+        :param facets: str,
                      if this parameter is specified,
                      the corresponding data will be displayed
                      at the end of the returned result.
-                     supported :'app', 'device', 'service', 'os', 'port', 'country', 'city'
-                     tips:the data returned by the app is contained in the product
-                        other data are corresponding
-        :return: json data
-        """
-        self.search_type = resource
-        search_api = self.search_api.format(resource)
-
-        headers = self._check_header()
-
-        dork_data = []
-        all_data = []
-        for i in range(page):
-            if isinstance(facets, (tuple, list)):
-                facets = ','.join(facets)
-
-            params = {'query': dork, 'page': i + 1, 'facets': facets}
-            result = self._request(search_api, params=params, headers=headers)
-            if result and "matches" in result:
-                self.total = result.get("total")
-                all_data.append(result)
-                for j in result.get("matches"):
-                    # get every piece of data
-                    dork_data.append(j)
-                if facets:
-                    # facets field exist, get it.
-                    self.facet_data = result.get("facets")
-
-        # dork_data is the processed data and returns a list.
-        # nested dictionaries in the list.
-        self.data_list = dork_data
-        # all_data is the raw data returned by the api.
-        # since the api is returned by a dictionary,
-        # i added it to a list for easy viewing of each piece of data
-        self.raw_data = all_data
-        # return processed data
-        return dork_data
-
-    def resources_info(self) -> dict:
-        """
-        account resource information, resource limit and package type
-        see: https://www.zoomeye.org/doc#resources-info
+                     supported : 'product', 'device', 'service', 'os', 'port', 'country', 'subdivisions', 'city'
         :return: dict
-        """
-        headers = self._check_header()
-        result = self._request(self.user_info_api, headers=headers)
-        return result
-
-    def show_count(self):
-        """
-        display the total amount of dork data currently searched
-        :return: int
-        """
-        return self.total
 
-    def dork_filter(self, keys):
-        """
-        display data based on input fields
-        supported fields:
-            host: "app","version","device","ip"","port","hostname","city","country","asn","banner"
-            web: "app","headers","keywords","title","ip","site","city","country"
-        :param keys: str
-        :return:
         """
-        result = []
-        if self.search_type == "host":
-            fields_table = fields_tables_host
-        elif self.search_type == "web":
-            fields_table = fields_tables_web
+        if qbase64:
+            dork = qbase64
+        elif qbase64 == '' and dork != '':
+            dork = base64.b64encode(dork.encode('utf-8')).decode('utf-8')
         else:
-            raise TypeError("the search type must be one of host and web,not {}".format(self.search_type))
-        keys = keys.split(",")
-        for i in self.data_list:
-            item = []
-            zmdict = ZoomEyeDict(i)
-            for key in keys:
-                res = zmdict.find(fields_table.get(key.strip()))
-                item.append(res)
-            result.append(item)
-        return result
-
-    def get_facet(self):
-        """
-        input facets can return the content of facets through this function
-        :return: dict, facets data
-        """
-        return self.facet_data
-
-    def history_ip(self, ip):
-        """
-        Query IP History Information.
-        see: https://www.zoomeye.org/doc#history-data
-        param: ip
-        """
-        result = {}
-
-        zoomeye_api = self.history_api.format(ip)
-        headers = self._check_header()
-        resp = self._request(zoomeye_api, headers=headers)
-        if resp and 'data' in resp:
-            result = resp
-        return result
-
-    def domain_search(self, q, source=0, page=1) -> list:
-        """
-        Search records with ZoomEye dorks.
-        Args:
-            q: query content
-            source: Search type 0, 1
-            page: want to view page
-
-        Returns:
-                list
-        """
-        search_api = self.search_api.format('domain')
+            raise Exception("dork and qbase64 can't be empty at the same time")
         headers = self._check_header()
-        request_result = self._request(search_api, params={"q": q, "type": source, "page": page}, headers=headers)
-        if request_result:
-            self.raw_data = request_result  # json字符串
-            self.data_list = request_result.get("list", [])
-            self.total = request_result.get("total", 0)
-
-        return [self.data_list, self.total]
-
-    def generate_dot(self, q, source=0, page=1):
-        """
-
-        """
-        error_info = ''
-        search_api = self.search_api.format('domain')
-        headers = self._check_header()
-        try:
-            request_result = self._request(search_api, params={"q": q, "type": source, "page": page}, headers=headers)
-        except Exception as e:
-            error_info = e
-            request_result = None
-        if not request_result:
-            return False, error_info
-        # the request data is successful, and the domain name network map is generated.
-        domain = q.replace('.', '_')
-        grap_obj = graphviz.Digraph(
-            name=domain,
-            filename='{}.gv'.format(domain),
-            engine='sfdp',
-            format='png',
-        )
-        result = {}
-        for item in request_result.get('list'):
-            if len(item.get('ip')) != 0:
-                for ip in item.get('ip'):
-                    result[ip] = item.get('name')
-
-        for ip, name in result.items():
-            grap_obj.edge(name, ip)
-
-        try:
-            grap_obj.render()
-        except Exception as e:
-            return False, e
-        return True, "successful! saving in {}".format(os.getcwd())
-
-
-
-def show_site_ip(data):
-    """
-    show web search
-    :param data: dict, matches data from api
-    :return:
-    """
-    if data:
-        for i in data:
-            print(i.get('site'), i.get('ip'))
-
-
-def show_ip_port(data):
-    """
-    show host search ip and port
-    :param data: dict, matches data from api
-    :return:
-    """
-    if data:
-        for i in data:
-            print(i.get('ip'), i.get('portinfo').get('port'))
+        headers["Content-Type"] = "application/json"
+        params = {"qbase64": dork, "sub_type": sub_type, "page": page, "facets": facets, "fields": fields,
+                  "pagesize": pagesize}
+        resp = self._request(self.search_api,
+                             method='POST',
+                             params=params,
+                             headers=headers)
+        return resp
 
 
 def zoomeye_api_test():
     zoomeye = ZoomEye()
     zoomeye.api_key = input('ZoomEye API-KEY:')
-    print(zoomeye.resources_info())
-
-    data = zoomeye.dork_search('solr')
-    show_ip_port(data)
 
-    data = zoomeye.dork_search('country:cn')
-    show_ip_port(data)
-
-    data = zoomeye.dork_search('solr country:cn')
-    show_ip_port(data)
+    """
+    version: 3.0.0
+    """
+    print(zoomeye.userinfo())
 
-    data = zoomeye.dork_search('solr country:cn', resource='web')
-    show_site_ip(data)
+    data = zoomeye.search('country=cn')
+    print(data)
 
 
 if __name__ == "__main__":
diff --git a/zoomeye/show.py b/zoomeye/show.py
index 8f4f316..b9ae422 100644
--- a/zoomeye/show.py
+++ b/zoomeye/show.py
@@ -2,13 +2,13 @@
 * Filename: show.py
 * Description: used to print different data on the terminal.
 * Time: 2020.11.30
-* Author: liuf5
+* Author: wh0am1i
 */
 """
 import re
 import operator
 from colorama import init
-from zoomeye import config, data, plotlib
+from zoomeye import config, tools, plotlib
 from zoomeye.sdk import ZoomEyeDict
 import json
 
@@ -16,41 +16,6 @@
 init(autoreset=True)
 
 
-def convert_str(s):
-    """
-    convert arbitrary string to another string, for print and human readable
-    :param:
-    :return:
-    """
-    res = []
-    d = {
-        '\n': '\\n',
-        '\r': '\\r',
-        '\t': '\\t',
-        '\b': '\\b',
-        '\a': '\\a',
-    }
-    for c in s:
-        if c in d.keys():
-            res.append(d[c])
-        else:
-            res.append(c)
-    return ''.join(res)
-
-
-def omit_str(text, index=0):
-    """
-    ignore part of the string
-    :param text: str, text to be omitted
-    :param index: int, position omitted on the longest basis
-    :return: str, ex: string...
-    """
-    if len(text) < config.STRING_MAX_LENGTH:
-        return text
-
-    return text[:config.STRING_MAX_LENGTH - index] + '...'
-
-
 def printf(s, color="white"):
     """
     print result in terminal
@@ -67,74 +32,11 @@ def printf(s, color="white"):
     }
 
     # default color
-    default = '\033[0m'  # item default color
-    print('{}{}{}'.format(colors.get(color, "WHITE"), s, default))
+    Default = '\033[0m'  # item default color
+    print('{}{}{}'.format(colors.get(color, "WHITE"), s, Default))
 
 
-def show_host_default_data(data_list, count):
-    """
-    display the dork data searched by the user on the terminal,
-    if facet is specified, it will also be displayed.
-    :param resource: search type web or host, str
-    :param data_list: dork data , list
-    :param count: API data count , int
-    :return:
-    """
-    total = 0
-    # print title
-    printf("{:<25}{:<20}{:<20}{:<30}{:<30}".format(
-        "ip:port", "service", "country", "app", "banner"), color="green")
-
-    # process data
-    for d in data_list:
-        ip, country, port, app, banner, service = data.get_host_item(d)
-        # content length too long, truncated
-        app_name = omit_str(app, 5)
-
-        # str --> hex
-        banner_content = omit_str(convert_str(omit_str(banner)))
-
-        # print result
-        total += 1
-        printf('{:<25}{:<20}{:<20}{:<30}{:30}'.format(
-            "{}:{}".format(ip, port), service, country, app_name,
-            banner_content)
-        )
-    print()
-    printf("total: {}/{}".format(total, count))
-
-
-def show_web_default_data(data_list, count):
-    # print title
-    printf("{:<27}{:<27}{:<27}{:<30}".format(
-         "site", "title", "country", "banner"), color="green")
-    num = 0
-    for item in data_list:
-        num += 1
-        item_dict = ZoomEyeDict(item)
-        content = ''
-        for item_key in data.default_table_web.keys():
-            dict_result = item_dict.find(data.default_table_web.get(item_key))
-            if isinstance(dict_result, list):
-                for result_item in dict_result:
-                    if isinstance(result_item, dict):
-                        text = result_item.get("name")
-                    elif isinstance(result_item, str):
-                        text = result_item
-                    else:
-                        text = 'unknown'
-            else:
-                text = dict_result
-            if text is None:
-                text = 'unknown'
-            text = convert_str(omit_str(text))
-            content += "{:<27}".format(text)
-        printf(content)
-    printf('')
-    printf("total:{}/{}".format(num, count))
-
-
-def print_filter(keys, data_list, condition=None):
+def print_filter(keys, data_list, data_total, condition=None):
     """
     used to display user filtered data on the terminal
     :param keys: user input key, is str
@@ -148,13 +50,14 @@ def print_filter(keys, data_list, condition=None):
     for key in keys.split(","):
         title += "{:<30}".format(key)
     printf("{}".format(title), color="green")
-
     # print data
     for i in data_list:
         items = ""
         for j in i:
             if len(str(j)) != 0 and isinstance(j, list):
-                if isinstance(j[0], str):
+                if len(j) == 0:
+                    j = '[unknown]'
+                elif isinstance(j[0], str):
                     j = j[0]
                 elif isinstance(j[0], dict):
                     j = j[0].get('name', '[unknown]')
@@ -165,7 +68,7 @@ def print_filter(keys, data_list, condition=None):
             else:
                 if len(str(j)) == 0:
                     j = '[unknown]'
-            j_hex = convert_str(str(j))
+            j_hex = tools.convert_str(str(j))
             # match to content highlight
             if condition:
                 for item in condition:
@@ -178,15 +81,14 @@ def print_filter(keys, data_list, condition=None):
             items += "{:<30}".format(j_hex)
         total += 1
         printf(items)
-    print()
-    printf("total: {}".format(total))
+    printf("\ntotal: {}/{}".format(total, data_total))
 
 
-def print_facets(facets, facet_data, total, figure, table):
+def print_facets(facets, facet_data: dict, total, figure, table):
     """
     used to print data that users need to count
     :param facets: str, statistical data
-    :param facet_data:list, all facets data
+    :param facet_data: dict, all facets data
     :param total:int, data total
     :param figure:int, data total
     {"app": [{"name": 'xx', 'count': xxx}{"name": 'xx', 'count': xxx}{"name": 'xx', 'count': xxx}]}
@@ -242,210 +144,5 @@ def print_facets(facets, facet_data, total, figure, table):
             plotlib.generate_histogram(counts, names, force_ascii=True)
 
 
-def print_stat(keys, stat_data, num, figure):
-    """
-    print current data aggregation
-    :param keys: str, field
-    :param figure: str, pie or hist
-    :param num: int, local total data
-    :param stat_data: {'app': {'Gunicorn': 2, 'nginx': 14, 'Apache httpd': 9, '[unknown]': 3, 'Tornado httpd': 2}, 'port': {443: 29, 8443: 1}}
-    :return:
-    """
-    if not stat_data:
-        return
-    print(' ' + '-' * 40)
-    printf(" current total data:{}".format(num), color='green')
-    for key in keys.split(','):
-        print(' {:-^40}'.format(key + " data"))
-        # print title
-        if figure is None:
-            printf(" {:<35}{:<20}".format(key, "count"), color="green")
-
-        # sort by the amount of each data
-        item = stat_data.get(key)
-        sorted_item = sorted(item.items(), key=lambda x: x[1], reverse=True)
-        # print result
-        if figure is None:
-            for name, count in sorted_item:
-                printf(" {:<35}{:<20}".format(name, count))
-
-        names = []
-        counts = []
-        pie_info = []
-        for name, count in sorted_item:
-            names.append(name)
-            counts.append(count)
-            # get pie chart data
-            # three decimal places
-            pie = (name, round(count / num, 3))
-            pie_info.append(pie)
-        # pie chart
-        if figure and figure == 'pie':
-            plotlib.show_pie_chart(pie_info)
-        # histogram
-        if figure and figure == 'hist':
-            plotlib.generate_histogram(counts, names, force_ascii=True)
-
-
-def print_host_data(host_data):
-    """
-    :param host_data, list,
-    """
-    # host data is None
-    if len(host_data) == 0:
-        return
-    # parser hostname,country,city... information
-    first_item = host_data[0]
-    all_data, port_count = data.filter_ip_information(data.fields_tables_history_host.keys(),
-                                                      data.fields_tables_history_host,
-                                                      host_data, omit=True)
-    printf(first_item.get('ip'))
-    dict_first_item = data.ZoomEyeDict(first_item)
-    # print title
-    for dict_item in data.tables_history_info.keys():
-        result = dict_first_item.find(data.tables_history_info.get(dict_item))
-        if result == "" or result is None or result == "Unknown":
-            result = "[unknown]"
-        printf("{:<30}{}".format(dict_item.capitalize() + ":", result))
-    printf("{:30}{}{}".format("Number of open ports:", len(port_count), port_count))
-    printf("{:30}{}".format("Number of historical probes:", len(host_data)))
-    printf('')
-    printf("{:<27}{:<27}{:<27}{:<27}".format("timestamp", "port/service", "app", "banner"), color='green')
-    # print detail and process port/service
-    for data_item in all_data:
-        content = ''
-        for item_item in data_item:
-            if data_item.index(item_item) == 1:
-                res = item_item
-                continue
-            if data_item.index(item_item) == 2:
-                item_item = "{}/{}".format(res, item_item)
-            content += "{:<27}".format(item_item)
-        printf(content)
-
-
-def print_filter_history(fileds, hist_data, condition=None):
-    """
-    print user filter history data,
-    :param fileds list,user input field
-    :param hist_data dict, from ZoomEye API get data
-    :param condition list, filter condition
-    """
-    filter_title = ''
-    first_item = hist_data[0]
-    # filter data
-    all_data, port_count = data.filter_ip_information(fileds, data.fields_tables_history_host,
-                                                      hist_data, omit=False)
-    printf(first_item.get('ip'))
-    dict_first_item = data.ZoomEyeDict(first_item)
-    # parser filter data title
-    for dict_item in data.tables_history_info.keys():
-        result = dict_first_item.find(data.tables_history_info.get(dict_item))
-        if result == "" or result is None or result == "Unknown":
-            result = "[unknown]"
-        printf("{:<30}{}".format(dict_item.capitalize() + ":", result))
-    printf("{:30}{}".format("Number of open ports:", len(port_count)))
-    printf("{:30}{}".format("Number of historical probes:", len(hist_data)))
-    printf('')
-    # print title
-    for item in fileds:
-        filter_title += "{:<27}".format(item)
-    printf(filter_title, color='green')
-    # print data
-    for data_item in all_data:
-        content = ""
-        for item_item in data_item:
-            # match to content highlight
-            if condition:
-                for condition_item in condition:
-                    k, v = condition_item.split('=')
-                    re_result = re.search(str(v), str(item_item), re.I | re.M)
-                    # replace to highlight
-                    if re_result:
-                        content_item = "\033[31m{}\033[0m".format(re_result.group())
-                        item_item = str(item_item).replace(re_result.group(), content_item)
-            content += "{:<27}".format(item_item)
-        printf(content)
-
-
-def print_information(raw_data):
-    if len(raw_data) == 0:
-        return
-    # parser hostname,country,city... information
-    first_item = raw_data[0]
-    all_data, port_count = data.filter_ip_information(data.fields_ip.keys(), data.fields_ip, raw_data, omit=True)
-    printf(first_item.get('ip'))
-    dict_first_item = data.ZoomEyeDict(first_item)
-    # print title
-    for dict_item in data.tables_history_info.keys():
-        result = dict_first_item.find(data.tables_history_info.get(dict_item))
-        if result == "" or result is None or result == "Unknown":
-            result = "[unknown]"
-        printf("{:<30}{}".format(dict_item.capitalize() + ":", result))
-    printf("{:30}{}{}".format("Number of open ports:", len(port_count), port_count))
-    printf("")
-    # print port/service
-    printf("{:<10}{:<15}{:<23}{:<30}".format("port", "service", "app", "banner"), color='green')
-    for data_item in sorted(all_data, key=lambda k: int(k[0])):
-        printf("{:<10}{:<15}{:<23}{:<30}".format(data_item[0], data_item[1], omit_str(data_item[2], 7), data_item[3]))
-
-
-def print_info_filter(filters, raw_data, condition=None):
-    filter_title = ''
-    first_item = raw_data[0]
-    # filter data
-    all_data, port_count = data.filter_ip_information(filters, data.fields_ip,
-                                                      raw_data, omit=False)
-    printf(first_item.get('ip'))
-    dict_first_item = data.ZoomEyeDict(first_item)
-    # parser filter data title
-    for dict_item in data.tables_history_info.keys():
-        result = dict_first_item.find(data.tables_history_info.get(dict_item))
-        if result == "" or result is None or result == "Unknown":
-            result = "[unknown]"
-        printf("{:<30}{}".format(dict_item.capitalize() + ":", result))
-    printf("{:30}{}{}".format("Number of open ports:", len(port_count), port_count))
-    printf('')
-    # print title
-    for item in filters:
-        filter_title += "{:<27}".format(item)
-    printf(filter_title, color='green')
-    # print data
-    for data_item in all_data:
-        content = ""
-        for item_item in data_item:
-            # match to content highlight
-            if condition:
-                for condition_item in condition:
-                    k, v = condition_item.split('=')
-                    re_result = re.search(str(v), str(item_item), re.I | re.M)
-                    # replace to highlight
-                    if re_result:
-                        content_item = "\033[31m{}\033[0m".format(re_result.group())
-                        item_item = str(item_item).replace(re_result.group(), content_item)
-            content += "{:<27}".format(item_item)
-        printf(content)
-
-
-def show_domain_info(info_list, total, page):
-    """
-    show query domain info
-    Args:
-        info_list:
-
-    Returns:
-        None
-    """
-
-    if len(info_list) == 0:
-        return
-    printf("{:<55}{:<15}{:<25}".format("name", "timestamp", "ip"), color="green")
-    for d in info_list:
-        name, timestamp, ip = d.values()
-        printf("{:<55}{:<15}{:<25}".format(name, timestamp, json.dumps(ip)))
-    print()
-    printf("total: {}/{}".format(str(30 * int(page)), total))
-
-
 
 
diff --git a/zoomeye/tools.py b/zoomeye/tools.py
new file mode 100644
index 0000000..442c2a7
--- /dev/null
+++ b/zoomeye/tools.py
@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+
+"""
+* Filename: tools.py
+* Description:
+* Time: 2025.02.05
+* Author: wh0am1i
+*/
+"""
+
+import json
+import os
+import time
+import datetime
+import hashlib
+from zoomeye import config
+from zoomeye.sdk import ZoomEyeDict
+from zoomeye import show
+
+zoomeye_dir = os.path.expanduser(config.ZOOMEYE_CONFIG_PATH)
+
+
+def md5_convert(string):
+    """
+    calculate the md5 of a string
+    :param string: input string
+    :return: md5 string
+    """
+    m = hashlib.md5()
+    m.update(string.encode('utf-8'))
+    return m.hexdigest()
+
+
+def convert_str(s):
+    """
+    convert arbitrary string to another string, for print and human readable
+    :param:
+    :return:
+    """
+    res = []
+    d = {
+        '\n': '\\n',
+        '\r': '\\r',
+        '\t': '\\t',
+        '\b': '\\b',
+        '\a': '\\a',
+    }
+    for c in s:
+        if c in d.keys():
+            res.append(d[c])
+        else:
+            res.append(c)
+    return ''.join(res)
+
+
+def omit_str(text, index=0):
+    """
+    ignore part of the string
+    :param text: str, text to be omitted
+    :param index: int, position omitted on the longest basis
+    :return: str, ex: string...
+    """
+    if len(text) < config.STRING_MAX_LENGTH:
+        return text
+
+    return text[:config.STRING_MAX_LENGTH - index] + '...'
+
+
+class Cache:
+    """
+    used to cache the data obtained from the api to the local,
+    or directly clip the file from the local.
+    """
+
+    def __init__(self, dork, page, pagesize, facets, fields, sub_type):
+        self.dork = dork
+        self.page = page
+        self.pagesize = pagesize
+        self.facets = facets
+        self.fields = fields
+        self.sub_type = sub_type
+        self.cache_folder = os.path.expanduser(config.ZOOMEYE_CACHE_PATH)
+        cache_filename = "{}_{}_{}_{}".format(dork, facets, fields, sub_type)
+        self.filename = self.cache_folder + config.FILE_NAME.format(md5_convert(cache_filename), page*pagesize)
+
+    def check(self):
+        """
+        used to detect whether there is a local cache file,
+        and check whether the local cache file expires.
+        :return: bool
+        """
+        # exist?
+        if not os.path.exists(self.filename):
+            return False
+        # check expired
+        file_create_time = os.path.getatime(self.filename)
+        # expired time is five day, time stamp = 60 * 60 * 24 * 5
+        if int(time.time()) - int(file_create_time) > config.EXPIRED_TIME:
+            # delete expired cache file
+            os.remove(self.filename)
+            return False
+        # the cache file exists and has not expired
+        else:
+            return True
+
+    def save(self, data):
+        # folder is exists?
+        if not os.path.isdir(self.cache_folder):
+            try:
+                # create folder when folder does not exists
+                os.makedirs(self.cache_folder)
+            except OSError:
+                raise Exception("init dirs failed {}".format(self.cache_folder))
+        # write to local
+        with open(self.filename, 'w') as f:
+            f.write(json.dumps(data))
+
+    def load(self):
+        """
+        files in the cache from the local folder
+        :return:
+        """
+        with open(self.filename, 'r') as f:
+            read_data = f.read()
+        data_json = json.loads(read_data)
+        return data_json
+
+    def update(self):
+        pass
\ No newline at end of file