Introduction

Overview

Welcome to ZAP API Documentation! The OWASP Zed Attack Proxy (ZAP) is one of the world's most popular free security tools which lets you automatically find security vulnerabilities in your applications. ZAP also has an extremely powerful API that allows you to do nearly everything that is possible via the desktop interface. This allows the developers to automate pentesting and security regression testing of the application in the CI/CD pipeline.

This document provides example guides & API definitions for ZAP APIs. You can view code examples in the dark area to the right; switch the programming language of the examples with the tabs on the top right. If anything is missing or seems incorrect, please check the FAQs or the GitHub issues for existing known issues. Also, if you are new to ZAP, then check out the getting started guide to learn the basic concepts behind ZAP.

The following are some of the features provided by ZAP:

• Intercepting Proxy
• Active and Passive Scanners
• Traditional and Ajax Spiders
• Brute Force Scanner
• Port Scanner
• Web Sockets

Have a look at the examples below to learn how to use each of these features via ZAP API.

Documentation Structure

The API documentation is divided into eight main sections.

• Introduction section contains introductory information of ZAP and installation guide to set up ZAP for testing.
• Exploring the App section contains examples on how to explore the web application.
• Attacking the App section contains examples on how to scan or attack a web application.
• Getting the Results section contains examples on how to retrieve alerts and generate Reports from ZAP.
• Getting Authenticated section contains examples on how to authenticate the web application with ZAP.
• Advanced Settings section contains advanced configurations on how to fine tune ZAP results.
• Contributions section contains guidelines and instructions on how to contribute to ZAP's documentation.
• API Catalogue section contains OpenAPI definitions and auto generated code for ZAP APIs.

Basics on the API Request

ZAP APIs provide access to most of the core features of ZAP such as the active scanner and spider. ZAP API is enabled by default in the daemon mode and the desktop mode. If you are using ZAP desktop, then the API can be configured by visiting the following screen:

Tools -> Options -> API.

Please note that not all the operations which are available in the desktop interface are available via the APIs. Future versions of ZAP will increase the functionality/scope available via the APIs.

API URL Format

The API is available via GET and POST endpoints and the response is available in JSON, XML, HTML, and OTHER (custom formats, e.g. HAR) formats. All the response formats return the same information, just in a different format. Based on the use case, choose the appropriate format. For example, to generate easily readable reports use the HTML format and use XML/JSON based response to parse the results quickly.

The following example shows the API URL format of ZAP:

http://zap/<format>/<component>/<operation>/<operation name>[/?<parameters>]

The format can be either JSON, XML or HTML. The operation can be either view or action or other. The view operation is used to return information and the action is used to control ZAP. For example, views can be used to generated reports or retrieve results and action can be used to start or stop the Spider. The components, operation names and parameters can all be discovered by browsing the API Catalogue.

Access the API

The REST API can be accessed directly or via one of the client implementations detailed below.
A simple web UI is also available to explore and use the APIs via the browser. This web UI can be accessed via http://zap/ when you are proxying through ZAP, or via the host and port ZAP is listening on, e.g. http://localhost:8080/.

By default only the machine ZAP is running on is able to access the APIs. You can allow other machines, that are able to use ZAP as a proxy, access to the API.

Client SDKs

API clients are available for the following languages:

Language	Download links	Notes
.NET	NuGet	Official API
Java	GitHub Maven Central	Official API
Node.js	NPM	Official API
PHP	GitHub Packagist	In process of becoming an official API
Python	PyPI	Official API
Ruby	GitHub

Quick Setup Guide

The quick setup guide focuses on setting up ZAP and a testing application. If you have already setup ZAP then Jump to specific example to experiment with specific features.

Start ZAP

# For Linux, Option: 1, using "headless/daemon" mode
<ZAP_HOME>./zap.sh -daemon -config api.key=change-me-9203935709
# For Linux, Option: 2, using ZAP desktop App
<ZAP_HOME>./zap.sh

# For Windows, Run the exe file or zap.bat script to start ZAP

// For Linux, Option: 1, using "headless/daemon" mode
<ZAP_HOME>./zap.sh -daemon -config api.key=change-me-9203935709
// For Linux, Option: 2, using ZAP desktop App
<ZAP_HOME>./zap.sh

// For Windows, Run the exe file or zap.bat script to start ZAP

# For Linux, Option: 1, using "headless/daemon" mode
$ <ZAP_HOME>./zap.sh -daemon -config api.key=change-me-9203935709
# For Linux, Option: 2, using ZAP desktop App
$ <ZAP_HOME>./zap.sh 

# For Windows, Run the exe file or zap.bat script to start ZAP

To install ZAP, go to ZAP's home page and download the installer specific to the operating system. After extracting the bundle you can start ZAP by issuing the following command shown in the right column.

The API key must be specified on all API actions and some other operations. The API key is used to prevent malicious sites from accessing ZAP API.

Setup a Testing Application

If you already have a website to scan or to perform security testing, then obtain the URL/IP of the application to begin the scanning. The example guide uses Google's Firing Range and OWASP Juice Shop to perform the security testing. The Spidering and Attacking examples use the public instance of the Firing Range, and OWASP Juice Shop are used to showcase the Authentication examples of ZAP.

The following is a list of publicly available vulnerable applications that you can also used in conjunction with ZAP.

Getting Help

All available APIs are documented in the API Catalogue. If you are new to ZAP, then it's highly recommended that you experiment with the desktop UI before trying out the APIs. Because ZAP's APIs strongly resemble the desktop UI. Therefore by working with the UI, you will get a good understanding on how to orchestrate ZAP's APIs. Also, use the export config functionality from the desktop UI to export complex configurations such as contexts, scan policies, etc. Then use the exported configurations when creating the automation scripts.

ZAP has a very friendly and active developer community. Always feel free to raise a question in the ZAP users forum or Stack Overflow for issues related to ZAP. Also, use the ZAP's GitHub repository to raise a bug report or to make any feature requests.

Stay tuned on twitter @zaproxy.

Exploring the App

In order to expose content and functionality for ZAP to test the target the application should be explored before performing any scan or attack. The more you explore your App the more accurate the results will be. If the application is not explored very well then it will impact or reduce the vulnerabilities ZAP can find.

The following are some of the options to explore the site by using ZAP. You can use multiple approaches in a combination to get more complete coverage of the application.

• Traditional Spider (Crawler): Use this approach to crawl the HTML resources (hyperlinks etc) in the web application.

• Ajax Spider: Use this feature if the application heavily relies with Ajax calls.

• Proxy Regression / Unit Tests This is the recommended approach for security regression testing. Use this approach to explore the application, if you already have a test suite or unit tests in place.

• OpenAPI/SOAP Definition: Use this approach if you have a well defined OpenAPI definition. The OpenAPI plugin can be downloaded via the marketplace.

Using Spider

#!/usr/bin/env python
import time
from zapv2 import ZAPv2

# The URL of the application to be tested
target = 'https://public-firing-range.appspot.com'
# Change to match the API key set in ZAP, or use None if the API key is disabled
apiKey = 'changeMe'

# By default ZAP API client will connect to port 8080
zap = ZAPv2(apikey=apiKey)
# Use the line below if ZAP is not listening on port 8080, for example, if listening on port 8090
# zap = ZAPv2(apikey=apikey, proxies={'http': 'http://127.0.0.1:8090', 'https': 'http://127.0.0.1:8090'})

print('Spidering target {}'.format(target))
# The scan returns a scan id to support concurrent scanning
scanID = zap.spider.scan(target)
while int(zap.spider.status(scanID)) < 100:
    # Poll the status until it completes
    print('Spider progress %: {}'.format(zap.spider.status(scanID)))
    time.sleep(1)

print('Spider has completed!')
# Prints the URLs the spider has crawled
print('\n'.join(map(str, zap.spider.results(scanID))))
# If required post process the spider results

# TODO: Explore the Application more with Ajax Spider or Start scanning the application for vulnerabilities

public class Spider {

    private static final String ZAP_ADDRESS = "localhost";
    private static final int ZAP_PORT = 8080;
    // Change to match the API key set in ZAP, or use NULL if the API key is disabled
    private static final String ZAP_API_KEY = "change me";
    // The URL of the application to be tested
    private static final String TARGET = "https://public-firing-range.appspot.com";

    public static void main(String[] args) {
        ClientApi api = new ClientApi(ZAP_ADDRESS, ZAP_PORT, ZAP_API_KEY);

        try {
            // Start spidering the target
            System.out.println("Spidering target : " + TARGET);
            ApiResponse resp = api.spider.scan(TARGET, null, null, null, null);
            String scanID;
            int progress;

            // The scan returns a scan id to support concurrent scanning
            scanID = ((ApiResponseElement) resp).getValue();
            // Poll the status until it completes
            while (true) {
                Thread.sleep(1000);
                progress = Integer.parseInt(((ApiResponseElement) api.spider.status(scanID)).getValue());
                System.out.println("Spider progress : " + progress + "%");
                if (progress >= 100) {
                    break;
                }
            }
            System.out.println("Spider completed");
            // If required post process the spider results
            List<ApiResponse> spiderResults = ((ApiResponseList) api.spider.results(scanID)).getItems();

            // TODO: Explore the Application more with Ajax Spider or Start scanning the application for vulnerabilities

        } catch (Exception e) {
            System.out.println("Exception : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

# To start the Spider scan (Response: Scan ID). Modify the API Key and URL to suite the target
$ curl "http://localhost:8080/JSON/spider/action/scan/?apikey=<ZAP_API_KEY>&url=https://public-firing-range.appspot.com&contextName=&recurse="

# To view the scan status/ percentage of work done
$ curl "http://localhost:8080/JSON/spider/view/status/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"

# To view the scan results
$ curl "http://localhost:8080/JSON/spider/view/results/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"

# To stop the scanning
$ curl "http://localhost:8080/JSON/spider/action/stop/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"
# To pause the scanning
$ curl "http://localhost:8080/JSON/spider/action/pause/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"
# To resume the scanning
$ curl "http://localhost:8080/JSON/spider/action/resume/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"

The Spider is a tool that is used to automatically discover new resources (URLs) on a particular site. It begins with a list of URLs to visit, called the seeds, which depends on how the Spider is started. The Spider then visits these URLs, it identifies all the hyperlinks in the page and adds them to the list of URLs to visit, and the process continues recursively as long as new resources are found. Each response type is processed differently in ZAP. All the available endpoints for the spider can be found in spider section.

Start the Spider

The Spiders explore the site and they don't actually do any scanning. The resources crawled by the Spider(s) are passively scanned in the background via the Passive Scanner. The scan API runs the spider against the given URL. Optionally, the 'maxChildren' parameter can be set to limit the number of children scanned and the 'recurse' parameter can be used to prevent the spider from seeding recursively. The parameter 'subtreeOnly' allows to restrict the spider under a site's subtree (using the specified 'URL'). The parameter 'contextName' can be used to constrain the scan to a Context. View the context example to understand how to create a context with ZAP API.

The code sample on the right recursively scans the application with the provided URL. The scan ID is returned as a response when starting the Spider. Use this scan ID to perform any additional actions or to retrieve any views from the Spider API.

View Status

The spider scan is a async request and the time to complete the task will vary depending on the complexity of the web application. The scan ID returned via starting the spider should be used to obtain the results of the crawling. Execute the status API to get the status/percentage of work done by the Spider.

View Spider Results

The results of the crawling can be obtained via the results API. The following image shows the JSON sample response provided by the results API, listing all the resources crawled by Spider.

Stop or Pause the Spider

If the scanning takes more time than expected you can stop or pause the scanning via using the stop or pause APIs. Additional APIs are available in the API Catalogue to pause or resume or to stop All the scanning processes.

The advanced section on Spider contains more examples on how to tweak/improve the Spider results.

Using Ajax Spider

#!/usr/bin/env python
import time
from zapv2 import ZAPv2

# The URL of the application to be tested
target = 'https://public-firing-range.appspot.com'
# Change to match the API key set in ZAP, or use None if the API key is disabled
apiKey = 'changeme'

# By default ZAP API client will connect to port 8080
zap = ZAPv2(apikey=apiKey)
# Use the line below if ZAP is not listening on port 8080, for example, if listening on port 8090
# zap = ZAPv2(apikey=apikey, proxies={'http': 'http://127.0.0.1:8090', 'https': 'http://127.0.0.1:8090'})

print('Ajax Spider target {}'.format(target))
scanID = zap.ajaxSpider.scan(target)

timeout = time.time() + 60*2   # 2 minutes from now
# Loop until the ajax spider has finished or the timeout has exceeded
while zap.ajaxSpider.status == 'running':
    if time.time() > timeout:
        break
    print('Ajax Spider status' + zap.ajaxSpider.status)
    time.sleep(2)

print('Ajax Spider completed')
ajaxResults = zap.ajaxSpider.results(start=0, count=10)
# If required perform additional operations with the Ajax Spider results

# TODO: Start scanning the application to find vulnerabilities

public class AjaxSpider {

    private static final int ZAP_PORT = 8080;
    private static final String ZAP_API_KEY = null;
    private static final String ZAP_ADDRESS = "localhost";
    private static final String TARGET = "https://public-firing-range.appspot.com";

    public static void main(String[] args) {
        // Create the ZAP Client
        ClientApi api = new ClientApi(ZAP_ADDRESS, ZAP_PORT, ZAP_API_KEY);

        try {
            // Start spidering the target
            System.out.println("Ajax Spider target : " + TARGET);
            ApiResponse resp = api.ajaxSpider.scan(TARGET, null, null, null);
            String status;

            long startTime = System.currentTimeMillis();
            long timeout = TimeUnit.MINUTES.toMillis(2); // Two minutes in milli seconds
            // Loop until the ajax spider has finished or the timeout has exceeded
            while (true) {
                Thread.sleep(2000);
                status = (((ApiResponseElement) api.ajaxSpider.status()).getValue());
                System.out.println("Spider status : " + status);
                if (!("stopped".equals(status)) || (System.currentTimeMillis() - startTime) < timeout) {
                    break;
                }
            }
            System.out.println("Ajax Spider completed");
            // Perform additional operations with the Ajax Spider results
            List<ApiResponse> ajaxSpiderResponse = ((ApiResponseList) api.ajaxSpider.results("0", "10")).getItems();

            // TODO: Start scanning(passive/active scan) the application to find vulnerabilities

        } catch (Exception e) {
            System.out.println("Exception : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

# To start the Ajax Spider
$ curl "http://localhost:8080/JSON/AjaxSpider/action/scan/?apikey=<ZAP_API_KEY>&url=<URL>&inScope=&contextName=&subtreeOnly="

# To view the status
$ curl "http://localhost:8080/JSON/AjaxSpider/view/status/?apikey=<ZAP_API_KEY>"

# To view the number of results
$ curl "http://localhost:8080/JSON/AjaxSpider/view/numberOfResults/?apikey=<ZAP_API_KEY>"

# To view the results
$ curl "http://localhost:8080/JSON/AjaxSpider/view/fullResults/?apikey=<ZAP_API_KEY>"

# To stop the Ajax Spider
$ curl "http://localhost:8080/JSON/AjaxSpider/action/stop/?apikey=<ZAP_API_KEY>"

Use the Ajax Spider if you have applications which heavily depend on Ajax or JavaScript. The Ajax Spider allows you to crawl web applications written in Ajax in far more depth than the traditional Spider.You should also use the traditional Spider as well for complete coverage of a application (e.g. to cover HTML comments).

Start Ajax Spider

The scan API starts the Ajax Spider based on a given URL. Similar to the Traditional Spider, Ajax Spider can be also limited to a context or scope. The parameter 'contextName' can be used to constrain the scan to a Context, the option 'inScope' is ignored if a context was also specified. The parameter 'subtreeOnly' allows to restrict the spider under a site's subtree (using the specified 'URL').

View Status

Unlike the traditional Spider, Ajax Spider does not provide a percentage for the work to be done. Use the status endpoint to identify whether the Ajax Spider is still active or finished.

View Results

Similar to the Traditional Spider, the Ajax Spider's results API can be used to view the resources which are crawled by the Ajax Spider. The following image shows a sample response given by the API.

Stop the Ajax Spider

Ajax spider does not have an indication on how much resources are left to be crawled. Therefore if the Ajax spider takes too much time than expected, then it can be stopped by using the stop API.

View the advanced section on Ajax Spider to learn more about how to further fine-tune the results of the Ajax Spider.

Attacking the App

The application should be explored before starting to scan for security vulnerabilities. If you haven't done that look at the explore section on how to explore the web application. The following section provides examples on how to use the Passive and Active Scanner to find security vulnerabilities in the application.

Using Passive Scan

public class PassiveScan {

    private static final int ZAP_PORT = 8080;
    private static final String ZAP_API_KEY = null;
    private static final String ZAP_ADDRESS = "localhost";

    public static void main(String[] args) {
        ClientApi api = new ClientApi(ZAP_ADDRESS, ZAP_PORT, ZAP_API_KEY);
        int numberOfRecords;

        try {
            // TODO : explore the app (Spider, etc) before using the Passive Scan API, Refer the explore section for details
            // Loop until the ajax spider has finished or the timeout has exceeded
            while (true) {
                Thread.sleep(2000);
                api.pscan.recordsToScan();
                numberOfRecords = Integer.parseInt(((ApiResponseElement) api.pscan.recordsToScan()).getValue());
                System.out.println("Number of records left for scanning : " + numberOfRecords);
                if (numberOfRecords == 0) {
                    break;
                }
            }
            System.out.println("Passive Scan completed");

            // Print Passive scan results/alerts
            System.out.println("Alerts:");
            System.out.println(new String(api.core.xmlreport(), StandardCharsets.UTF_8));

        } catch (Exception e) {
            System.out.println("Exception : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

#!/usr/bin/env python
import time
from pprint import pprint
from zapv2 import ZAPv2

apiKey = 'changeme'
target = 'https://public-firing-range.appspot.com'
zap = ZAPv2(apikey=apiKey, proxies={'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080'})

# TODO : explore the app (Spider, etc) before using the Passive Scan API, Refer the explore section for details
while int(zap.pscan.records_to_scan) > 0:
    # Loop until the ajax spider has finished or the timeout has exceeded
    print('Records to passive scan : ' + zap.pscan.records_to_scan)
    time.sleep(2)

print('Passive Scan completed')

# Print Passive scan results/alerts
print('Hosts: {}'.format(', '.join(zap.core.hosts)))
print('Alerts: ')
pprint(zap.core.alerts())

# To view the number of records left to be scanned
$ curl "http://localhost:8080/JSON/pscan/view/recordsToScan/?apikey=<ZAP_API_KEY>"

# To view the alerts of passive scan
$ curl "http://localhost:8080/JSON/core/view/alerts/?apikey=<ZAP_API_KEY>&baseurl=<TARGET_URL>&start=0&count=10"

All requests that are proxied through ZAP or initialised by tools like the Spider are passively scanned. You do not have to manually start the passive scan process, ZAP by default passively scans all HTTP and WebSocket messages (requests and responses)
which are sent to the application.

Passive scanning does not change the requests nor the responses in any way and is therefore safe to use. This is good for finding problems like missing security headers or missing anti CSRF tokens but is no good for finding vulnerabilities like XSS which require malicious requests to be sent - that's the job of the active scanner.

View the Status

As the records are passively scanned it will take additional time to complete the full scan. After the crawling is completed use the recordsToScan API to obtain the number of records left to be scanned. After the scanning has completed the alerts can be obtained via the alerts endpoint(s).

View the advanced section to know how to configure additional parameters of Passive Scan.

Using Active Scan

Active scanning attempts to find potential vulnerabilities by using known attacks against the selected targets. Active scanning is an attack on those targets. You should NOT use it on applications that you do not own.

Start Active Scanner

public class ActiveScan {

    private static final int ZAP_PORT = 8080;
    private static final String ZAP_API_KEY = null;
    private static final String ZAP_ADDRESS = "localhost";
    private static final String TARGET = "https://public-firing-range.appspot.com";

    public static void main(String[] args) {

        ClientApi api = new ClientApi(ZAP_ADDRESS, ZAP_PORT, ZAP_API_KEY);

        try {
            // TODO : explore the app (Spider, etc) before using the Active Scan API, Refer the explore section
            System.out.println("Active Scanning target : " + TARGET);
            ApiResponse resp = api.ascan.scan(TARGET, "True", "False", null, null, null);
            String scanid;
            int progress;

            // The scan now returns a scan id to support concurrent scanning
            scanid = ((ApiResponseElement) resp).getValue();
            // Poll the status until it completes
            while (true) {
                Thread.sleep(5000);
                progress =
                        Integer.parseInt(
                                ((ApiResponseElement) api.ascan.status(scanid)).getValue());
                System.out.println("Active Scan progress : " + progress + "%");
                if (progress >= 100) {
                    break;
                }
            }

            System.out.println("Active Scan complete");
            // Print vulnerabilities found by the scanning
            System.out.println("Alerts:");
            System.out.println(new String(api.core.xmlreport(), StandardCharsets.UTF_8));

        } catch (Exception e) {
            System.out.println("Exception : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

#!/usr/bin/env python
import time
from pprint import pprint
from zapv2 import ZAPv2

apiKey = 'changeme'
target = 'https://public-firing-range.appspot.com'
zap = ZAPv2(apikey=apiKey, proxies={'http': 'http://127.0.0.1:8080', 'https': 'http://127.0.0.1:8080'})

# TODO : explore the app (Spider, etc) before using the Active Scan API, Refer the explore section
print('Active Scanning target {}'.format(target))
scanID = zap.ascan.scan(target)
while int(zap.ascan.status(scanID)) < 100:
    # Loop until the scanner has finished
    print('Scan progress %: {}'.format(zap.ascan.status(scanID)))
    time.sleep(5)

print('Active Scan completed')
# Print vulnerabilities found by the scanning
print('Hosts: {}'.format(', '.join(zap.core.hosts)))
print('Alerts: ')
pprint(zap.core.alerts(baseurl=target))

# To start the the active scan
$ curl "http://localhost:8080/JSON/ascan/action/scan/?apikey=<ZAP_API_KEY>&url=<TARGET_URL>&recurse=true&inScopeOnly=&scanPolicyName=&method=&postData=&contextId="

# To view the the status of active scan
$ curl "http://localhost:8080/JSON/ascan/view/status/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"

# To view the alerts of active scan
$ curl "http://localhost:8080/JSON/core/view/alerts/?apikey=<ZAP_API_KEY>&baseurl=<TARGET_URL>&start=0&count=10"

# To stop the active scan
$ curl "http://localhost:8080/JSON/ascan/action/stop/?apikey=<ZAP_API_KEY>&scanId=<SCAN_ID>"

The scan endpoint runs the active scanner against the given URL or Context. Optionally, the 'recurse' parameter can be used to scan URLs under the given URL, the parameter 'inScopeOnly' can be used to constrain the scan to URLs that are in scope (ignored if a Context is specified). The parameter 'scanPolicyName' allows to specify the scan policy (if none is given it uses the default scan policy). The parameters 'method' and 'postData' allow to select a given request in conjunction with the given URL.

View advanced settings to learn, how to configure the context, scope, and scan policy with ZAP APIs.

View Status

The status API provides the percentage of scanning done by the active scanner. The scan ID returned via starting the Active Scan should be used to query the status of the scanner.

View Results

Similar to the passive scan results, the active scan results can be viewed using the same alerts endpoint(s). The alerts endpoint(s) will show the consolidated results of Passive and Active Scan.

Stop Active Scanning

Use the stop API to stop a long running active scan. Optionally you can use the stopAllScans endpoints or pause endpoint to stop and pause the active scanning.

It should be noted that active scanning can only find certain types of vulnerabilities. Logical vulnerabilities, such as broken access control, will not be found by any active or automated vulnerability scanning. Manual penetration testing should always be performed in addition to active scanning to find all types of vulnerabilities.

Getting the Results

#!/usr/bin/env python
from zapv2 import ZAPv2

# The URL of the application to be tested
target = 'https://public-firing-range.appspot.com'
# Change to match the API key set in ZAP, or use None if the API key is disabled
apiKey = 'changeMe'

# By default ZAP API client will connect to port 8080
zap = ZAPv2(apikey=apiKey)
# Use the line below if ZAP is not listening on port 8080, for example, if listening on port 8090
# zap = ZAPv2(apikey=apikey, proxies={'http': 'http://127.0.0.1:8090', 'https': 'http://127.0.0.1:8090'})

# TODO: Check if the scanning has completed

# Retrieve the alerts using paging in case there are lots of them
st = 0
pg = 5000
alert_dict = {}
alert_count = 0
alerts = zap.alert.alerts(baseurl=target, start=st, count=pg)
blacklist = [1,2]
while len(alerts) > 0:
    print('Reading ' + str(pg) + ' alerts from ' + str(st))
    alert_count += len(alerts)
    for alert in alerts:
        plugin_id = alert.get('pluginId')
        if plugin_id in blacklist:
            continue
        if alert.get('risk') == 'High':
            # Trigger any relevant postprocessing
            continue
        if alert.get('risk') == 'Informational':
            # Ignore all info alerts - some of them may have been downgraded by security annotations
            continue
    st += pg
    alerts = zap.alert.alerts(start=st, count=pg)
print('Total number of alerts: ' + str(alert_count))

public class Alerts {

    private static final String ZAP_ADDRESS = "localhost";
    private static final int ZAP_PORT = 8080;
    // Change to match the API key set in ZAP, or use NULL if the API key is disabled
    private static final String ZAP_API_KEY = "change me";
    // The URL of the application to be tested
    private static final String TARGET = "https://public-firing-range.appspot.com";

    private static List<String> blackListPlugins = Arrays.asList("1000", "1025");


    public static void main(String[] args) {
        ClientApi api = new ClientApi(ZAP_ADDRESS, ZAP_PORT, ZAP_API_KEY);

        try {
            // TODO: Check if the scanning has completed

            // Retrieve the alerts using paging in case there are lots of them
            int start = 0;
            int count = 5000;
            int alertCount = 0;
            ApiResponse resp = api.alert.alerts(TARGET, String.valueOf(start), String.valueOf(count), null);

            while (((ApiResponseList) resp).getItems().size() != 0) {
                System.out.println("Reading " + count + " alerts from " + start);
                alertCount += ((ApiResponseList) resp).getItems().size();

                for (ApiResponse l : (((ApiResponseList) resp).getItems())) {

                    Map<String, ApiResponse> element = ((ApiResponseSet) l).getValuesMap();
                    if (blackListPlugins.contains(element.get("pluginId").toString())) {
                        // TODO: Trigger any relevant postprocessing
                    } else if ("High".equals(element.get("risk").toString())) {
                        // TODO: Trigger any relevant postprocessing
                    } else if ("Informational".equals(element.get("risk").toString())) {
                        // TODO: Ignore all info alerts - some of them may have been downgraded by security annotations
                    }
                }
                start += count;
                resp = api.alert.alerts(TARGET, String.valueOf(start), String.valueOf(count), null);
            }
            System.out.println("Total number of Alerts: " + alertCount);

        } catch (Exception e) {
            System.out.println("Exception : " + e.getMessage());
            e.printStackTrace();
        }
    }
}

# To view the alerts
$ curl "http://localhost:8080/JSON/alert/view/alerts/?apikey=<ZAP_API_KEY>&baseurl=<BASE_URL>&start=0&count=5000&riskId="

# To view the summary of the alerts
$ curl "http://localhost:8080/JSON/alert/view/alertsSummary/?apikey=<ZAP_API_KEY>baseurl=<BASE_URL>"

# To view alerts by risk category
$ curl "http://localhost:8080/JSON/alert/view/alertsByRisk/?apikey=<ZAP_API_KEY>&url=<BASE_URL>&recurse="

After the scanning (Active/Passive) completes, ZAP provides the security vulnerabilities in the form of alerts. The alerts are categorized into high-priority, medium-priority, low-priority and informational priority risks. The priority indicates the degree of risk associated with each alert. For example, a high priority risk means that the issues listed in that category has more threat or risk potential than a medium-priority alert.

The alerts endpoint provides all the alerts which are identified by ZAP. View the sample code on the right to retrieve the alerts from the alerts endpoint. The results can be used to raise security alerts in the CI/CD pipeline or to trigger any custom workflows.

The alerts summary gets the number of alerts grouped by each risk level and optionally filtering by URL. A Summary report can be also generated using the core module. Use the htmlreport or jsonreport or xmlreport endpoint to generate this summary report. The following image shows the report generated via the HTML report API. The report categories the alerts to risk level and provides a brief description about each alert.

Getting Authenticated

The target application for testing might have a portion of the functionality that is only available for a logged-in user. In order to get full test coverage of the application you need to test the application with a logged-in user as well. Therefore it's very important to understand how to perform authenticated scans with ZAP. ZAP has several means to authenticate your application and keep track of the authentication state. The following are some of the options available for authentication with ZAP.

• Form-based authentication
• Script-based authentication
• JSON-based authentication
• HTTP/NTLM based authentication

The examples below show three authentication workflows. A simple form-based authentication is showcased with the use of the Bodgeit application. The second example shows the script-based authentication using the Damn Vulnerable Web Application(DVWA). The third example shows a more complicated authentication workflow using the JSON and script-based authentication using the OWASP Juice Shop.

General Steps

The following are the general steps when configuring the application authentication with ZAP.

Step 1. Define a context

Contexts are a way of relating a set of URLs together. The URLs are defined as a set of regular expressions (regex). You should include the target application inside the context. The unwanted URLs such as the logout page, password change functionality should be added to the exclude in context section.

Step 2. Set the authentication mechanism

Choose the appropriate login mechanism for your application. If your application supports a simple form-based login, then choose the form-based authentication method. For complex login workflows, you can use the script-based login to define custom authentication workflows.

Step 3. Define your auth parameters

In general, you need to provide the settings on how to communicate to the authentication service of your application. In general, the settings would include the login URL and payload format (username & password). The required parameters will be different for different authentication methods.

Step 4. Set relevant logged in/out indicators

ZAP additionally needs hints to identify whether the application is authenticated or not. To verify the authentication status, ZAP supports logged in/out regexes. These are regex patterns that you should configure to match strings in the responses which indicate if the user is logged in or logged out.

Step 5. Add a valid user and password

Add a user account (an existing user in your application) with valid credentials in ZAP. You can create multiple users if your application exposes different functionality based on user roles. Additionally, you should also set valid session management when configuring the authentication for your application. Currently, ZAP supports cookie-based session management and HTTP authentication based session management.

Step 6. Enable forced user mode (Optional)

Now enable the "Forced User Mode disabled - click to enable" button. Pressing this button will cause ZAP to resend the authentication request whenever it detects that the user is no longer logged in, ie by using the 'logged in' or 'logged out' indicator. But the forced used mode is ignored for scans that already have a user set.

Form Based Authentication

#!/usr/bin/env python
import urllib.parse
from zapv2 import ZAPv2

context_id = 1
apiKey = 'changeMe'
context_name = 'Default Context'
target_url = 'http://localhost:8090/bodgeit'

# By default ZAP API client will connect to port 8080
zap = ZAPv2(apikey=apiKey)


# Use the line below if ZAP is not listening on port 8080, for example, if listening on port 8090
# zap = ZAPv2(apikey=apikey, proxies={'http': 'http://127.0.0.1:8090', 'https': 'http://127.0.0.1:8090'})

def set_include_in_context():
    exclude_url = 'http://localhost:8090/bodgeit/logout.jsp'
    include_url = 'http://localhost:8090/bodgeit.*'
    zap.context.include_in_context(context_name, include_url, apiKey)
    zap.context.exclude_from_context(context_name, exclude_url, apiKey)
    print('Configured include and exclude regex(s) in context')


def set_logged_in_indicator():
    logged_in_regex = '\Q<a href="logout.jsp">Logout</a>\E'
    zap.authentication.set_logged_in_indicator(context_id, logged_in_regex, apiKey)
    print('Configured logged in indicator regex: ')


def set_form_based_auth():
    login_url = 'http://localhost:8090/bodgeit/login.jsp'
    login_request_data = 'username={%username%}&password={%password%}'
    form_based_config = 'loginUrl=' + urllib.parse.quote(login_url) + '&loginRequestData=' + urllib.parse.quote(login_request_data)
    zap.authentication.set_authentication_method(context_id, 'formBasedAuthentication', form_based_config, apiKey)
    print('Configured form based authentication')


def set_user_auth_config():
    user = 'Test User'
    username = '[email protected]'
    password = 'weakPassword'

    user_id = zap.users.new_user(context_id, user, apiKey)
    user_auth_config = 'username=' + urllib.parse.quote(username) + '&password=' + urllib.parse.quote(password)
    zap.users.set_authentication_credentials(context_id, user_id, user_auth_config, apiKey)
    zap.users.set_user_enabled(context_id, user_id, 'true', apiKey)
    zap.forcedUser.set_forced_user(context_id, user_id, apiKey)
    zap.forcedUser.set_forced_user_mode_enabled('true', apiKey)
    print('User Auth Configured')
    return user_id


def start_spider(user_id):
    zap.spider.scan_as_user(context_id, user_id, target_url, recurse='true')
    print('Started Scanning with Authentication')


set_include_in_context()
set_form_based_auth()
set_logged_in_indicator()
user_id_response = set_user_auth_config()
start_spider(user_id_response)

public class FormAuth {

    private static final String ZAP_ADDRESS = "localhost";
    private static final int ZAP_PORT = 8080;
    private static final String ZAP_API_KEY = null;
    private static final String contextId = "1";
    private static final String contextName = "Default Context";
    private static final String target = "http://localhost:8090/bodgeit";

    private static void setIncludeAndExcludeInContext(ClientApi clientApi) throws UnsupportedEncodingException, ClientApiException {
        String includeInContext = "http://localhost:8090/bodgeit.*";
        String excludeInContext = "http://localhost:8090/bodgeit/logout.jsp";

        clientApi.context.includeInContext(contextName, includeInContext);
        clientApi.context.excludeFromContext(contextName, excludeInContext);
    }


    private static void setLoggedInIndicator(ClientApi clientApi) throws UnsupportedEncodingException, ClientApiException {
        // Prepare values to set, with the logged in indicator as a regex matching the logout link
        String loggedInIndicator = "<a href=\"logout.jsp\">Logout</a>";

        // Actually set the logged in indicator
        clientApi.authentication.setLoggedInIndicator(ZAP_API_KEY, contextId, java.util.regex.Pattern.quote(loggedInIndicator));

        // Check out the logged in indicator that is set
        System.out.println("Configured logged in indicator regex: "
                + ((ApiResponseElement) clientApi.authentication.getLoggedInIndicator(contextId)).getValue());
    }

    private static void setFormBasedAuthenticationForBodgeit(ClientApi clientApi) throws ClientApiException,
            UnsupportedEncodingException {
        // Setup the authentication method

        String loginUrl = "http://localhost:8090/bodgeit/login.jsp";
        String loginRequestData = "username={%username%}&password={%password%}";

        // Prepare the configuration in a format similar to how URL parameters are formed. This
        // means that any value we add for the configuration values has to be URL encoded.
        StringBuilder formBasedConfig = new StringBuilder();
        formBasedConfig.append("loginUrl=").append(URLEncoder.encode(loginUrl, "UTF-8"));
        formBasedConfig.append("&loginRequestData=").append(URLEncoder.encode(loginRequestData, "UTF-8"));

        System.out.println("Setting form based authentication configuration as: "
                + formBasedConfig.toString());
        clientApi.authentication.setAuthenticationMethod(ZAP_API_KEY, contextId, "formBasedAuthentication",
                formBasedConfig.toString());

        // Check if everything is set up ok
        System.out
                .println("Authentication config: " + clientApi.authentication.getAuthenticationMethod(contextId).toString(0));
    }

    private static String setUserAuthConfigForBodgeit(ClientApi clientApi) throws ClientApiException, UnsupportedEncodingException {
        // Prepare info
        String user = "Test User";
        String username = "[email protected]";
        String password = "weakPassword";

        // Make sure we have at least one user
        String userId = extractUserId(clientApi.users.newUser(ZAP_API_KEY, contextId, user));

        // Prepare the configuration in a format similar to how URL parameters are formed. This
        // means that any value we add for the configuration values has to be URL encoded.
        StringBuilder userAuthConfig = new StringBuilder();
        userAuthConfig.append("username=").append(URLEncoder.encode(username, "UTF-8"));
        userAuthConfig.append("&password=").append(URLEncoder.encode(password, "UTF-8"));

        System.out.println("Setting user authentication configuration as: " + userAuthConfig.toString());
        clientApi.users.setAuthenticationCredentials(ZAP_API_KEY, contextId, userId, userAuthConfig.toString());
        clientApi.users.setUserEnabled(contextId, userId, "true");
        clientApi.forcedUser.setForcedUser(contextId, userId);
        clientApi.forcedUser.setForcedUserModeEnabled(true);

        // Check if everything is set up ok
        System.out.println("Authentication config: " + clientApi.users.getUserById(contextId, userId).toString(0));
        return userId;
    }

    private static String extractUserId(ApiResponse response) {
        return ((ApiResponseElement) response).getValue();
    }

    private static void scanAsUser(ClientApi clientApi, String userId) throws ClientApiException {
        clientApi.spider.scanAsUser(contextId, userId, target, null, "true", null);
    }

    /**
     * The main method.
     *
     * @param args the arguments
     * @throws ClientApiException
     * @throws UnsupportedEncodingException
     */
    public static void main(String[] args) throws ClientApiException, UnsupportedEncodingException {
        ClientApi clientApi = new ClientApi(ZAP_ADDRESS, ZAP_PORT);

        setIncludeAndExcludeInContext(clientApi);
        setFormBasedAuthenticationForBodgeit(clientApi);
        setLoggedInIndicator(clientApi);
        String userId = setUserAuthConfigForBodgeit(clientApi);
        scanAsUser(clientApi, userId);
    }
}

# To include in default context
curl 'http://localhost:8080/JSON/context/action/includeInContext/?contextName=Default+Context&regex=http%3A%2F%2Flocalhost%3A8090%2Fbodgeit.*'

# Set login details (URL Endoded)
curl 'http://localhost:8080/JSON/authentication/action/setAuthenticationMethod/?contextId=1&authMethodName=formBasedAuthentication&authMethodConfigParams=loginUrl%3Dhttp%3A%2F%2Flocalhost%3A8090%2Fbodgeit%2Flogin.jsp%26loginRequestData%3Dusername%253D%257B%2525username%2525%257D%2526password%253D%257B%2525password%2525%257D'

# To set the login indicator
curl 'http://localhost:8080/JSON/authentication/action/setLoggedInIndicator/?contextId=1&loggedInIndicatorRegex=%5CQ%3Ca+href%3D%22logout.jsp%22%3ELogout%3C%2Fa%3E%5CE'

# To create a user (The first user id is: 0)
curl 'http://localhost:8080/JSON/users/action/newUser/?contextId=1&name=Test+User'

# To add the credentials for the user
curl 'http://localhost:8080/JSON/users/action/setAuthenticationCredentials/?contextId=1&userId=0&authCredentialsConfigParams=username%3Dtest%40example.com%26password%3DweakPassword'

# To enable the user
curl 'http://localhost:8080/JSON/users/action/setUserEnabled/?contextId=1&userId=0&enabled=true'

# To set forced user
curl 'http://localhost:8080/JSON/forcedUser/action/setForcedUser/?contextId=1&userId=0'

# To enable forced user mode
curl 'http://localhost:8080/JSON/forcedUser/action/setForcedUserModeEnabled/?boolean=true'

The following example performs a simple form-based authentication using the Bodgeit vulnerable application. It's recommended that you configure the authentication via the desktop UI before attempting the APIs.

Setup Target Application

Bodgeit uses a simple form-based authentication to authenticate the users to the application. Use the following command to start a docker instance of the Bodgeit application: docker run --rm -p 8090:8080 -i -t psiinon/bodgeit

Register a User

Register a user in the application by navigating to the following URL: http://localhost:8090/bodgeit/register.jsp. For the purpose of this example, use the following credentials.

• username: [email protected]
• password: weakPass

Login

After registering the user, browse (proxied via ZAP) to the following URL (http://localhost:8090/bodgeit/login.jsp), and log in to the application. When you log in to the application, the request will be added to the History tab in ZAP. Search for the POST request to the following URL: http://localhost:8090/bodgeit/login.jsp. Right-click on the post request, and select Flag as Context -> Default Context : Form based Login Request option. This will open the context authentication editor. You can notice it has auto-selected the form-based authentication, auto-filled the login URL, and the post data. Select the correct form parameter as the username and password in the dropdown and click Ok.

Now you need to inform ZAP whether the application is logged in or out. The Bodgeit application includes the logout URL <a href="logout.jsp">Logout</a> as the successful response. You can view this by navigating to the response tab of the login request. Highlight the text and right click and select the Flag as Context -> Default Context, Loggedin Indicator option. This will autofill the regex needed for the login indicator. The following image shows the completed set up for the authentication tab of the context menu.

Now let's add the user credentials by going to the context -> users -> Add section. After adding the credentials, enable the "Forced User" mode in the desktop UI to forcefully authenticate the user prior to the testing of the application.

Now let's test the authentication by performing an authenticated Spidering with ZAP. To accomplish this, go to the Spider and select the default context and the test user to perform the authentication. After this, you should see the Spider crawling all the protected resources.

Steps to Reproduce via API

If you have configured the authentication via the desktop UI, then export the context and import it using the importContext API. Otherwise follow the steps below to configure the authentication setting for the context.

Include in Context

Inorder to proceed with authentication, the URL of the application should be added to the context. As the Bodgit is available via http://localhost:8090/bodgeit use the includeInContext API to add the URL to a context.

Set Authentication Method

Use the setAuthenticationMethod to set up the authentication method and the configuration parameters. The setAuthenticationMethod takes contextId, authMethodName, and authMethodConfigParams as parameters. As Bodgeit uses the form-based authentication, use formBasedAuthentication for the authMethodName and use the contextID from Step 1 as the contextId parameter.

The authMethodConfigParams requires the loginUrl and loginRequestData. Therefore you should set the values to authMethodConfigParams in the following format:

authMethodConfigParams : loginUrl=http://localhost:8090/bodgeit/login.jsp&loginRequestData=username%3D%7B%25username%25%7D%26password%3D%7B%25password%25%7D

The values for authMethodConfigParams parameters must be URL encoded, in this case loginRequestData is username={%username%}&password={%password%}.

Set Login and Logout Indicators

Use the setLoggedOutIndicator to set the logout indicators of the application. The Following is the regex command to match the successful response with the Bodgeit application. \Q<a href=\"logout.jsp\"></a>\E

Create User and Enable Forced User Mode

Now add the user credentials via the setAuthenticationCredentials API and use the SetForcedUserModeEnabled to enable the forced user mode in ZAP.

Advanced Settings

The following section shows advanced configurations of the APIs.

Spider Settings

The following image shows the advanced configurations tab of Spider in the desktop UI.

Use the setOptionMaxDepth to set the maximum depth the spider can crawl, where 0 refers to unlimited depth. The setOptionMaxChildren sets the maximum number of child nodes (per node) that can be crawled, where 0 means no limit. The setOptionMaxDuration API can be used to set the maximum duration the Spider will run. Use the setOptionMaxParseSizeBytes to limit the amount of data parsed by the spider. This allows the spider to skip big responses/files.

View the Spider section in the API Catalogue for additional APIs.

Ajax Spider Settings

The following image shows the advanced configurations tab of Ajax Spider in the desktop UI.

Similar to the Spider API, the Ajax spider also provides APIs to set the maximum depth, crawl state, and maximum duration.

Passive Scan Settings

The scanning rules can be enabled/disabled using the enableScanners and disableScanners API. Also use the setScanOnlyInScope API to limit the passive scanning to a scope. View the advanced section to learn how to configure a context or scope using ZAP APIs.

Passive scanning can also be used to automatically add tags and raise alerts for potential issues. A set of rules for automatic tagging are provided by default. These can be changed, deleted or added to via the Options Passive Scan Tags Screen.

Active Scan Settings

Content in progress!

Contributions Welcome!

Contributions are welcome! There are many ways you can contribute to OWASP ZAP, both as a user and as a developer.

1. Creating High-level API/Automation Docs

Create high level docs or example guides on how to use the APIs to perform any action/view with ZAP. The source files for the ZAP API documentation is hosted on GitHub. The repository is available at Github. The source files are in Markdown (md) format.

2. REST API Documentation

ZAP's rest API is documented using the OpenAPI specification. The specification could be improved by enhancing the description of parameters/ results/ data types etc. The open API specification is available via GitHub.

3. Feature Documentation

Feature documentation related to ZAP is available on ZAP wiki, ZAP user guide, and ZAP extensions repositories.

How to Contribute

The ZAP API documentation is developed according to the docs as code philosophy. The most direct and effective way to contribute to the docs is to submit a pull request(PR) or raise an issue in the GitHub repository containing the docs content that you want to change.

There are 2 different workflows which you can use to make changes or PRs. Use what you are most comfortable with!

1. "Edit this File on GitHub"

You can edit the documentation in the browser via navigating to the relevant source file and clicking the edit this file button. This workflow is recommended for minor changes. For example correcting typos/spellings/grammar etc. For extensive changes, please use the local setup and editing option.

2. Local Setup and Editing

You can fork the repository on GitHub and submit the changes via pull requests. Please see the local setup for API docs section to setup and render the docs locally.

Local Setup for API Docs

ZAP uses git for its code repository. To submit a documentation update, use the following steps:

1. Clone the ZAP Docs repository: git clone https://github.com/zaproxy/zap-api-docs

2. Navigate to the cloned repository: cd zap-api-docs

3. Use the following guide to install Ruby

4. To install the dependencies: $ bundle install

5. To start the server: $ bundle exec middleman server

Documentation Style

This style guide provides a set of editorial guidelines for anyone writing documentation for OWASP ZAP.

General Guidelines

• Check for the grammar and spellings before sending the pull request. Most of the modern editors comes with a spell check option or plugin.

• Use a friendly and conversational tone. Always use simple sentences. If the sentence is lengthy try to break it in to smaller sentences. Also avoid sentences with complicated words or jargon.

• Write positively and avoid using negative sentences.

  • Recommended: If you are not familiar with the Spider, then read this documentation.
  • Not Recommended: Read this documentation to get familiarized with the Spider.

• The documentation should be neutral, without judgments, opinions. For example, words like "easily" or "simple" come with a lot of assumptions. Things that are easier for you might be difficult for another person. Avoid this type of wordings when contributing to the document.

Language and Grammar

• Abbreviation

  Spell out the abbreviation or acronym before introducing them in the sentence. If the abbreviation is well known such as API or ZAP or HTML, you can use it without spelling it first.

• Active Voice

  In general use active voice when formulating the sentence instead of passive voice. A sentence written in the active voice will emphasize the person or thing who is performing an action (eg.The dog chased the ball). In contrast, the passive voice will highlight the recipient of the action (The ball was chased by the dog). Therefor use the passive voice, only when it's less important who or what completed the action and more important that the action was completed. For example:

  • Recommended: The Spider crawls the URLs.
  • Not recommended: The URLs are crawled by the Spider.
    

• Gender References

  Use gender neutral pronouns (they/their/them) when referring to a hypothetical person such as "a user with a logged in session". For example, instead of: - he or she, use they; - him or her, use them; - his or her, use their; - his or hers, use theirs; - himself or herself, use themselves;

• Method Description

  When you're writing reference documentation for a method, phrase the main method description in terms of what it does ("Gets," "Starts," "Creates," "Lists"), rather than what the developer would use it to do ("Get," "Start," "Create," "List").

  • Recommended: action.scan: Starts the Spider on the specified URL.
  • Not recommended: action.scan: Start the Spider on the specified URL.
    

• Second Person

  In general, use second person in your docs rather than first person. For example:

  • Recommended: You are recommended to use the Spider.
  • Not Recommended: We recommend to use the Spider.
    

• Spellings

  Use American spellings when contributing to the documentation.

Formatting

• Capitalization:

  • Use the Chicago manual for capitalization rules for the documentation.
  • For titles of a section, Capitalize of the first letter of each word except for the closed-class words such as determiners, pronouns, conjunctions, and prepositions. Use the following link for guidance.
    • Recommended: The Spider Tutorial with APIs
  • For normal sentences don't capitalize random words in the middle of the sentences.

• Number formatting

  • In general spell out the number if it starts a sentence or is less than ten or an ordinal number.
    • Recommended: Seventeen requests has been intercepted by the passive scanner.
    • Recommended: The passive scan showed nine warnings.
      
    • Recommended: The fifth alert was a high priority alert.
      
  • Use numerals for numbers higher than ten or fractions or unit prices.
    • Recommended: The active scanner detected 24 issues.
    • Recommended: The scanner took 23.4 seconds to complete the crawling.

Punctuation

• Commas

  • Use oxford commas when writing a list of three or more items
    • Recommended: The API can return the results in XML, JSON, and HTML.
    • Not Recommended: The API can return the results in XML, JSON and HTML.
      

• Periods

  • Do not add period to headings or titles.
    
  • Avoid using periods at the end of URLs. Try to modify the sentence so the URL can be in the middle of the sentence.

Markdown Syntax

The API docs are created using standard markdown files. This section contains information regarding the syntax and linting of the Markdown files. Refer to the Slate documentation. Also refer to this document to properly lint the Markdown files.

Writing Code

Inline Code

Put `backticks` around the following symbols when used in text:

• Data types: json, xml, html
• File name: test.py, /path-to-your-data/xml/example-name

Code Block

Use three back ticks to open and close a code block. Specify the programming language after the first backtick group. The documentation currently supports python, java, and shell languages.

API Catalogue

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

The HTTP API for controlling and accessing ZAP.

Base URLs:

• http://zap

• http://{address}:{port}

  • address - The address ZAP is listening on. Default: 127.0.0.1
  • port - The port ZAP is bound to. Default: 8080

Email: OWASP ZAP User Group Web: OWASP ZAP User Group License: Apache 2.0

Authentication

• API Key (apiKeyHeader)

  • Parameter Name: X-ZAP-API-Key, in: header.

• API Key (apiKeyQuery)

  • Parameter Name: apikey, in: query.

alert

alertViewAlert

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/alert/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/alert/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/alert/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/alert/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/alert/

Gets the alert with the given ID, the corresponding HTTP message can be obtained with the 'messageId' field and 'message' API method

Parameters

Name	In	Type	Required	Description
id	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertViewAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/alerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/alerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/alerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/alerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/alerts/

Gets the alerts raised by ZAP, optionally filtering by URL or riskId, and paginating with 'start' position and 'count' of alerts

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none
riskId	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertViewAlertsSummary

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/alertsSummary/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/alertsSummary/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/alertsSummary/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/alertsSummary/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/alertsSummary/

Gets number of alerts grouped by each risk level, optionally filtering by URL

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertViewNumberOfAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/numberOfAlerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/numberOfAlerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/numberOfAlerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/numberOfAlerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/numberOfAlerts/

Gets the number of alerts, optionally filtering by URL or riskId

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
riskId	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertViewAlertsByRisk

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/alertsByRisk/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/alertsByRisk/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/alertsByRisk/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/alertsByRisk/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/alertsByRisk/

Gets a summary of the alerts, optionally filtered by a 'url'. If 'recurse' is true then all alerts that apply to urls that start with the specified 'url' will be returned, otherwise only those on exactly the same 'url' (ignoring url parameters)

Parameters

Name	In	Type	Required	Description
url	query	string	false	none
recurse	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertViewAlertCountsByRisk

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/view/alertCountsByRisk/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/view/alertCountsByRisk/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/view/alertCountsByRisk/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/view/alertCountsByRisk/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/view/alertCountsByRisk/

Gets a count of the alerts, optionally filtered as per alertsPerRisk

Parameters

Name	In	Type	Required	Description
url	query	string	false	none
recurse	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertActionDeleteAllAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/action/deleteAllAlerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/action/deleteAllAlerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/action/deleteAllAlerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/action/deleteAllAlerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/alert/action/deleteAllAlerts/

Deletes all alerts of the current session.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

alertActionDeleteAlert

Code samples

# You can also use wget
curl -X GET http://zap/JSON/alert/action/deleteAlert/?id=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/alert/action/deleteAlert/?id=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/alert/action/deleteAlert/', params={
  'id': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/alert/action/deleteAlert/',
  params: {
  'id' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/alert/action/deleteAlert/

Deletes the alert with the given ID.

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

acsrf

acsrfViewOptionTokensNames

Code samples

# You can also use wget
curl -X GET http://zap/JSON/acsrf/view/optionTokensNames/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/acsrf/view/optionTokensNames/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/acsrf/view/optionTokensNames/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/acsrf/view/optionTokensNames/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/acsrf/view/optionTokensNames/

Lists the names of all anti-CSRF tokens

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

acsrfActionAddOptionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/acsrf/action/addOptionToken/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/acsrf/action/addOptionToken/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/acsrf/action/addOptionToken/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/acsrf/action/addOptionToken/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/acsrf/action/addOptionToken/

Adds an anti-CSRF token with the given name, enabled by default

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

acsrfActionRemoveOptionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/acsrf/action/removeOptionToken/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/acsrf/action/removeOptionToken/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/acsrf/action/removeOptionToken/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/acsrf/action/removeOptionToken/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/acsrf/action/removeOptionToken/

Removes the anti-CSRF token with the given name

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

acsrfOtherGenForm

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/acsrf/other/genForm/?hrefId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/acsrf/other/genForm/?hrefId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/acsrf/other/genForm/', params={
  'hrefId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/acsrf/other/genForm/',
  params: {
  'hrefId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /OTHER/acsrf/other/genForm/

Generate a form for testing lack of anti-CSRF tokens - typically invoked via ZAP

Parameters

Name	In	Type	Required	Description
hrefId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscan

pscanViewScanOnlyInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/view/scanOnlyInScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/view/scanOnlyInScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/view/scanOnlyInScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/view/scanOnlyInScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/view/scanOnlyInScope/

Tells whether or not the passive scan should be performed only on messages that are in scope.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanViewRecordsToScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/view/recordsToScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/view/recordsToScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/view/recordsToScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/view/recordsToScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/view/recordsToScan/

The number of records the passive scanner still has to scan

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanViewScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/view/scanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/view/scanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/view/scanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/view/scanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/view/scanners/

Lists all passive scanners with its ID, name, enabled state and alert threshold.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanViewCurrentRule

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/view/currentRule/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/view/currentRule/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/view/currentRule/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/view/currentRule/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/view/currentRule/

Show information about the passive scan rule currently being run (if any).

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanViewMaxAlertsPerRule

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/view/maxAlertsPerRule/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/view/maxAlertsPerRule/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/view/maxAlertsPerRule/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/view/maxAlertsPerRule/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/view/maxAlertsPerRule/

Gets the maximum number of alerts a passive scan rule should raise.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionSetEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/setEnabled/?enabled=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/setEnabled/?enabled=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/setEnabled/', params={
  'enabled': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/setEnabled/',
  params: {
  'enabled' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/setEnabled/

Sets whether or not the passive scanning is enabled (Note: the enabled state is not persisted).

Parameters

Name	In	Type	Required	Description
enabled	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionSetScanOnlyInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/setScanOnlyInScope/?onlyInScope=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/setScanOnlyInScope/?onlyInScope=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/setScanOnlyInScope/', params={
  'onlyInScope': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/setScanOnlyInScope/',
  params: {
  'onlyInScope' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/setScanOnlyInScope/

Sets whether or not the passive scan should be performed only on messages that are in scope.

Parameters

Name	In	Type	Required	Description
onlyInScope	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionEnableAllScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/enableAllScanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/enableAllScanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/enableAllScanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/enableAllScanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/enableAllScanners/

Enables all passive scanners

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionDisableAllScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/disableAllScanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/disableAllScanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/disableAllScanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/disableAllScanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/disableAllScanners/

Disables all passive scanners

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionEnableScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/enableScanners/?ids=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/enableScanners/?ids=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/enableScanners/', params={
  'ids': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/enableScanners/',
  params: {
  'ids' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/enableScanners/

Enables all passive scanners with the given IDs (comma separated list of IDs)

Parameters

Name	In	Type	Required	Description
ids	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionDisableScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/disableScanners/?ids=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/disableScanners/?ids=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/disableScanners/', params={
  'ids': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/disableScanners/',
  params: {
  'ids' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/disableScanners/

Disables all passive scanners with the given IDs (comma separated list of IDs)

Parameters

Name	In	Type	Required	Description
ids	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionSetScannerAlertThreshold

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/setScannerAlertThreshold/?id=0&alertThreshold=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/setScannerAlertThreshold/?id=0&alertThreshold=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/setScannerAlertThreshold/', params={
  'id': '0',  'alertThreshold': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/setScannerAlertThreshold/',
  params: {
  'id' => 'integer',
'alertThreshold' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/setScannerAlertThreshold/

Sets the alert threshold of the passive scanner with the given ID, accepted values for alert threshold: OFF, DEFAULT, LOW, MEDIUM and HIGH

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none
alertThreshold	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

pscanActionSetMaxAlertsPerRule

Code samples

# You can also use wget
curl -X GET http://zap/JSON/pscan/action/setMaxAlertsPerRule/?maxAlerts=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/pscan/action/setMaxAlertsPerRule/?maxAlerts=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/pscan/action/setMaxAlertsPerRule/', params={
  'maxAlerts': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/pscan/action/setMaxAlertsPerRule/',
  params: {
  'maxAlerts' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/pscan/action/setMaxAlertsPerRule/

Sets the maximum number of alerts a passive scan rule should raise.

Parameters

Name	In	Type	Required	Description
maxAlerts	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

search

searchViewUrlsByUrlRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/urlsByUrlRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/urlsByUrlRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/urlsByUrlRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/urlsByUrlRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/urlsByUrlRegex/

Returns the URLs of the HTTP messages that match the given regular expression in the URL optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewUrlsByRequestRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/urlsByRequestRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/urlsByRequestRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/urlsByRequestRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/urlsByRequestRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/urlsByRequestRegex/

Returns the URLs of the HTTP messages that match the given regular expression in the request optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewUrlsByResponseRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/urlsByResponseRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/urlsByResponseRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/urlsByResponseRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/urlsByResponseRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/urlsByResponseRegex/

Returns the URLs of the HTTP messages that match the given regular expression in the response optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewUrlsByHeaderRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/urlsByHeaderRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/urlsByHeaderRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/urlsByHeaderRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/urlsByHeaderRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/urlsByHeaderRegex/

Returns the URLs of the HTTP messages that match the given regular expression in the header(s) optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewMessagesByUrlRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/messagesByUrlRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/messagesByUrlRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/messagesByUrlRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/messagesByUrlRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/messagesByUrlRegex/

Returns the HTTP messages that match the given regular expression in the URL optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewMessagesByRequestRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/messagesByRequestRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/messagesByRequestRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/messagesByRequestRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/messagesByRequestRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/messagesByRequestRegex/

Returns the HTTP messages that match the given regular expression in the request optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewMessagesByResponseRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/messagesByResponseRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/messagesByResponseRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/messagesByResponseRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/messagesByResponseRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/messagesByResponseRegex/

Returns the HTTP messages that match the given regular expression in the response optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchViewMessagesByHeaderRegex

Code samples

# You can also use wget
curl -X GET http://zap/JSON/search/view/messagesByHeaderRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/search/view/messagesByHeaderRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/search/view/messagesByHeaderRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/search/view/messagesByHeaderRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/search/view/messagesByHeaderRegex/

Returns the HTTP messages that match the given regular expression in the header(s) optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchOtherHarByUrlRegex

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/search/other/harByUrlRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/search/other/harByUrlRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/search/other/harByUrlRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/search/other/harByUrlRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/search/other/harByUrlRegex/

Returns the HTTP messages, in HAR format, that match the given regular expression in the URL optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchOtherHarByRequestRegex

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/search/other/harByRequestRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/search/other/harByRequestRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/search/other/harByRequestRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/search/other/harByRequestRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/search/other/harByRequestRegex/

Returns the HTTP messages, in HAR format, that match the given regular expression in the request optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchOtherHarByResponseRegex

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/search/other/harByResponseRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/search/other/harByResponseRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/search/other/harByResponseRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/search/other/harByResponseRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/search/other/harByResponseRegex/

Returns the HTTP messages, in HAR format, that match the given regular expression in the response optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

searchOtherHarByHeaderRegex

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/search/other/harByHeaderRegex/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/search/other/harByHeaderRegex/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/search/other/harByHeaderRegex/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/search/other/harByHeaderRegex/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/search/other/harByHeaderRegex/

Returns the HTTP messages, in HAR format, that match the given regular expression in the header(s) optionally filtered by URL and paginated with 'start' position and 'count' of messages.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdate

autoupdateViewLatestVersionNumber

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/latestVersionNumber/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/latestVersionNumber/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/latestVersionNumber/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/latestVersionNumber/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/latestVersionNumber/

Returns the latest version number

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewIsLatestVersion

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/isLatestVersion/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/isLatestVersion/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/isLatestVersion/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/isLatestVersion/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/isLatestVersion/

Returns 'true' if ZAP is on the latest version

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewInstalledAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/installedAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/installedAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/installedAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/installedAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/installedAddons/

Return a list of all of the installed add-ons

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewLocalAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/localAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/localAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/localAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/localAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/localAddons/

Returns a list with all local add-ons, installed or not.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewNewAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/newAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/newAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/newAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/newAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/newAddons/

Return a list of any add-ons that have been added to the Marketplace since the last check for updates

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewUpdatedAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/updatedAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/updatedAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/updatedAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/updatedAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/updatedAddons/

Return a list of any add-ons that have been changed in the Marketplace since the last check for updates

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewMarketplaceAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/marketplaceAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/marketplaceAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/marketplaceAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/marketplaceAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/marketplaceAddons/

Return a list of all of the add-ons on the ZAP Marketplace (this information is read once and then cached)

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionAddonDirectories

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionAddonDirectories/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionAddonDirectories/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionAddonDirectories/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionAddonDirectories/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionAddonDirectories/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionDayLastChecked

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionDayLastChecked/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionDayLastChecked/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionDayLastChecked/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionDayLastChecked/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionDayLastChecked/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionDayLastInstallWarned

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionDayLastInstallWarned/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionDayLastInstallWarned/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionDayLastInstallWarned/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionDayLastInstallWarned/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionDayLastInstallWarned/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionDayLastUpdateWarned

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionDayLastUpdateWarned/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionDayLastUpdateWarned/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionDayLastUpdateWarned/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionDayLastUpdateWarned/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionDayLastUpdateWarned/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionDownloadDirectory

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionDownloadDirectory/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionDownloadDirectory/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionDownloadDirectory/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionDownloadDirectory/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionDownloadDirectory/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionCheckAddonUpdates

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionCheckAddonUpdates/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionCheckAddonUpdates/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionCheckAddonUpdates/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionCheckAddonUpdates/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionCheckAddonUpdates/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionCheckOnStart

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionCheckOnStart/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionCheckOnStart/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionCheckOnStart/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionCheckOnStart/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionCheckOnStart/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionDownloadNewRelease

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionDownloadNewRelease/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionDownloadNewRelease/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionDownloadNewRelease/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionDownloadNewRelease/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionDownloadNewRelease/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionInstallAddonUpdates

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionInstallAddonUpdates/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionInstallAddonUpdates/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionInstallAddonUpdates/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionInstallAddonUpdates/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionInstallAddonUpdates/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionInstallScannerRules

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionInstallScannerRules/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionInstallScannerRules/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionInstallScannerRules/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionInstallScannerRules/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionInstallScannerRules/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionReportAlphaAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionReportAlphaAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionReportAlphaAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionReportAlphaAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionReportAlphaAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionReportAlphaAddons/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionReportBetaAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionReportBetaAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionReportBetaAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionReportBetaAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionReportBetaAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionReportBetaAddons/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateViewOptionReportReleaseAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/view/optionReportReleaseAddons/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/view/optionReportReleaseAddons/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/view/optionReportReleaseAddons/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/view/optionReportReleaseAddons/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/view/optionReportReleaseAddons/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionDownloadLatestRelease

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/downloadLatestRelease/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/downloadLatestRelease/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/downloadLatestRelease/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/downloadLatestRelease/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/downloadLatestRelease/

Downloads the latest release, if any

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionInstallAddon

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/installAddon/?id=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/installAddon/?id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/installAddon/', params={
  'id': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/installAddon/',
  params: {
  'id' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/installAddon/

Installs or updates the specified add-on, returning when complete (ie not asynchronously)

Parameters

Name	In	Type	Required	Description
id	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionInstallLocalAddon

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/installLocalAddon/?file=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/installLocalAddon/?file=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/installLocalAddon/', params={
  'file': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/installLocalAddon/',
  params: {
  'file' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/installLocalAddon/

Parameters

Name	In	Type	Required	Description
file	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionUninstallAddon

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/uninstallAddon/?id=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/uninstallAddon/?id=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/uninstallAddon/', params={
  'id': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/uninstallAddon/',
  params: {
  'id' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/uninstallAddon/

Uninstalls the specified add-on

Parameters

Name	In	Type	Required	Description
id	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionCheckAddonUpdates

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionCheckAddonUpdates/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionCheckAddonUpdates/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionCheckAddonUpdates/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionCheckAddonUpdates/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionCheckAddonUpdates/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionCheckOnStart

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionCheckOnStart/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionCheckOnStart/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionCheckOnStart/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionCheckOnStart/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionCheckOnStart/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionDownloadNewRelease

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionDownloadNewRelease/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionDownloadNewRelease/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionDownloadNewRelease/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionDownloadNewRelease/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionDownloadNewRelease/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionInstallAddonUpdates

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionInstallAddonUpdates/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionInstallAddonUpdates/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionInstallAddonUpdates/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionInstallAddonUpdates/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionInstallAddonUpdates/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionInstallScannerRules

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionInstallScannerRules/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionInstallScannerRules/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionInstallScannerRules/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionInstallScannerRules/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionInstallScannerRules/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionReportAlphaAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionReportAlphaAddons/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionReportAlphaAddons/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionReportAlphaAddons/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionReportAlphaAddons/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionReportAlphaAddons/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionReportBetaAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionReportBetaAddons/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionReportBetaAddons/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionReportBetaAddons/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionReportBetaAddons/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionReportBetaAddons/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

autoupdateActionSetOptionReportReleaseAddons

Code samples

# You can also use wget
curl -X GET http://zap/JSON/autoupdate/action/setOptionReportReleaseAddons/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/autoupdate/action/setOptionReportReleaseAddons/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/autoupdate/action/setOptionReportReleaseAddons/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/autoupdate/action/setOptionReportReleaseAddons/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/autoupdate/action/setOptionReportReleaseAddons/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spider

spiderViewStatus

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/status/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/status/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/status/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/status/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/status/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewResults

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/results/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/results/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/results/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/results/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/results/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewFullResults

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/fullResults/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/fullResults/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/fullResults/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/fullResults/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/fullResults/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/scans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/scans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/scans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/scans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/scans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewExcludedFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/excludedFromScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/excludedFromScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/excludedFromScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/excludedFromScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/excludedFromScan/

Gets the regexes of URLs excluded from the spider scans.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewAllUrls

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/allUrls/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/allUrls/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/allUrls/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/allUrls/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/allUrls/

Returns a list of unique URLs from the history table based on HTTP messages added by the Spider.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewAddedNodes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/addedNodes/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/addedNodes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/addedNodes/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/addedNodes/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/addedNodes/

Returns a list of the names of the nodes added to the Sites tree by the specified scan.

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewDomainsAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/domainsAlwaysInScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/domainsAlwaysInScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/domainsAlwaysInScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/domainsAlwaysInScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/domainsAlwaysInScope/

Gets all the domains that are always in scope. For each domain the following are shown: the index, the value (domain), if enabled, and if specified as a regex.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionDomainsAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionDomainsAlwaysInScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionDomainsAlwaysInScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionDomainsAlwaysInScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionDomainsAlwaysInScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionDomainsAlwaysInScope/

Use view domainsAlwaysInScope instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionDomainsAlwaysInScopeEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionDomainsAlwaysInScopeEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionDomainsAlwaysInScopeEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionDomainsAlwaysInScopeEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionDomainsAlwaysInScopeEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionDomainsAlwaysInScopeEnabled/

Use view domainsAlwaysInScope instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionHandleParameters

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionHandleParameters/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionHandleParameters/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionHandleParameters/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionHandleParameters/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionHandleParameters/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionMaxChildren

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionMaxChildren/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionMaxChildren/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionMaxChildren/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionMaxChildren/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionMaxChildren/

Gets the maximum number of child nodes (per node) that can be crawled, 0 means no limit.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionMaxDepth

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionMaxDepth/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionMaxDepth/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionMaxDepth/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionMaxDepth/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionMaxDepth/

Gets the maximum depth the spider can crawl, 0 if unlimited.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionMaxDuration

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionMaxDuration/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionMaxDuration/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionMaxDuration/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionMaxDuration/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionMaxDuration/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionMaxParseSizeBytes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionMaxParseSizeBytes/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionMaxParseSizeBytes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionMaxParseSizeBytes/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionMaxParseSizeBytes/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionMaxParseSizeBytes/

Gets the maximum size, in bytes, that a response might have to be parsed.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionMaxScansInUI

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionMaxScansInUI/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionMaxScansInUI/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionMaxScansInUI/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionMaxScansInUI/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionMaxScansInUI/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionRequestWaitTime

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionRequestWaitTime/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionRequestWaitTime/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionRequestWaitTime/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionRequestWaitTime/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionRequestWaitTime/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionScope/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionScopeText

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionScopeText/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionScopeText/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionScopeText/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionScopeText/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionScopeText/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionSkipURLString

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionSkipURLString/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionSkipURLString/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionSkipURLString/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionSkipURLString/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionSkipURLString/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionThreadCount

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionThreadCount/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionThreadCount/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionThreadCount/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionThreadCount/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionThreadCount/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionUserAgent

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionUserAgent/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionUserAgent/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionUserAgent/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionUserAgent/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionUserAgent/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionAcceptCookies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionAcceptCookies/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionAcceptCookies/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionAcceptCookies/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionAcceptCookies/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionAcceptCookies/

Gets whether or not a spider process should accept cookies while spidering.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionHandleODataParametersVisited

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionHandleODataParametersVisited/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionHandleODataParametersVisited/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionHandleODataParametersVisited/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionHandleODataParametersVisited/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionHandleODataParametersVisited/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionParseComments

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionParseComments/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionParseComments/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionParseComments/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionParseComments/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionParseComments/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionParseGit

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionParseGit/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionParseGit/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionParseGit/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionParseGit/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionParseGit/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionParseRobotsTxt

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionParseRobotsTxt/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionParseRobotsTxt/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionParseRobotsTxt/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionParseRobotsTxt/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionParseRobotsTxt/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionParseSVNEntries

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionParseSVNEntries/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionParseSVNEntries/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionParseSVNEntries/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionParseSVNEntries/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionParseSVNEntries/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionParseSitemapXml

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionParseSitemapXml/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionParseSitemapXml/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionParseSitemapXml/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionParseSitemapXml/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionParseSitemapXml/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionPostForm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionPostForm/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionPostForm/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionPostForm/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionPostForm/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionPostForm/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionProcessForm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionProcessForm/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionProcessForm/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionProcessForm/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionProcessForm/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionProcessForm/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionSendRefererHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionSendRefererHeader/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionSendRefererHeader/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionSendRefererHeader/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionSendRefererHeader/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionSendRefererHeader/

Gets whether or not the 'Referer' header should be sent while spidering.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderViewOptionShowAdvancedDialog

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/view/optionShowAdvancedDialog/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/view/optionShowAdvancedDialog/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/view/optionShowAdvancedDialog/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/view/optionShowAdvancedDialog/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/view/optionShowAdvancedDialog/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/scan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/scan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/scan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/scan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/scan/

Runs the spider against the given URL (or context). Optionally, the 'maxChildren' parameter can be set to limit the number of children scanned, the 'recurse' parameter can be used to prevent the spider from seeding recursively, the parameter 'contextName' can be used to constrain the scan to a Context and the parameter 'subtreeOnly' allows to restrict the spider under a site's subtree (using the specified 'url').

Parameters

Name	In	Type	Required	Description
url	query	string	false	none
maxChildren	query	integer	false	none
recurse	query	boolean	false	none
contextName	query	string	false	none
subtreeOnly	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionScanAsUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/scanAsUser/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/scanAsUser/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/scanAsUser/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/scanAsUser/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/scanAsUser/

Runs the spider from the perspective of a User, obtained using the given Context ID and User ID. See 'scan' action for more details.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none
url	query	string	false	none
maxChildren	query	integer	false	none
recurse	query	boolean	false	none
subtreeOnly	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionPause

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/pause/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/pause/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/pause/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/pause/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/pause/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionResume

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/resume/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/resume/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/resume/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/resume/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/resume/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionStop

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/stop/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/stop/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/stop/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/stop/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/stop/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionRemoveScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/removeScan/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/removeScan/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/removeScan/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/removeScan/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/removeScan/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionPauseAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/pauseAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/pauseAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/pauseAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/pauseAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/pauseAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionResumeAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/resumeAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/resumeAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/resumeAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/resumeAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/resumeAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionStopAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/stopAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/stopAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/stopAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/stopAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/stopAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionRemoveAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/removeAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/removeAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/removeAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/removeAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/removeAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionClearExcludedFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/clearExcludedFromScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/clearExcludedFromScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/clearExcludedFromScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/clearExcludedFromScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/clearExcludedFromScan/

Clears the regexes of URLs excluded from the spider scans.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionExcludeFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/excludeFromScan/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/excludeFromScan/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/excludeFromScan/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/excludeFromScan/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/excludeFromScan/

Adds a regex of URLs that should be excluded from the spider scans.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionAddDomainAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/addDomainAlwaysInScope/?value=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/addDomainAlwaysInScope/?value=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/addDomainAlwaysInScope/', params={
  'value': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/addDomainAlwaysInScope/',
  params: {
  'value' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/addDomainAlwaysInScope/

Adds a new domain that's always in scope, using the specified value. Optionally sets if the new entry is enabled (default, true) and whether or not the new value is specified as a regex (default, false).

Parameters

Name	In	Type	Required	Description
value	query	string	true	none
isRegex	query	boolean	false	none
isEnabled	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionModifyDomainAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/modifyDomainAlwaysInScope/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/modifyDomainAlwaysInScope/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/modifyDomainAlwaysInScope/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/modifyDomainAlwaysInScope/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/modifyDomainAlwaysInScope/

Modifies a domain that's always in scope. Allows to modify the value, if enabled or if a regex. The domain is selected with its index, which can be obtained with the view domainsAlwaysInScope.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none
value	query	string	false	none
isRegex	query	boolean	false	none
isEnabled	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionRemoveDomainAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/removeDomainAlwaysInScope/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/removeDomainAlwaysInScope/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/removeDomainAlwaysInScope/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/removeDomainAlwaysInScope/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/removeDomainAlwaysInScope/

Removes a domain that's always in scope, with the given index. The index can be obtained with the view domainsAlwaysInScope.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionEnableAllDomainsAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/enableAllDomainsAlwaysInScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/enableAllDomainsAlwaysInScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/enableAllDomainsAlwaysInScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/enableAllDomainsAlwaysInScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/enableAllDomainsAlwaysInScope/

Enables all domains that are always in scope.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionDisableAllDomainsAlwaysInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/disableAllDomainsAlwaysInScope/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/disableAllDomainsAlwaysInScope/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/disableAllDomainsAlwaysInScope/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/disableAllDomainsAlwaysInScope/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/disableAllDomainsAlwaysInScope/

Disables all domains that are always in scope.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionHandleParameters

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionHandleParameters/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionHandleParameters/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionHandleParameters/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionHandleParameters/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionHandleParameters/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionScopeString

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionScopeString/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionScopeString/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionScopeString/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionScopeString/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionScopeString/

Use actions [add|modify|remove]DomainAlwaysInScope instead.

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionSkipURLString

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionSkipURLString/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionSkipURLString/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionSkipURLString/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionSkipURLString/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionSkipURLString/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionUserAgent

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionUserAgent/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionUserAgent/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionUserAgent/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionUserAgent/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionUserAgent/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionAcceptCookies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionAcceptCookies/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionAcceptCookies/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionAcceptCookies/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionAcceptCookies/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionAcceptCookies/

Sets whether or not a spider process should accept cookies while spidering.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionHandleODataParametersVisited

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionHandleODataParametersVisited/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionHandleODataParametersVisited/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionHandleODataParametersVisited/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionHandleODataParametersVisited/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionHandleODataParametersVisited/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionMaxChildren

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionMaxChildren/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionMaxChildren/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionMaxChildren/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionMaxChildren/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionMaxChildren/

Sets the maximum number of child nodes (per node) that can be crawled, 0 means no limit.

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionMaxDepth

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionMaxDepth/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionMaxDepth/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionMaxDepth/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionMaxDepth/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionMaxDepth/

Sets the maximum depth the spider can crawl, 0 for unlimited depth.

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionMaxDuration

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionMaxDuration/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionMaxDuration/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionMaxDuration/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionMaxDuration/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionMaxDuration/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionMaxParseSizeBytes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionMaxParseSizeBytes/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionMaxParseSizeBytes/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionMaxParseSizeBytes/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionMaxParseSizeBytes/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionMaxParseSizeBytes/

Sets the maximum size, in bytes, that a response might have to be parsed. This allows the spider to skip big responses/files.

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionMaxScansInUI

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionMaxScansInUI/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionMaxScansInUI/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionMaxScansInUI/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionMaxScansInUI/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionMaxScansInUI/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionParseComments

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionParseComments/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionParseComments/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionParseComments/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionParseComments/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionParseComments/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionParseGit

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionParseGit/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionParseGit/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionParseGit/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionParseGit/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionParseGit/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionParseRobotsTxt

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionParseRobotsTxt/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionParseRobotsTxt/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionParseRobotsTxt/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionParseRobotsTxt/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionParseRobotsTxt/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionParseSVNEntries

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionParseSVNEntries/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionParseSVNEntries/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionParseSVNEntries/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionParseSVNEntries/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionParseSVNEntries/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionParseSitemapXml

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionParseSitemapXml/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionParseSitemapXml/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionParseSitemapXml/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionParseSitemapXml/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionParseSitemapXml/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionPostForm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionPostForm/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionPostForm/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionPostForm/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionPostForm/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionPostForm/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionProcessForm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionProcessForm/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionProcessForm/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionProcessForm/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionProcessForm/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionProcessForm/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionRequestWaitTime

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionRequestWaitTime/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionRequestWaitTime/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionRequestWaitTime/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionRequestWaitTime/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionRequestWaitTime/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionSendRefererHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionSendRefererHeader/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionSendRefererHeader/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionSendRefererHeader/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionSendRefererHeader/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionSendRefererHeader/

Sets whether or not the 'Referer' header should be sent while spidering.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionShowAdvancedDialog

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionShowAdvancedDialog/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionShowAdvancedDialog/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionShowAdvancedDialog/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionShowAdvancedDialog/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionShowAdvancedDialog/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

spiderActionSetOptionThreadCount

Code samples

# You can also use wget
curl -X GET http://zap/JSON/spider/action/setOptionThreadCount/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/spider/action/setOptionThreadCount/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/spider/action/setOptionThreadCount/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/spider/action/setOptionThreadCount/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/spider/action/setOptionThreadCount/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

core

coreViewHosts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/hosts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/hosts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/hosts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/hosts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/hosts/

Gets the name of the hosts accessed through/by ZAP

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewSites

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/sites/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/sites/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/sites/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/sites/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/sites/

Gets the sites accessed through/by ZAP (scheme and domain)

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewUrls

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/urls/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/urls/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/urls/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/urls/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/urls/

Gets the URLs accessed through/by ZAP, optionally filtering by (base) URL.

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewChildNodes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/childNodes/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/childNodes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/childNodes/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/childNodes/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/childNodes/

Gets the child nodes underneath the specified URL in the Sites tree

Parameters

Name	In	Type	Required	Description
url	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewMessage

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/message/?id=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/message/?id=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/message/', params={
  'id': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/message/',
  params: {
  'id' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/view/message/

Gets the HTTP message with the given ID. Returns the ID, request/response headers and bodies, cookies, note, type, RTT, and timestamp.

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewMessages

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/messages/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/messages/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/messages/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/messages/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/messages/

Gets the HTTP messages sent by ZAP, request and response, optionally filtered by URL and paginated with 'start' position and 'count' of messages

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewMessagesById

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/messagesById/?ids=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/messagesById/?ids=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/messagesById/', params={
  'ids': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/messagesById/',
  params: {
  'ids' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/view/messagesById/

Gets the HTTP messages with the given IDs.

Parameters

Name	In	Type	Required	Description
ids	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewNumberOfMessages

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/numberOfMessages/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/numberOfMessages/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/numberOfMessages/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/numberOfMessages/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/numberOfMessages/

Gets the number of messages, optionally filtering by URL

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/mode/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/mode/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/mode/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/mode/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/mode/

Gets the mode

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewVersion

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/version/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/version/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/version/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/version/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/version/

Gets ZAP version

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewExcludedFromProxy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/excludedFromProxy/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/excludedFromProxy/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/excludedFromProxy/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/excludedFromProxy/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/excludedFromProxy/

Gets the regular expressions, applied to URLs, to exclude from the local proxies.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewHomeDirectory

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/homeDirectory/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/homeDirectory/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/homeDirectory/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/homeDirectory/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/homeDirectory/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewSessionLocation

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/sessionLocation/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/sessionLocation/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/sessionLocation/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/sessionLocation/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/sessionLocation/

Gets the location of the current session file

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewProxyChainExcludedDomains

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/proxyChainExcludedDomains/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/proxyChainExcludedDomains/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/proxyChainExcludedDomains/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/proxyChainExcludedDomains/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/proxyChainExcludedDomains/

Gets all the domains that are excluded from the outgoing proxy. For each domain the following are shown: the index, the value (domain), if enabled, and if specified as a regex.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainSkipName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainSkipName/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainSkipName/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainSkipName/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainSkipName/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainSkipName/

Use view proxyChainExcludedDomains instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyExcludedDomains

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyExcludedDomains/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyExcludedDomains/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyExcludedDomains/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyExcludedDomains/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyExcludedDomains/

Use view proxyChainExcludedDomains instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyExcludedDomainsEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyExcludedDomainsEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyExcludedDomainsEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyExcludedDomainsEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyExcludedDomainsEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyExcludedDomainsEnabled/

Use view proxyChainExcludedDomains instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewZapHomePath

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/zapHomePath/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/zapHomePath/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/zapHomePath/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/zapHomePath/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/zapHomePath/

Gets the path to ZAP's home directory.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionMaximumAlertInstances

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionMaximumAlertInstances/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionMaximumAlertInstances/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionMaximumAlertInstances/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionMaximumAlertInstances/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionMaximumAlertInstances/

Gets the maximum number of alert instances to include in a report.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionMergeRelatedAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionMergeRelatedAlerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionMergeRelatedAlerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionMergeRelatedAlerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionMergeRelatedAlerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionMergeRelatedAlerts/

Gets whether or not related alerts will be merged in any reports generated.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionAlertOverridesFilePath

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionAlertOverridesFilePath/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionAlertOverridesFilePath/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionAlertOverridesFilePath/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionAlertOverridesFilePath/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionAlertOverridesFilePath/

Gets the path to the file with alert overrides.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewAlert

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/alert/?id=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/alert/?id=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/alert/', params={
  'id': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/alert/',
  params: {
  'id' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/view/alert/

Gets the alert with the given ID, the corresponding HTTP message can be obtained with the 'messageId' field and 'message' API method

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/alerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/alerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/alerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/alerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/alerts/

Gets the alerts raised by ZAP, optionally filtering by URL or riskId, and paginating with 'start' position and 'count' of alerts

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none
riskId	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewAlertsSummary

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/alertsSummary/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/alertsSummary/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/alertsSummary/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/alertsSummary/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/alertsSummary/

Gets number of alerts grouped by each risk level, optionally filtering by URL

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewNumberOfAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/numberOfAlerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/numberOfAlerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/numberOfAlerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/numberOfAlerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/numberOfAlerts/

Gets the number of alerts, optionally filtering by URL or riskId

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
riskId	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionDefaultUserAgent

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionDefaultUserAgent/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionDefaultUserAgent/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionDefaultUserAgent/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionDefaultUserAgent/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionDefaultUserAgent/

Gets the user agent that ZAP should use when creating HTTP messages (for example, spider messages or CONNECT requests to outgoing proxy).

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionDnsTtlSuccessfulQueries

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionDnsTtlSuccessfulQueries/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionDnsTtlSuccessfulQueries/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionDnsTtlSuccessfulQueries/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionDnsTtlSuccessfulQueries/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionDnsTtlSuccessfulQueries/

Gets the TTL (in seconds) of successful DNS queries.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionHttpState

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionHttpState/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionHttpState/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionHttpState/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionHttpState/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionHttpState/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainName/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainName/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainName/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainName/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainName/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainPassword

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainPassword/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainPassword/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainPassword/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainPassword/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainPassword/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainPort

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainPort/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainPort/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainPort/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainPort/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainPort/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainRealm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainRealm/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainRealm/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainRealm/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainRealm/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainRealm/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainUserName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainUserName/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainUserName/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainUserName/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainUserName/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainUserName/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionTimeoutInSecs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionTimeoutInSecs/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionTimeoutInSecs/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionTimeoutInSecs/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionTimeoutInSecs/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionTimeoutInSecs/

Gets the connection time out, in seconds.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionHttpStateEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionHttpStateEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionHttpStateEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionHttpStateEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionHttpStateEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionHttpStateEnabled/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionProxyChainPrompt

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionProxyChainPrompt/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionProxyChainPrompt/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionProxyChainPrompt/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionProxyChainPrompt/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionProxyChainPrompt/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionSingleCookieRequestHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionSingleCookieRequestHeader/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionSingleCookieRequestHeader/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionSingleCookieRequestHeader/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionSingleCookieRequestHeader/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionSingleCookieRequestHeader/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionUseProxyChain

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionUseProxyChain/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionUseProxyChain/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionUseProxyChain/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionUseProxyChain/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionUseProxyChain/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreViewOptionUseProxyChainAuth

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/view/optionUseProxyChainAuth/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/view/optionUseProxyChainAuth/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/view/optionUseProxyChainAuth/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/view/optionUseProxyChainAuth/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/view/optionUseProxyChainAuth/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionAccessUrl

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/accessUrl/?url=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/accessUrl/?url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/accessUrl/', params={
  'url': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/accessUrl/',
  params: {
  'url' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/accessUrl/

Convenient and simple action to access a URL, optionally following redirections. Returns the request sent and response received and followed redirections, if any. Other actions are available which offer more control on what is sent, like, 'sendRequest' or 'sendHarRequest'.

Parameters

Name	In	Type	Required	Description
url	query	string	true	none
followRedirects	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionShutdown

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/shutdown/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/shutdown/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/shutdown/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/shutdown/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/shutdown/

Shuts down ZAP

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionNewSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/newSession/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/newSession/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/newSession/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/newSession/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/newSession/

Creates a new session, optionally overwriting existing files. If a relative path is specified it will be resolved against the "session" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
name	query	string	false	none
overwrite	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionLoadSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/loadSession/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/loadSession/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/loadSession/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/loadSession/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/loadSession/

Loads the session with the given name. If a relative path is specified it will be resolved against the "session" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
name	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSaveSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/saveSession/?name=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/saveSession/?name=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/saveSession/', params={
  'name': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/saveSession/',
  params: {
  'name' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/saveSession/

Saves the session with the name supplied, optionally overwriting existing files. If a relative path is specified it will be resolved against the "session" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
name	query	string	true	none
overwrite	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSnapshotSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/snapshotSession/?name=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/snapshotSession/?name=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/snapshotSession/', params={
  'name': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/snapshotSession/',
  params: {
  'name' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/snapshotSession/

Snapshots the session, optionally with the given name, and overwriting existing files. If no name is specified the name of the current session with a timestamp appended is used. If a relative path is specified it will be resolved against the "session" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
name	query	string	true	none
overwrite	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionClearExcludedFromProxy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/clearExcludedFromProxy/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/clearExcludedFromProxy/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/clearExcludedFromProxy/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/clearExcludedFromProxy/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/clearExcludedFromProxy/

Clears the regexes of URLs excluded from the local proxies.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionExcludeFromProxy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/excludeFromProxy/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/excludeFromProxy/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/excludeFromProxy/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/excludeFromProxy/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/excludeFromProxy/

Adds a regex of URLs that should be excluded from the local proxies.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetHomeDirectory

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setHomeDirectory/?dir=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setHomeDirectory/?dir=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setHomeDirectory/', params={
  'dir': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setHomeDirectory/',
  params: {
  'dir' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setHomeDirectory/

Parameters

Name	In	Type	Required	Description
dir	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setMode/?mode=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setMode/?mode=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setMode/', params={
  'mode': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setMode/',
  params: {
  'mode' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setMode/

Sets the mode, which may be one of [safe, protect, standard, attack]

Parameters

Name	In	Type	Required	Description
mode	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionGenerateRootCA

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/generateRootCA/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/generateRootCA/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/generateRootCA/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/generateRootCA/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/generateRootCA/

Generates a new Root CA certificate for the local proxies.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSendRequest

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/sendRequest/?request=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/sendRequest/?request=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/sendRequest/', params={
  'request': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/sendRequest/',
  params: {
  'request' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/sendRequest/

Sends the HTTP request, optionally following redirections. Returns the request sent and response received and followed redirections, if any. The Mode is enforced when sending the request (and following redirections), custom manual requests are not allowed in 'Safe' mode nor in 'Protected' mode if out of scope.

Parameters

Name	In	Type	Required	Description
request	query	string	true	none
followRedirects	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionRunGarbageCollection

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/runGarbageCollection/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/runGarbageCollection/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/runGarbageCollection/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/runGarbageCollection/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/runGarbageCollection/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionDeleteSiteNode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/deleteSiteNode/?url=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/deleteSiteNode/?url=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/deleteSiteNode/', params={
  'url': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/deleteSiteNode/',
  params: {
  'url' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/deleteSiteNode/

Deletes the site node found in the Sites Tree on the basis of the URL, HTTP method, and post data (if applicable and specified).

Parameters

Name	In	Type	Required	Description
url	query	string	true	none
method	query	string	false	none
postData	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionAddProxyChainExcludedDomain

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/addProxyChainExcludedDomain/?value=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/addProxyChainExcludedDomain/?value=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/addProxyChainExcludedDomain/', params={
  'value': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/addProxyChainExcludedDomain/',
  params: {
  'value' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/addProxyChainExcludedDomain/

Adds a domain to be excluded from the outgoing proxy, using the specified value. Optionally sets if the new entry is enabled (default, true) and whether or not the new value is specified as a regex (default, false).

Parameters

Name	In	Type	Required	Description
value	query	string	true	none
isRegex	query	boolean	false	none
isEnabled	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionModifyProxyChainExcludedDomain

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/modifyProxyChainExcludedDomain/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/modifyProxyChainExcludedDomain/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/modifyProxyChainExcludedDomain/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/modifyProxyChainExcludedDomain/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/modifyProxyChainExcludedDomain/

Modifies a domain excluded from the outgoing proxy. Allows to modify the value, if enabled or if a regex. The domain is selected with its index, which can be obtained with the view proxyChainExcludedDomains.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none
value	query	string	false	none
isRegex	query	boolean	false	none
isEnabled	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionRemoveProxyChainExcludedDomain

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/removeProxyChainExcludedDomain/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/removeProxyChainExcludedDomain/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/removeProxyChainExcludedDomain/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/removeProxyChainExcludedDomain/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/removeProxyChainExcludedDomain/

Removes a domain excluded from the outgoing proxy, with the given index. The index can be obtained with the view proxyChainExcludedDomains.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionEnableAllProxyChainExcludedDomains

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/enableAllProxyChainExcludedDomains/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/enableAllProxyChainExcludedDomains/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/enableAllProxyChainExcludedDomains/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/enableAllProxyChainExcludedDomains/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/enableAllProxyChainExcludedDomains/

Enables all domains excluded from the outgoing proxy.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionDisableAllProxyChainExcludedDomains

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/disableAllProxyChainExcludedDomains/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/disableAllProxyChainExcludedDomains/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/disableAllProxyChainExcludedDomains/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/disableAllProxyChainExcludedDomains/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/disableAllProxyChainExcludedDomains/

Disables all domains excluded from the outgoing proxy.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionMaximumAlertInstances

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionMaximumAlertInstances/?numberOfInstances=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionMaximumAlertInstances/?numberOfInstances=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionMaximumAlertInstances/', params={
  'numberOfInstances': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionMaximumAlertInstances/',
  params: {
  'numberOfInstances' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionMaximumAlertInstances/

Sets the maximum number of alert instances to include in a report. A value of zero is treated as unlimited.

Parameters

Name	In	Type	Required	Description
numberOfInstances	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionMergeRelatedAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionMergeRelatedAlerts/?enabled=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionMergeRelatedAlerts/?enabled=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionMergeRelatedAlerts/', params={
  'enabled': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionMergeRelatedAlerts/',
  params: {
  'enabled' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionMergeRelatedAlerts/

Sets whether or not related alerts will be merged in any reports generated.

Parameters

Name	In	Type	Required	Description
enabled	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionAlertOverridesFilePath

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionAlertOverridesFilePath/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionAlertOverridesFilePath/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionAlertOverridesFilePath/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionAlertOverridesFilePath/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionAlertOverridesFilePath/

Sets (or clears, if empty) the path to the file with alert overrides.

Parameters

Name	In	Type	Required	Description
filePath	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionEnablePKCS12ClientCertificate

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/enablePKCS12ClientCertificate/?filePath=string&password=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/enablePKCS12ClientCertificate/?filePath=string&password=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/enablePKCS12ClientCertificate/', params={
  'filePath': 'string',  'password': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/enablePKCS12ClientCertificate/',
  params: {
  'filePath' => 'string',
'password' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/enablePKCS12ClientCertificate/

Enables use of a PKCS12 client certificate for the certificate with the given file system path, password, and optional index.

Parameters

Name	In	Type	Required	Description
filePath	query	string	true	none
password	query	string	true	none
index	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionDisableClientCertificate

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/disableClientCertificate/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/disableClientCertificate/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/disableClientCertificate/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/disableClientCertificate/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/disableClientCertificate/

Disables the option for use of client certificates.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionDeleteAllAlerts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/deleteAllAlerts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/deleteAllAlerts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/deleteAllAlerts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/deleteAllAlerts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/core/action/deleteAllAlerts/

Deletes all alerts of the current session.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionDeleteAlert

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/deleteAlert/?id=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/deleteAlert/?id=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/deleteAlert/', params={
  'id': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/deleteAlert/',
  params: {
  'id' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/deleteAlert/

Deletes the alert with the given ID.

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionDefaultUserAgent

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionDefaultUserAgent/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionDefaultUserAgent/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionDefaultUserAgent/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionDefaultUserAgent/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionDefaultUserAgent/

Sets the user agent that ZAP should use when creating HTTP messages (for example, spider messages or CONNECT requests to outgoing proxy).

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainName/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainName/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainName/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainName/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainName/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainPassword

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainPassword/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainPassword/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainPassword/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainPassword/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainPassword/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainRealm

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainRealm/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainRealm/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainRealm/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainRealm/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainRealm/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainSkipName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainSkipName/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainSkipName/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainSkipName/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainSkipName/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainSkipName/

Use actions [add|modify|remove]ProxyChainExcludedDomain instead.

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainUserName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainUserName/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainUserName/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainUserName/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainUserName/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainUserName/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionDnsTtlSuccessfulQueries

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionDnsTtlSuccessfulQueries/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionDnsTtlSuccessfulQueries/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionDnsTtlSuccessfulQueries/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionDnsTtlSuccessfulQueries/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionDnsTtlSuccessfulQueries/

Sets the TTL (in seconds) of successful DNS queries (applies after ZAP restart).

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionHttpStateEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionHttpStateEnabled/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionHttpStateEnabled/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionHttpStateEnabled/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionHttpStateEnabled/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionHttpStateEnabled/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainPort

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainPort/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainPort/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainPort/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainPort/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainPort/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionProxyChainPrompt

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionProxyChainPrompt/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionProxyChainPrompt/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionProxyChainPrompt/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionProxyChainPrompt/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionProxyChainPrompt/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionSingleCookieRequestHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionSingleCookieRequestHeader/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionSingleCookieRequestHeader/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionSingleCookieRequestHeader/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionSingleCookieRequestHeader/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionSingleCookieRequestHeader/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionTimeoutInSecs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionTimeoutInSecs/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionTimeoutInSecs/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionTimeoutInSecs/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionTimeoutInSecs/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionTimeoutInSecs/

Sets the connection time out, in seconds.

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionUseProxyChain

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionUseProxyChain/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionUseProxyChain/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionUseProxyChain/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionUseProxyChain/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionUseProxyChain/

Sets whether or not the outgoing proxy should be used. The address/hostname of the outgoing proxy must be set to enable this option.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreActionSetOptionUseProxyChainAuth

Code samples

# You can also use wget
curl -X GET http://zap/JSON/core/action/setOptionUseProxyChainAuth/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/core/action/setOptionUseProxyChainAuth/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/core/action/setOptionUseProxyChainAuth/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/core/action/setOptionUseProxyChainAuth/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/core/action/setOptionUseProxyChainAuth/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherProxy.pac

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/proxy.pac/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/proxy.pac/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/proxy.pac/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/proxy.pac/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/proxy.pac/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherRootcert

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/rootcert/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/rootcert/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/rootcert/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/rootcert/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/rootcert/

Gets the Root CA certificate used by the local proxies.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherSetproxy

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/setproxy/?proxy=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/setproxy/?proxy=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/setproxy/', params={
  'proxy': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/setproxy/',
  params: {
  'proxy' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/setproxy/

Parameters

Name	In	Type	Required	Description
proxy	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherXmlreport

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/xmlreport/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/xmlreport/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/xmlreport/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/xmlreport/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/xmlreport/

Generates a report in XML format

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherHtmlreport

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/htmlreport/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/htmlreport/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/htmlreport/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/htmlreport/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/htmlreport/

Generates a report in HTML format

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherJsonreport

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/jsonreport/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/jsonreport/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/jsonreport/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/jsonreport/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/jsonreport/

Generates a report in JSON format

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherMdreport

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/mdreport/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/mdreport/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/mdreport/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/mdreport/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/mdreport/

Generates a report in Markdown format

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherMessageHar

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/messageHar/?id=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/messageHar/?id=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/messageHar/', params={
  'id': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/messageHar/',
  params: {
  'id' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/messageHar/

Gets the message with the given ID in HAR format

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherMessagesHar

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/messagesHar/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/messagesHar/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/messagesHar/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/messagesHar/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/messagesHar/

Gets the HTTP messages sent through/by ZAP, in HAR format, optionally filtered by URL and paginated with 'start' position and 'count' of messages

Parameters

Name	In	Type	Required	Description
baseurl	query	string	false	none
start	query	integer	false	none
count	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherMessagesHarById

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/messagesHarById/?ids=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/messagesHarById/?ids=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/messagesHarById/', params={
  'ids': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/messagesHarById/',
  params: {
  'ids' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/messagesHarById/

Gets the HTTP messages with the given IDs, in HAR format.

Parameters

Name	In	Type	Required	Description
ids	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

coreOtherSendHarRequest

Code samples

# You can also use wget
curl -X GET http://zap/OTHER/core/other/sendHarRequest/?request=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/OTHER/core/other/sendHarRequest/?request=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/OTHER/core/other/sendHarRequest/', params={
  'request': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/OTHER/core/other/sendHarRequest/',
  params: {
  'request' => 'string'
}, headers: headers

p JSON.parse(result)

GET /OTHER/core/other/sendHarRequest/

Sends the first HAR request entry, optionally following redirections. Returns, in HAR format, the request sent and response received and followed redirections, if any. The Mode is enforced when sending the request (and following redirections), custom manual requests are not allowed in 'Safe' mode nor in 'Protected' mode if out of scope.

Parameters

Name	In	Type	Required	Description
request	query	string	true	none
followRedirects	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

params

paramsViewParams

Code samples

# You can also use wget
curl -X GET http://zap/JSON/params/view/params/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/params/view/params/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/params/view/params/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/params/view/params/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/params/view/params/

Shows the parameters for the specified site, or for all sites if the site is not specified

Parameters

Name	In	Type	Required	Description
site	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascan

ascanViewStatus

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/status/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/status/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/status/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/status/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/status/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewScanProgress

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/scanProgress/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/scanProgress/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/scanProgress/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/scanProgress/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/scanProgress/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewMessagesIds

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/messagesIds/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/messagesIds/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/messagesIds/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/messagesIds/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/messagesIds/

Gets the IDs of the messages sent during the scan with the given ID. A message can be obtained with 'message' core view.

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewAlertsIds

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/alertsIds/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/alertsIds/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/alertsIds/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/alertsIds/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/alertsIds/

Gets the IDs of the alerts raised during the scan with the given ID. An alert can be obtained with 'alert' core view.

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/scans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/scans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/scans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/scans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/scans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewScanPolicyNames

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/scanPolicyNames/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/scanPolicyNames/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/scanPolicyNames/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/scanPolicyNames/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/scanPolicyNames/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewExcludedFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/excludedFromScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/excludedFromScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/excludedFromScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/excludedFromScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/excludedFromScan/

Gets the regexes of URLs excluded from the active scans.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/scanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/scanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/scanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/scanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/scanners/

Gets the scanners, optionally, of the given scan policy and/or scanner policy/category ID.

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	false	none
policyId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewPolicies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/policies/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/policies/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/policies/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/policies/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/policies/

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	false	none
policyId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewAttackModeQueue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/attackModeQueue/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/attackModeQueue/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/attackModeQueue/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/attackModeQueue/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/attackModeQueue/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewExcludedParams

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/excludedParams/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/excludedParams/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/excludedParams/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/excludedParams/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/excludedParams/

Gets all the parameters that are excluded. For each parameter the following are shown: the name, the URL, and the parameter type.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionExcludedParamList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionExcludedParamList/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionExcludedParamList/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionExcludedParamList/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionExcludedParamList/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionExcludedParamList/

Use view excludedParams instead.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewExcludedParamTypes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/excludedParamTypes/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/excludedParamTypes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/excludedParamTypes/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/excludedParamTypes/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/excludedParamTypes/

Gets all the types of excluded parameters. For each type the following are shown: the ID and the name.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionAttackPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionAttackPolicy/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionAttackPolicy/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionAttackPolicy/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionAttackPolicy/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionAttackPolicy/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionDefaultPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionDefaultPolicy/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionDefaultPolicy/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionDefaultPolicy/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionDefaultPolicy/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionDefaultPolicy/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionDelayInMs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionDelayInMs/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionDelayInMs/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionDelayInMs/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionDelayInMs/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionDelayInMs/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionHandleAntiCSRFTokens

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionHandleAntiCSRFTokens/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionHandleAntiCSRFTokens/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionHandleAntiCSRFTokens/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionHandleAntiCSRFTokens/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionHandleAntiCSRFTokens/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionHostPerScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionHostPerScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionHostPerScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionHostPerScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionHostPerScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionHostPerScan/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionMaxChartTimeInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionMaxChartTimeInMins/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionMaxChartTimeInMins/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionMaxChartTimeInMins/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionMaxChartTimeInMins/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionMaxChartTimeInMins/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionMaxResultsToList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionMaxResultsToList/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionMaxResultsToList/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionMaxResultsToList/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionMaxResultsToList/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionMaxResultsToList/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionMaxRuleDurationInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionMaxRuleDurationInMins/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionMaxRuleDurationInMins/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionMaxRuleDurationInMins/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionMaxRuleDurationInMins/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionMaxRuleDurationInMins/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionMaxScanDurationInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionMaxScanDurationInMins/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionMaxScanDurationInMins/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionMaxScanDurationInMins/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionMaxScanDurationInMins/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionMaxScanDurationInMins/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionMaxScansInUI

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionMaxScansInUI/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionMaxScansInUI/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionMaxScansInUI/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionMaxScansInUI/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionMaxScansInUI/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionTargetParamsEnabledRPC

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionTargetParamsEnabledRPC/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionTargetParamsEnabledRPC/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionTargetParamsEnabledRPC/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionTargetParamsEnabledRPC/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionTargetParamsEnabledRPC/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionTargetParamsInjectable

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionTargetParamsInjectable/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionTargetParamsInjectable/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionTargetParamsInjectable/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionTargetParamsInjectable/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionTargetParamsInjectable/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionThreadPerHost

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionThreadPerHost/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionThreadPerHost/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionThreadPerHost/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionThreadPerHost/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionThreadPerHost/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionAddQueryParam

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionAddQueryParam/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionAddQueryParam/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionAddQueryParam/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionAddQueryParam/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionAddQueryParam/

Tells whether or not the active scanner should add a query parameter to GET request that don't have parameters to start with.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionAllowAttackOnStart

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionAllowAttackOnStart/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionAllowAttackOnStart/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionAllowAttackOnStart/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionAllowAttackOnStart/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionAllowAttackOnStart/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionInjectPluginIdInHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionInjectPluginIdInHeader/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionInjectPluginIdInHeader/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionInjectPluginIdInHeader/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionInjectPluginIdInHeader/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionInjectPluginIdInHeader/

Tells whether or not the active scanner should inject the HTTP request header X-ZAP-Scan-ID, with the ID of the scanner that's sending the requests.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionPromptInAttackMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionPromptInAttackMode/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionPromptInAttackMode/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionPromptInAttackMode/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionPromptInAttackMode/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionPromptInAttackMode/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionPromptToClearFinishedScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionPromptToClearFinishedScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionPromptToClearFinishedScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionPromptToClearFinishedScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionPromptToClearFinishedScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionPromptToClearFinishedScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionRescanInAttackMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionRescanInAttackMode/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionRescanInAttackMode/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionRescanInAttackMode/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionRescanInAttackMode/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionRescanInAttackMode/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionScanHeadersAllRequests

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionScanHeadersAllRequests/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionScanHeadersAllRequests/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionScanHeadersAllRequests/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionScanHeadersAllRequests/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionScanHeadersAllRequests/

Tells whether or not the HTTP Headers of all requests should be scanned. Not just requests that send parameters, through the query or request body.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanViewOptionShowAdvancedDialog

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/view/optionShowAdvancedDialog/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/view/optionShowAdvancedDialog/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/view/optionShowAdvancedDialog/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/view/optionShowAdvancedDialog/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/view/optionShowAdvancedDialog/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/scan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/scan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/scan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/scan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/scan/

Runs the active scanner against the given URL and/or Context. Optionally, the 'recurse' parameter can be used to scan URLs under the given URL, the parameter 'inScopeOnly' can be used to constrain the scan to URLs that are in scope (ignored if a Context is specified), the parameter 'scanPolicyName' allows to specify the scan policy (if none is given it uses the default scan policy), the parameters 'method' and 'postData' allow to select a given request in conjunction with the given URL.

Parameters

Name	In	Type	Required	Description
url	query	string	false	none
recurse	query	boolean	false	none
inScopeOnly	query	boolean	false	none
scanPolicyName	query	string	false	none
method	query	string	false	none
postData	query	string	false	none
contextId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionScanAsUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/scanAsUser/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/scanAsUser/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/scanAsUser/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/scanAsUser/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/scanAsUser/

Active Scans from the perspective of a User, obtained using the given Context ID and User ID. See 'scan' action for more details.

Parameters

Name	In	Type	Required	Description
url	query	string	false	none
contextId	query	integer	false	none
userId	query	integer	false	none
recurse	query	boolean	false	none
scanPolicyName	query	string	false	none
method	query	string	false	none
postData	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionPause

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/pause/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/pause/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/pause/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/pause/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/pause/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionResume

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/resume/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/resume/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/resume/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/resume/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/resume/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionStop

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/stop/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/stop/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/stop/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/stop/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/stop/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionRemoveScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/removeScan/?scanId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/removeScan/?scanId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/removeScan/', params={
  'scanId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/removeScan/',
  params: {
  'scanId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/removeScan/

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionPauseAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/pauseAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/pauseAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/pauseAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/pauseAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/pauseAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionResumeAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/resumeAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/resumeAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/resumeAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/resumeAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/resumeAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionStopAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/stopAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/stopAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/stopAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/stopAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/stopAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionRemoveAllScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/removeAllScans/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/removeAllScans/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/removeAllScans/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/removeAllScans/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/removeAllScans/

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionClearExcludedFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/clearExcludedFromScan/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/clearExcludedFromScan/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/clearExcludedFromScan/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/clearExcludedFromScan/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/clearExcludedFromScan/

Clears the regexes of URLs excluded from the active scans.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionExcludeFromScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/excludeFromScan/?regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/excludeFromScan/?regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/excludeFromScan/', params={
  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/excludeFromScan/',
  params: {
  'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/excludeFromScan/

Adds a regex of URLs that should be excluded from the active scans.

Parameters

Name	In	Type	Required	Description
regex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionEnableAllScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/enableAllScanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/enableAllScanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/enableAllScanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/enableAllScanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/enableAllScanners/

Enables all scanners of the scan policy with the given name, or the default if none given.

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionDisableAllScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/disableAllScanners/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/disableAllScanners/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/disableAllScanners/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/disableAllScanners/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/disableAllScanners/

Disables all scanners of the scan policy with the given name, or the default if none given.

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionEnableScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/enableScanners/?ids=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/enableScanners/?ids=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/enableScanners/', params={
  'ids': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/enableScanners/',
  params: {
  'ids' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/enableScanners/

Enables the scanners with the given IDs (comma separated list of IDs) of the scan policy with the given name, or the default if none given.

Parameters

Name	In	Type	Required	Description
ids	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionDisableScanners

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/disableScanners/?ids=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/disableScanners/?ids=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/disableScanners/', params={
  'ids': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/disableScanners/',
  params: {
  'ids' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/disableScanners/

Disables the scanners with the given IDs (comma separated list of IDs) of the scan policy with the given name, or the default if none given.

Parameters

Name	In	Type	Required	Description
ids	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetEnabledPolicies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setEnabledPolicies/?ids=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setEnabledPolicies/?ids=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setEnabledPolicies/', params={
  'ids': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setEnabledPolicies/',
  params: {
  'ids' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setEnabledPolicies/

Parameters

Name	In	Type	Required	Description
ids	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetPolicyAttackStrength

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setPolicyAttackStrength/?id=0&attackStrength=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setPolicyAttackStrength/?id=0&attackStrength=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setPolicyAttackStrength/', params={
  'id': '0',  'attackStrength': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setPolicyAttackStrength/',
  params: {
  'id' => 'integer',
'attackStrength' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setPolicyAttackStrength/

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none
attackStrength	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetPolicyAlertThreshold

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setPolicyAlertThreshold/?id=0&alertThreshold=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setPolicyAlertThreshold/?id=0&alertThreshold=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setPolicyAlertThreshold/', params={
  'id': '0',  'alertThreshold': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setPolicyAlertThreshold/',
  params: {
  'id' => 'integer',
'alertThreshold' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setPolicyAlertThreshold/

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none
alertThreshold	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetScannerAttackStrength

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setScannerAttackStrength/?id=0&attackStrength=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setScannerAttackStrength/?id=0&attackStrength=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setScannerAttackStrength/', params={
  'id': '0',  'attackStrength': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setScannerAttackStrength/',
  params: {
  'id' => 'integer',
'attackStrength' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setScannerAttackStrength/

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none
attackStrength	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetScannerAlertThreshold

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setScannerAlertThreshold/?id=0&alertThreshold=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setScannerAlertThreshold/?id=0&alertThreshold=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setScannerAlertThreshold/', params={
  'id': '0',  'alertThreshold': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setScannerAlertThreshold/',
  params: {
  'id' => 'integer',
'alertThreshold' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setScannerAlertThreshold/

Parameters

Name	In	Type	Required	Description
id	query	integer	true	none
alertThreshold	query	string	true	none
scanPolicyName	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionAddScanPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/addScanPolicy/?scanPolicyName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/addScanPolicy/?scanPolicyName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/addScanPolicy/', params={
  'scanPolicyName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/addScanPolicy/',
  params: {
  'scanPolicyName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/addScanPolicy/

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	true	none
alertThreshold	query	string	false	none
attackStrength	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionRemoveScanPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/removeScanPolicy/?scanPolicyName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/removeScanPolicy/?scanPolicyName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/removeScanPolicy/', params={
  'scanPolicyName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/removeScanPolicy/',
  params: {
  'scanPolicyName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/removeScanPolicy/

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionUpdateScanPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/updateScanPolicy/?scanPolicyName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/updateScanPolicy/?scanPolicyName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/updateScanPolicy/', params={
  'scanPolicyName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/updateScanPolicy/',
  params: {
  'scanPolicyName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/updateScanPolicy/

Parameters

Name	In	Type	Required	Description
scanPolicyName	query	string	true	none
alertThreshold	query	string	false	none
attackStrength	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionImportScanPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/importScanPolicy/?path=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/importScanPolicy/?path=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/importScanPolicy/', params={
  'path': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/importScanPolicy/',
  params: {
  'path' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/importScanPolicy/

Imports a Scan Policy using the given file system path.

Parameters

Name	In	Type	Required	Description
path	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionAddExcludedParam

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/addExcludedParam/?name=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/addExcludedParam/?name=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/addExcludedParam/', params={
  'name': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/addExcludedParam/',
  params: {
  'name' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/addExcludedParam/

Adds a new parameter excluded from the scan, using the specified name. Optionally sets if the new entry applies to a specific URL (default, all URLs) and sets the ID of the type of the parameter (default, ID of any type). The type IDs can be obtained with the view excludedParamTypes.

Parameters

Name	In	Type	Required	Description
name	query	string	true	none
type	query	string	false	none
url	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionModifyExcludedParam

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/modifyExcludedParam/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/modifyExcludedParam/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/modifyExcludedParam/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/modifyExcludedParam/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/modifyExcludedParam/

Modifies a parameter excluded from the scan. Allows to modify the name, the URL and the type of parameter. The parameter is selected with its index, which can be obtained with the view excludedParams.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none
name	query	string	false	none
type	query	string	false	none
url	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionRemoveExcludedParam

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/removeExcludedParam/?idx=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/removeExcludedParam/?idx=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/removeExcludedParam/', params={
  'idx': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/removeExcludedParam/',
  params: {
  'idx' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/removeExcludedParam/

Removes a parameter excluded from the scan, with the given index. The index can be obtained with the view excludedParams.

Parameters

Name	In	Type	Required	Description
idx	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSkipScanner

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/skipScanner/?scanId=0&scannerId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/skipScanner/?scanId=0&scannerId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/skipScanner/', params={
  'scanId': '0',  'scannerId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/skipScanner/',
  params: {
  'scanId' => 'integer',
'scannerId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/skipScanner/

Skips the scanner using the given IDs of the scan and the scanner.

Parameters

Name	In	Type	Required	Description
scanId	query	integer	true	none
scannerId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionAttackPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionAttackPolicy/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionAttackPolicy/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionAttackPolicy/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionAttackPolicy/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionAttackPolicy/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionDefaultPolicy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionDefaultPolicy/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionDefaultPolicy/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionDefaultPolicy/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionDefaultPolicy/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionDefaultPolicy/

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionAddQueryParam

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionAddQueryParam/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionAddQueryParam/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionAddQueryParam/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionAddQueryParam/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionAddQueryParam/

Sets whether or not the active scanner should add a query param to GET requests which do not have parameters to start with.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionAllowAttackOnStart

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionAllowAttackOnStart/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionAllowAttackOnStart/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionAllowAttackOnStart/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionAllowAttackOnStart/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionAllowAttackOnStart/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionDelayInMs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionDelayInMs/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionDelayInMs/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionDelayInMs/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionDelayInMs/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionDelayInMs/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionHandleAntiCSRFTokens

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionHandleAntiCSRFTokens/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionHandleAntiCSRFTokens/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionHandleAntiCSRFTokens/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionHandleAntiCSRFTokens/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionHandleAntiCSRFTokens/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionHostPerScan

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionHostPerScan/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionHostPerScan/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionHostPerScan/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionHostPerScan/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionHostPerScan/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionInjectPluginIdInHeader

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionInjectPluginIdInHeader/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionInjectPluginIdInHeader/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionInjectPluginIdInHeader/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionInjectPluginIdInHeader/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionInjectPluginIdInHeader/

Sets whether or not the active scanner should inject the HTTP request header X-ZAP-Scan-ID, with the ID of the scanner that's sending the requests.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionMaxChartTimeInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionMaxChartTimeInMins/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionMaxChartTimeInMins/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionMaxChartTimeInMins/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionMaxChartTimeInMins/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionMaxChartTimeInMins/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionMaxResultsToList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionMaxResultsToList/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionMaxResultsToList/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionMaxResultsToList/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionMaxResultsToList/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionMaxResultsToList/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionMaxRuleDurationInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionMaxRuleDurationInMins/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionMaxRuleDurationInMins/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionMaxRuleDurationInMins/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionMaxRuleDurationInMins/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionMaxRuleDurationInMins/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionMaxScanDurationInMins

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionMaxScanDurationInMins/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionMaxScanDurationInMins/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionMaxScanDurationInMins/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionMaxScanDurationInMins/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionMaxScanDurationInMins/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionMaxScansInUI

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionMaxScansInUI/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionMaxScansInUI/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionMaxScansInUI/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionMaxScansInUI/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionMaxScansInUI/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionPromptInAttackMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionPromptInAttackMode/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionPromptInAttackMode/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionPromptInAttackMode/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionPromptInAttackMode/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionPromptInAttackMode/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionPromptToClearFinishedScans

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionPromptToClearFinishedScans/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionPromptToClearFinishedScans/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionPromptToClearFinishedScans/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionPromptToClearFinishedScans/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionPromptToClearFinishedScans/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionRescanInAttackMode

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionRescanInAttackMode/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionRescanInAttackMode/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionRescanInAttackMode/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionRescanInAttackMode/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionRescanInAttackMode/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionScanHeadersAllRequests

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionScanHeadersAllRequests/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionScanHeadersAllRequests/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionScanHeadersAllRequests/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionScanHeadersAllRequests/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionScanHeadersAllRequests/

Sets whether or not the HTTP Headers of all requests should be scanned. Not just requests that send parameters, through the query or request body.

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionShowAdvancedDialog

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionShowAdvancedDialog/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionShowAdvancedDialog/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionShowAdvancedDialog/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionShowAdvancedDialog/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionShowAdvancedDialog/

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionTargetParamsEnabledRPC

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionTargetParamsEnabledRPC/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionTargetParamsEnabledRPC/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionTargetParamsEnabledRPC/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionTargetParamsEnabledRPC/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionTargetParamsEnabledRPC/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionTargetParamsInjectable

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionTargetParamsInjectable/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionTargetParamsInjectable/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionTargetParamsInjectable/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionTargetParamsInjectable/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionTargetParamsInjectable/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ascanActionSetOptionThreadPerHost

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ascan/action/setOptionThreadPerHost/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ascan/action/setOptionThreadPerHost/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ascan/action/setOptionThreadPerHost/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ascan/action/setOptionThreadPerHost/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/ascan/action/setOptionThreadPerHost/

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

context

contextViewContextList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/contextList/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/contextList/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/contextList/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/contextList/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/context/view/contextList/

List context names of current session

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewExcludeRegexs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/excludeRegexs/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/excludeRegexs/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/excludeRegexs/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/excludeRegexs/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/excludeRegexs/

List excluded regexs for context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewIncludeRegexs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/includeRegexs/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/includeRegexs/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/includeRegexs/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/includeRegexs/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/includeRegexs/

List included regexs for context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/context/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/context/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/context/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/context/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/context/

List the information about the named context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewTechnologyList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/technologyList/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/technologyList/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/technologyList/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/technologyList/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/context/view/technologyList/

Lists the names of all built in technologies

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewIncludedTechnologyList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/includedTechnologyList/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/includedTechnologyList/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/includedTechnologyList/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/includedTechnologyList/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/includedTechnologyList/

Lists the names of all technologies included in a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewExcludedTechnologyList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/excludedTechnologyList/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/excludedTechnologyList/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/excludedTechnologyList/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/excludedTechnologyList/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/excludedTechnologyList/

Lists the names of all technologies excluded from a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextViewUrls

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/view/urls/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/view/urls/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/view/urls/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/view/urls/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/view/urls/

Lists the URLs accessed through/by ZAP, that belong to the context with the given name.

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionExcludeFromContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/excludeFromContext/?contextName=string&regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/excludeFromContext/?contextName=string&regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/excludeFromContext/', params={
  'contextName': 'string',  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/excludeFromContext/',
  params: {
  'contextName' => 'string',
'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/excludeFromContext/

Add exclude regex to context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
regex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionIncludeInContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/includeInContext/?contextName=string&regex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/includeInContext/?contextName=string&regex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/includeInContext/', params={
  'contextName': 'string',  'regex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/includeInContext/',
  params: {
  'contextName' => 'string',
'regex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/includeInContext/

Add include regex to context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
regex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionSetContextRegexs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/setContextRegexs/?contextName=string&incRegexs=string&excRegexs=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/setContextRegexs/?contextName=string&incRegexs=string&excRegexs=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/setContextRegexs/', params={
  'contextName': 'string',  'incRegexs': 'string',  'excRegexs': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/setContextRegexs/',
  params: {
  'contextName' => 'string',
'incRegexs' => 'string',
'excRegexs' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/setContextRegexs/

Set the regexs to include and exclude for a context, both supplied as JSON string arrays

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
incRegexs	query	string	true	none
excRegexs	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionNewContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/newContext/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/newContext/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/newContext/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/newContext/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/newContext/

Creates a new context with the given name in the current session

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionRemoveContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/removeContext/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/removeContext/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/removeContext/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/removeContext/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/removeContext/

Removes a context in the current session

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionExportContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/exportContext/?contextName=string&contextFile=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/exportContext/?contextName=string&contextFile=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/exportContext/', params={
  'contextName': 'string',  'contextFile': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/exportContext/',
  params: {
  'contextName' => 'string',
'contextFile' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/exportContext/

Exports the context with the given name to a file. If a relative file path is specified it will be resolved against the "contexts" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
contextFile	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionImportContext

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/importContext/?contextFile=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/importContext/?contextFile=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/importContext/', params={
  'contextFile': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/importContext/',
  params: {
  'contextFile' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/importContext/

Imports a context from a file. If a relative file path is specified it will be resolved against the "contexts" directory in ZAP "home" dir.

Parameters

Name	In	Type	Required	Description
contextFile	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionIncludeContextTechnologies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/includeContextTechnologies/?contextName=string&technologyNames=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/includeContextTechnologies/?contextName=string&technologyNames=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/includeContextTechnologies/', params={
  'contextName': 'string',  'technologyNames': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/includeContextTechnologies/',
  params: {
  'contextName' => 'string',
'technologyNames' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/includeContextTechnologies/

Includes technologies with the given names, separated by a comma, to a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
technologyNames	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionIncludeAllContextTechnologies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/includeAllContextTechnologies/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/includeAllContextTechnologies/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/includeAllContextTechnologies/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/includeAllContextTechnologies/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/includeAllContextTechnologies/

Includes all built in technologies in to a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionExcludeContextTechnologies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/excludeContextTechnologies/?contextName=string&technologyNames=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/excludeContextTechnologies/?contextName=string&technologyNames=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/excludeContextTechnologies/', params={
  'contextName': 'string',  'technologyNames': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/excludeContextTechnologies/',
  params: {
  'contextName' => 'string',
'technologyNames' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/excludeContextTechnologies/

Excludes technologies with the given names, separated by a comma, from a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
technologyNames	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionExcludeAllContextTechnologies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/excludeAllContextTechnologies/?contextName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/excludeAllContextTechnologies/?contextName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/excludeAllContextTechnologies/', params={
  'contextName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/excludeAllContextTechnologies/',
  params: {
  'contextName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/excludeAllContextTechnologies/

Excludes all built in technologies from a context

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

contextActionSetContextInScope

Code samples

# You can also use wget
curl -X GET http://zap/JSON/context/action/setContextInScope/?contextName=string&booleanInScope=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/context/action/setContextInScope/?contextName=string&booleanInScope=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/context/action/setContextInScope/', params={
  'contextName': 'string',  'booleanInScope': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/context/action/setContextInScope/',
  params: {
  'contextName' => 'string',
'booleanInScope' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/context/action/setContextInScope/

Sets a context to in scope (contexts are in scope by default)

Parameters

Name	In	Type	Required	Description
contextName	query	string	true	none
booleanInScope	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessions

httpSessionsViewSites

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/view/sites/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/view/sites/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/view/sites/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/view/sites/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/view/sites/

Gets all of the sites that have sessions.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsViewSessions

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/view/sessions/?site=string&session=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/view/sessions/?site=string&session=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/view/sessions/', params={
  'site': 'string',  'session': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/view/sessions/',
  params: {
  'site' => 'string',
'session' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/view/sessions/

Gets the sessions for the given site. Optionally returning just the session with the given name.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
session	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsViewActiveSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/view/activeSession/?site=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/view/activeSession/?site=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/view/activeSession/', params={
  'site': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/view/activeSession/',
  params: {
  'site' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/view/activeSession/

Gets the name of the active session for the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsViewSessionTokens

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/view/sessionTokens/?site=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/view/sessionTokens/?site=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/view/sessionTokens/', params={
  'site': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/view/sessionTokens/',
  params: {
  'site' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/view/sessionTokens/

Gets the names of the session tokens for the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsViewDefaultSessionTokens

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/view/defaultSessionTokens/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/view/defaultSessionTokens/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/view/defaultSessionTokens/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/view/defaultSessionTokens/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/view/defaultSessionTokens/

Gets the default session tokens.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionCreateEmptySession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/createEmptySession/?site=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/createEmptySession/?site=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/createEmptySession/', params={
  'site': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/createEmptySession/',
  params: {
  'site' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/createEmptySession/

Creates an empty session for the given site. Optionally with the given name.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
session	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionRemoveSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/removeSession/?site=string&session=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/removeSession/?site=string&session=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/removeSession/', params={
  'site': 'string',  'session': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/removeSession/',
  params: {
  'site' => 'string',
'session' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/removeSession/

Removes the session from the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
session	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionSetActiveSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/setActiveSession/?site=string&session=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/setActiveSession/?site=string&session=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/setActiveSession/', params={
  'site': 'string',  'session': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/setActiveSession/',
  params: {
  'site' => 'string',
'session' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/setActiveSession/

Sets the given session as active for the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
session	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionUnsetActiveSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/unsetActiveSession/?site=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/unsetActiveSession/?site=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/unsetActiveSession/', params={
  'site': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/unsetActiveSession/',
  params: {
  'site' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/unsetActiveSession/

Unsets the active session of the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionAddSessionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/addSessionToken/?site=string&sessionToken=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/addSessionToken/?site=string&sessionToken=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/addSessionToken/', params={
  'site': 'string',  'sessionToken': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/addSessionToken/',
  params: {
  'site' => 'string',
'sessionToken' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/addSessionToken/

Adds the session token to the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
sessionToken	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionRemoveSessionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/removeSessionToken/?site=string&sessionToken=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/removeSessionToken/?site=string&sessionToken=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/removeSessionToken/', params={
  'site': 'string',  'sessionToken': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/removeSessionToken/',
  params: {
  'site' => 'string',
'sessionToken' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/removeSessionToken/

Removes the session token from the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
sessionToken	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionSetSessionTokenValue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/setSessionTokenValue/?site=string&session=string&sessionToken=string&tokenValue=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/setSessionTokenValue/?site=string&session=string&sessionToken=string&tokenValue=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/setSessionTokenValue/', params={
  'site': 'string',  'session': 'string',  'sessionToken': 'string',  'tokenValue': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/setSessionTokenValue/',
  params: {
  'site' => 'string',
'session' => 'string',
'sessionToken' => 'string',
'tokenValue' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/setSessionTokenValue/

Sets the value of the session token of the given session for the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
session	query	string	true	none
sessionToken	query	string	true	none
tokenValue	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionRenameSession

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/renameSession/?site=string&oldSessionName=string&newSessionName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/renameSession/?site=string&oldSessionName=string&newSessionName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/renameSession/', params={
  'site': 'string',  'oldSessionName': 'string',  'newSessionName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/renameSession/',
  params: {
  'site' => 'string',
'oldSessionName' => 'string',
'newSessionName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/renameSession/

Renames the session of the given site.

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
oldSessionName	query	string	true	none
newSessionName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionAddDefaultSessionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/addDefaultSessionToken/?sessionToken=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/addDefaultSessionToken/?sessionToken=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/addDefaultSessionToken/', params={
  'sessionToken': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/addDefaultSessionToken/',
  params: {
  'sessionToken' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/addDefaultSessionToken/

Adds a default session token with the given name and enabled state.

Parameters

Name	In	Type	Required	Description
sessionToken	query	string	true	none
tokenEnabled	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionSetDefaultSessionTokenEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/setDefaultSessionTokenEnabled/?sessionToken=string&tokenEnabled=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/setDefaultSessionTokenEnabled/?sessionToken=string&tokenEnabled=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/setDefaultSessionTokenEnabled/', params={
  'sessionToken': 'string',  'tokenEnabled': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/setDefaultSessionTokenEnabled/',
  params: {
  'sessionToken' => 'string',
'tokenEnabled' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/setDefaultSessionTokenEnabled/

Sets whether or not the default session token with the given name is enabled.

Parameters

Name	In	Type	Required	Description
sessionToken	query	string	true	none
tokenEnabled	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

httpSessionsActionRemoveDefaultSessionToken

Code samples

# You can also use wget
curl -X GET http://zap/JSON/httpSessions/action/removeDefaultSessionToken/?sessionToken=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/httpSessions/action/removeDefaultSessionToken/?sessionToken=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/httpSessions/action/removeDefaultSessionToken/', params={
  'sessionToken': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/httpSessions/action/removeDefaultSessionToken/',
  params: {
  'sessionToken' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/httpSessions/action/removeDefaultSessionToken/

Removes the default session token with the given name.

Parameters

Name	In	Type	Required	Description
sessionToken	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

break

breakViewIsBreakAll

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/view/isBreakAll/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/view/isBreakAll/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/view/isBreakAll/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/view/isBreakAll/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/view/isBreakAll/

Returns True if ZAP will break on both requests and responses

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakViewIsBreakRequest

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/view/isBreakRequest/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/view/isBreakRequest/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/view/isBreakRequest/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/view/isBreakRequest/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/view/isBreakRequest/

Returns True if ZAP will break on requests

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakViewIsBreakResponse

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/view/isBreakResponse/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/view/isBreakResponse/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/view/isBreakResponse/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/view/isBreakResponse/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/view/isBreakResponse/

Returns True if ZAP will break on responses

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakViewHttpMessage

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/view/httpMessage/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/view/httpMessage/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/view/httpMessage/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/view/httpMessage/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/view/httpMessage/

Returns the HTTP message currently intercepted (if any)

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionBreak

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/break/?type=string&state=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/break/?type=string&state=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/break/', params={
  'type': 'string',  'state': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/break/',
  params: {
  'type' => 'string',
'state' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/break/action/break/

Controls the global break functionality. The type may be one of: http-all, http-request or http-response. The state may be true (for turning break on for the specified type) or false (for turning break off). Scope is not currently used.

Parameters

Name	In	Type	Required	Description
type	query	string	true	none
state	query	string	true	none
scope	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionSetHttpMessage

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/setHttpMessage/?httpHeader=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/setHttpMessage/?httpHeader=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/setHttpMessage/', params={
  'httpHeader': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/setHttpMessage/',
  params: {
  'httpHeader' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/break/action/setHttpMessage/

Overwrites the currently intercepted message with the data provided

Parameters

Name	In	Type	Required	Description
httpHeader	query	string	true	none
httpBody	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionContinue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/continue/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/continue/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/continue/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/continue/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/action/continue/

Submits the currently intercepted message and unsets the global request/response break points

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionStep

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/step/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/step/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/step/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/step/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/action/step/

Submits the currently intercepted message, the next request or response will automatically be intercepted

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionDrop

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/drop/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/drop/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/drop/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/drop/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/break/action/drop/

Drops the currently intercepted message

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionAddHttpBreakpoint

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/addHttpBreakpoint/?string=string&location=string&match=string&inverse=true&ignorecase=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/addHttpBreakpoint/?string=string&location=string&match=string&inverse=true&ignorecase=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/addHttpBreakpoint/', params={
  'string': 'string',  'location': 'string',  'match': 'string',  'inverse': 'true',  'ignorecase': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/addHttpBreakpoint/',
  params: {
  'string' => 'string',
'location' => 'string',
'match' => 'string',
'inverse' => 'boolean',
'ignorecase' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/break/action/addHttpBreakpoint/

Adds a custom HTTP breakpoint. The string is the string to match. Location may be one of: url, request_header, request_body, response_header or response_body. Match may be: contains or regex. Inverse (match) may be true or false. Lastly, ignorecase (when matching the string) may be true or false.

Parameters

Name	In	Type	Required	Description
string	query	string	true	none
location	query	string	true	none
match	query	string	true	none
inverse	query	boolean	true	none
ignorecase	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

breakActionRemoveHttpBreakpoint

Code samples

# You can also use wget
curl -X GET http://zap/JSON/break/action/removeHttpBreakpoint/?string=string&location=string&match=string&inverse=true&ignorecase=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/break/action/removeHttpBreakpoint/?string=string&location=string&match=string&inverse=true&ignorecase=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/break/action/removeHttpBreakpoint/', params={
  'string': 'string',  'location': 'string',  'match': 'string',  'inverse': 'true',  'ignorecase': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/break/action/removeHttpBreakpoint/',
  params: {
  'string' => 'string',
'location' => 'string',
'match' => 'string',
'inverse' => 'boolean',
'ignorecase' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/break/action/removeHttpBreakpoint/

Removes the specified break point

Parameters

Name	In	Type	Required	Description
string	query	string	true	none
location	query	string	true	none
match	query	string	true	none
inverse	query	boolean	true	none
ignorecase	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authentication

authenticationViewGetSupportedAuthenticationMethods

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/view/getSupportedAuthenticationMethods/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/view/getSupportedAuthenticationMethods/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/view/getSupportedAuthenticationMethods/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/view/getSupportedAuthenticationMethods/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/authentication/view/getSupportedAuthenticationMethods/

Gets the name of the authentication methods.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationViewGetAuthenticationMethodConfigParams

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/view/getAuthenticationMethodConfigParams/?authMethodName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/view/getAuthenticationMethodConfigParams/?authMethodName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/view/getAuthenticationMethodConfigParams/', params={
  'authMethodName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/view/getAuthenticationMethodConfigParams/',
  params: {
  'authMethodName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/view/getAuthenticationMethodConfigParams/

Gets the configuration parameters for the authentication method with the given name.

Parameters

Name	In	Type	Required	Description
authMethodName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationViewGetAuthenticationMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/view/getAuthenticationMethod/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/view/getAuthenticationMethod/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/view/getAuthenticationMethod/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/view/getAuthenticationMethod/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/view/getAuthenticationMethod/

Gets the name of the authentication method for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationViewGetLoggedInIndicator

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/view/getLoggedInIndicator/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/view/getLoggedInIndicator/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/view/getLoggedInIndicator/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/view/getLoggedInIndicator/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/view/getLoggedInIndicator/

Gets the logged in indicator for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationViewGetLoggedOutIndicator

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/view/getLoggedOutIndicator/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/view/getLoggedOutIndicator/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/view/getLoggedOutIndicator/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/view/getLoggedOutIndicator/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/view/getLoggedOutIndicator/

Gets the logged out indicator for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationActionSetAuthenticationMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/action/setAuthenticationMethod/?contextId=0&authMethodName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/action/setAuthenticationMethod/?contextId=0&authMethodName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/action/setAuthenticationMethod/', params={
  'contextId': '0',  'authMethodName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/action/setAuthenticationMethod/',
  params: {
  'contextId' => 'integer',
'authMethodName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/action/setAuthenticationMethod/

Sets the authentication method for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
authMethodName	query	string	true	none
authMethodConfigParams	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationActionSetLoggedInIndicator

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/action/setLoggedInIndicator/?contextId=0&loggedInIndicatorRegex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/action/setLoggedInIndicator/?contextId=0&loggedInIndicatorRegex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/action/setLoggedInIndicator/', params={
  'contextId': '0',  'loggedInIndicatorRegex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/action/setLoggedInIndicator/',
  params: {
  'contextId' => 'integer',
'loggedInIndicatorRegex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/action/setLoggedInIndicator/

Sets the logged in indicator for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
loggedInIndicatorRegex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authenticationActionSetLoggedOutIndicator

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authentication/action/setLoggedOutIndicator/?contextId=0&loggedOutIndicatorRegex=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authentication/action/setLoggedOutIndicator/?contextId=0&loggedOutIndicatorRegex=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authentication/action/setLoggedOutIndicator/', params={
  'contextId': '0',  'loggedOutIndicatorRegex': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authentication/action/setLoggedOutIndicator/',
  params: {
  'contextId' => 'integer',
'loggedOutIndicatorRegex' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/authentication/action/setLoggedOutIndicator/

Sets the logged out indicator for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
loggedOutIndicatorRegex	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authorization

authorizationViewGetAuthorizationDetectionMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authorization/view/getAuthorizationDetectionMethod/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authorization/view/getAuthorizationDetectionMethod/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authorization/view/getAuthorizationDetectionMethod/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authorization/view/getAuthorizationDetectionMethod/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/authorization/view/getAuthorizationDetectionMethod/

Obtains all the configuration of the authorization detection method that is currently set for a context.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

authorizationActionSetBasicAuthorizationDetectionMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/authorization/action/setBasicAuthorizationDetectionMethod/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/authorization/action/setBasicAuthorizationDetectionMethod/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/authorization/action/setBasicAuthorizationDetectionMethod/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/authorization/action/setBasicAuthorizationDetectionMethod/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/authorization/action/setBasicAuthorizationDetectionMethod/

Sets the authorization detection method for a context as one that identifies un-authorized messages based on: the message's status code or a regex pattern in the response's header or body. Also, whether all conditions must match or just some can be specified via the logicalOperator parameter, which accepts two values: "AND" (default), "OR".

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
headerRegex	query	string	false	none
bodyRegex	query	string	false	none
statusCode	query	string	false	none
logicalOperator	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

localProxies

localProxiesViewAdditionalProxies

Code samples

# You can also use wget
curl -X GET http://zap/JSON/localProxies/view/additionalProxies/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/localProxies/view/additionalProxies/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/localProxies/view/additionalProxies/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/localProxies/view/additionalProxies/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/localProxies/view/additionalProxies/

Gets all of the additional proxies that have been configured.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

localProxiesActionAddAdditionalProxy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/localProxies/action/addAdditionalProxy/?address=string&port=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/localProxies/action/addAdditionalProxy/?address=string&port=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/localProxies/action/addAdditionalProxy/', params={
  'address': 'string',  'port': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/localProxies/action/addAdditionalProxy/',
  params: {
  'address' => 'string',
'port' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/localProxies/action/addAdditionalProxy/

Adds an new proxy using the details supplied.

Parameters

Name	In	Type	Required	Description
address	query	string	true	none
port	query	integer	true	none
behindNat	query	boolean	false	none
alwaysDecodeZip	query	boolean	false	none
removeUnsupportedEncodings	query	boolean	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

localProxiesActionRemoveAdditionalProxy

Code samples

# You can also use wget
curl -X GET http://zap/JSON/localProxies/action/removeAdditionalProxy/?address=string&port=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/localProxies/action/removeAdditionalProxy/?address=string&port=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/localProxies/action/removeAdditionalProxy/', params={
  'address': 'string',  'port': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/localProxies/action/removeAdditionalProxy/',
  params: {
  'address' => 'string',
'port' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/localProxies/action/removeAdditionalProxy/

Removes the additional proxy with the specified address and port.

Parameters

Name	In	Type	Required	Description
address	query	string	true	none
port	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ruleConfig

ruleConfigViewRuleConfigValue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ruleConfig/view/ruleConfigValue/?key=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ruleConfig/view/ruleConfigValue/?key=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ruleConfig/view/ruleConfigValue/', params={
  'key': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ruleConfig/view/ruleConfigValue/',
  params: {
  'key' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ruleConfig/view/ruleConfigValue/

Show the specified rule configuration

Parameters

Name	In	Type	Required	Description
key	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ruleConfigViewAllRuleConfigs

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ruleConfig/view/allRuleConfigs/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ruleConfig/view/allRuleConfigs/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ruleConfig/view/allRuleConfigs/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ruleConfig/view/allRuleConfigs/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ruleConfig/view/allRuleConfigs/

Show all of the rule configurations

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ruleConfigActionResetRuleConfigValue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ruleConfig/action/resetRuleConfigValue/?key=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ruleConfig/action/resetRuleConfigValue/?key=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ruleConfig/action/resetRuleConfigValue/', params={
  'key': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ruleConfig/action/resetRuleConfigValue/',
  params: {
  'key' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ruleConfig/action/resetRuleConfigValue/

Reset the specified rule configuration, which must already exist

Parameters

Name	In	Type	Required	Description
key	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ruleConfigActionResetAllRuleConfigValues

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ruleConfig/action/resetAllRuleConfigValues/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ruleConfig/action/resetAllRuleConfigValues/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ruleConfig/action/resetAllRuleConfigValues/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ruleConfig/action/resetAllRuleConfigValues/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/ruleConfig/action/resetAllRuleConfigValues/

Reset all of the rule configurations

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

ruleConfigActionSetRuleConfigValue

Code samples

# You can also use wget
curl -X GET http://zap/JSON/ruleConfig/action/setRuleConfigValue/?key=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/ruleConfig/action/setRuleConfigValue/?key=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/ruleConfig/action/setRuleConfigValue/', params={
  'key': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/ruleConfig/action/setRuleConfigValue/',
  params: {
  'key' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/ruleConfig/action/setRuleConfigValue/

Set the specified rule configuration, which must already exist

Parameters

Name	In	Type	Required	Description
key	query	string	true	none
value	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

sessionManagement

sessionManagementViewGetSupportedSessionManagementMethods

Code samples

# You can also use wget
curl -X GET http://zap/JSON/sessionManagement/view/getSupportedSessionManagementMethods/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/sessionManagement/view/getSupportedSessionManagementMethods/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/sessionManagement/view/getSupportedSessionManagementMethods/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/sessionManagement/view/getSupportedSessionManagementMethods/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/sessionManagement/view/getSupportedSessionManagementMethods/

Gets the name of the session management methods.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

sessionManagementViewGetSessionManagementMethodConfigParams

Code samples

# You can also use wget
curl -X GET http://zap/JSON/sessionManagement/view/getSessionManagementMethodConfigParams/?methodName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/sessionManagement/view/getSessionManagementMethodConfigParams/?methodName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/sessionManagement/view/getSessionManagementMethodConfigParams/', params={
  'methodName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/sessionManagement/view/getSessionManagementMethodConfigParams/',
  params: {
  'methodName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/sessionManagement/view/getSessionManagementMethodConfigParams/

Gets the configuration parameters for the session management method with the given name.

Parameters

Name	In	Type	Required	Description
methodName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

sessionManagementViewGetSessionManagementMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/sessionManagement/view/getSessionManagementMethod/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/sessionManagement/view/getSessionManagementMethod/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/sessionManagement/view/getSessionManagementMethod/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/sessionManagement/view/getSessionManagementMethod/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/sessionManagement/view/getSessionManagementMethod/

Gets the name of the session management method for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

sessionManagementActionSetSessionManagementMethod

Code samples

# You can also use wget
curl -X GET http://zap/JSON/sessionManagement/action/setSessionManagementMethod/?contextId=0&methodName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/sessionManagement/action/setSessionManagementMethod/?contextId=0&methodName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/sessionManagement/action/setSessionManagementMethod/', params={
  'contextId': '0',  'methodName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/sessionManagement/action/setSessionManagementMethod/',
  params: {
  'contextId' => 'integer',
'methodName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/sessionManagement/action/setSessionManagementMethod/

Sets the session management method for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
methodName	query	string	true	none
methodConfigParams	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

users

usersViewUsersList

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/view/usersList/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/view/usersList/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/view/usersList/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/view/usersList/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/users/view/usersList/

Gets a list of users that belong to the context with the given ID, or all users if none provided.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersViewGetUserById

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/view/getUserById/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/view/getUserById/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/view/getUserById/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/view/getUserById/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/view/getUserById/

Gets the data of the user with the given ID that belongs to the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersViewGetAuthenticationCredentialsConfigParams

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/view/getAuthenticationCredentialsConfigParams/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/view/getAuthenticationCredentialsConfigParams/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/view/getAuthenticationCredentialsConfigParams/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/view/getAuthenticationCredentialsConfigParams/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/view/getAuthenticationCredentialsConfigParams/

Gets the configuration parameters for the credentials of the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersViewGetAuthenticationCredentials

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/view/getAuthenticationCredentials/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/view/getAuthenticationCredentials/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/view/getAuthenticationCredentials/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/view/getAuthenticationCredentials/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/view/getAuthenticationCredentials/

Gets the authentication credentials of the user with given ID that belongs to the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersActionNewUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/action/newUser/?contextId=0&name=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/action/newUser/?contextId=0&name=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/action/newUser/', params={
  'contextId': '0',  'name': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/action/newUser/',
  params: {
  'contextId' => 'integer',
'name' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/action/newUser/

Creates a new user with the given name for the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
name	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersActionRemoveUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/action/removeUser/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/action/removeUser/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/action/removeUser/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/action/removeUser/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/action/removeUser/

Removes the user with the given ID that belongs to the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersActionSetUserEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/action/setUserEnabled/?contextId=0&userId=0&enabled=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/action/setUserEnabled/?contextId=0&userId=0&enabled=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/action/setUserEnabled/', params={
  'contextId': '0',  'userId': '0',  'enabled': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/action/setUserEnabled/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer',
'enabled' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/action/setUserEnabled/

Sets whether or not the user, with the given ID that belongs to the context with the given ID, should be enabled.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none
enabled	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersActionSetUserName

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/action/setUserName/?contextId=0&userId=0&name=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/action/setUserName/?contextId=0&userId=0&name=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/action/setUserName/', params={
  'contextId': '0',  'userId': '0',  'name': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/action/setUserName/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer',
'name' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/action/setUserName/

Renames the user with the given ID that belongs to the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none
name	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

usersActionSetAuthenticationCredentials

Code samples

# You can also use wget
curl -X GET http://zap/JSON/users/action/setAuthenticationCredentials/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/users/action/setAuthenticationCredentials/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/users/action/setAuthenticationCredentials/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/users/action/setAuthenticationCredentials/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/users/action/setAuthenticationCredentials/

Sets the authentication credentials for the user with the given ID that belongs to the context with the given ID.

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none
authCredentialsConfigParams	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

forcedUser

forcedUserViewIsForcedUserModeEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/forcedUser/view/isForcedUserModeEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/forcedUser/view/isForcedUserModeEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/forcedUser/view/isForcedUserModeEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/forcedUser/view/isForcedUserModeEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/forcedUser/view/isForcedUserModeEnabled/

Returns 'true' if 'forced user' mode is enabled, 'false' otherwise

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

forcedUserViewGetForcedUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/forcedUser/view/getForcedUser/?contextId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/forcedUser/view/getForcedUser/?contextId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/forcedUser/view/getForcedUser/', params={
  'contextId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/forcedUser/view/getForcedUser/',
  params: {
  'contextId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/forcedUser/view/getForcedUser/

Gets the user (ID) set as 'forced user' for the given context (ID)

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

forcedUserActionSetForcedUser

Code samples

# You can also use wget
curl -X GET http://zap/JSON/forcedUser/action/setForcedUser/?contextId=0&userId=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/forcedUser/action/setForcedUser/?contextId=0&userId=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/forcedUser/action/setForcedUser/', params={
  'contextId': '0',  'userId': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/forcedUser/action/setForcedUser/',
  params: {
  'contextId' => 'integer',
'userId' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/forcedUser/action/setForcedUser/

Sets the user (ID) that should be used in 'forced user' mode for the given context (ID)

Parameters

Name	In	Type	Required	Description
contextId	query	integer	true	none
userId	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

forcedUserActionSetForcedUserModeEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/forcedUser/action/setForcedUserModeEnabled/?boolean=true \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/forcedUser/action/setForcedUserModeEnabled/?boolean=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/forcedUser/action/setForcedUserModeEnabled/', params={
  'boolean': 'true'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/forcedUser/action/setForcedUserModeEnabled/',
  params: {
  'boolean' => 'boolean'
}, headers: headers

p JSON.parse(result)

GET /JSON/forcedUser/action/setForcedUserModeEnabled/

Sets if 'forced user' mode should be enabled or not

Parameters

Name	In	Type	Required	Description
boolean	query	boolean	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

script

scriptViewListEngines

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/listEngines/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/listEngines/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/listEngines/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/listEngines/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/script/view/listEngines/

Lists the script engines available

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewListTypes

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/listTypes/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/listTypes/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/listTypes/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/listTypes/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/script/view/listTypes/

Lists the script types available.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewListScripts

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/listScripts/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/listScripts/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/listScripts/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/listScripts/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/script/view/listScripts/

Lists the scripts available, with its engine, name, description, type and error state.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewGlobalVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/globalVar/?varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/globalVar/?varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/globalVar/', params={
  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/globalVar/',
  params: {
  'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/view/globalVar/

Gets the value of the global variable with the given key. Returns an API error (DOES_NOT_EXIST) if no value was previously set.

Parameters

Name	In	Type	Required	Description
varKey	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewGlobalVars

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/globalVars/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/globalVars/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/globalVars/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/globalVars/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/script/view/globalVars/

Gets all the global variables (key/value pairs).

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewScriptVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/scriptVar/?scriptName=string&varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/scriptVar/?scriptName=string&varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/scriptVar/', params={
  'scriptName': 'string',  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/scriptVar/',
  params: {
  'scriptName' => 'string',
'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/view/scriptVar/

Gets the value of the variable with the given key for the given script. Returns an API error (DOES_NOT_EXIST) if no script with the given name exists or if no value was previously set.

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none
varKey	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptViewScriptVars

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/view/scriptVars/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/view/scriptVars/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/view/scriptVars/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/view/scriptVars/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/view/scriptVars/

Gets all the variables (key/value pairs) of the given script. Returns an API error (DOES_NOT_EXIST) if no script with the given name exists.

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionEnable

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/enable/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/enable/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/enable/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/enable/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/enable/

Enables the script with the given name

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionDisable

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/disable/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/disable/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/disable/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/disable/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/disable/

Disables the script with the given name

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionLoad

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/load/?scriptName=string&scriptType=string&scriptEngine=string&fileName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/load/?scriptName=string&scriptType=string&scriptEngine=string&fileName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/load/', params={
  'scriptName': 'string',  'scriptType': 'string',  'scriptEngine': 'string',  'fileName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/load/',
  params: {
  'scriptName' => 'string',
'scriptType' => 'string',
'scriptEngine' => 'string',
'fileName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/load/

Loads a script into ZAP from the given local file, with the given name, type and engine, optionally with a description, and a charset name to read the script (the charset name is required if the script is not in UTF-8, for example, in ISO-8859-1).

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none
scriptType	query	string	true	none
scriptEngine	query	string	true	none
fileName	query	string	true	none
scriptDescription	query	string	false	none
charset	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionRemove

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/remove/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/remove/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/remove/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/remove/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/remove/

Removes the script with the given name

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionRunStandAloneScript

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/runStandAloneScript/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/runStandAloneScript/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/runStandAloneScript/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/runStandAloneScript/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/runStandAloneScript/

Runs the stand alone script with the given name

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionClearGlobalVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/clearGlobalVar/?varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/clearGlobalVar/?varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/clearGlobalVar/', params={
  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/clearGlobalVar/',
  params: {
  'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/clearGlobalVar/

Clears the global variable with the given key.

Parameters

Name	In	Type	Required	Description
varKey	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionClearGlobalVars

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/clearGlobalVars/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/clearGlobalVars/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/clearGlobalVars/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/clearGlobalVars/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/script/action/clearGlobalVars/

Clears the global variables.

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionClearScriptVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/clearScriptVar/?scriptName=string&varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/clearScriptVar/?scriptName=string&varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/clearScriptVar/', params={
  'scriptName': 'string',  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/clearScriptVar/',
  params: {
  'scriptName' => 'string',
'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/clearScriptVar/

Clears the variable with the given key of the given script. Returns an API error (DOES_NOT_EXIST) if no script with the given name exists.

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none
varKey	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionClearScriptVars

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/clearScriptVars/?scriptName=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/clearScriptVars/?scriptName=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/clearScriptVars/', params={
  'scriptName': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/clearScriptVars/',
  params: {
  'scriptName' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/clearScriptVars/

Clears the variables of the given script. Returns an API error (DOES_NOT_EXIST) if no script with the given name exists.

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionSetScriptVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/setScriptVar/?scriptName=string&varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/setScriptVar/?scriptName=string&varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/setScriptVar/', params={
  'scriptName': 'string',  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/setScriptVar/',
  params: {
  'scriptName' => 'string',
'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/setScriptVar/

Sets the value of the variable with the given key of the given script. Returns an API error (DOES_NOT_EXIST) if no script with the given name exists.

Parameters

Name	In	Type	Required	Description
scriptName	query	string	true	none
varKey	query	string	true	none
varValue	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

scriptActionSetGlobalVar

Code samples

# You can also use wget
curl -X GET http://zap/JSON/script/action/setGlobalVar/?varKey=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/script/action/setGlobalVar/?varKey=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/script/action/setGlobalVar/', params={
  'varKey': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/script/action/setGlobalVar/',
  params: {
  'varKey' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/script/action/setGlobalVar/

Sets the value of the global variable with the given key.

Parameters

Name	In	Type	Required	Description
varKey	query	string	true	none
varValue	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

stats

statsViewStats

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/stats/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/stats/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/stats/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/stats/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/stats/

Statistics

Parameters

Name	In	Type	Required	Description
keyPrefix	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewAllSitesStats

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/allSitesStats/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/allSitesStats/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/allSitesStats/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/allSitesStats/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/allSitesStats/

Gets all of the site based statistics, optionally filtered by a key prefix

Parameters

Name	In	Type	Required	Description
keyPrefix	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewSiteStats

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/siteStats/?site=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/siteStats/?site=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/siteStats/', params={
  'site': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/siteStats/',
  params: {
  'site' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/siteStats/

Gets all of the global statistics, optionally filtered by a key prefix

Parameters

Name	In	Type	Required	Description
site	query	string	true	none
keyPrefix	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewOptionStatsdHost

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/optionStatsdHost/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/optionStatsdHost/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/optionStatsdHost/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/optionStatsdHost/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/optionStatsdHost/

Gets the Statsd service hostname

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewOptionStatsdPort

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/optionStatsdPort/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/optionStatsdPort/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/optionStatsdPort/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/optionStatsdPort/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/optionStatsdPort/

Gets the Statsd service port

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewOptionStatsdPrefix

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/optionStatsdPrefix/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/optionStatsdPrefix/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/optionStatsdPrefix/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/optionStatsdPrefix/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/optionStatsdPrefix/

Gets the prefix to be applied to all stats sent to the configured Statsd service

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewOptionInMemoryEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/optionInMemoryEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/optionInMemoryEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/optionInMemoryEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/optionInMemoryEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/optionInMemoryEnabled/

Returns 'true' if in memory statistics are enabled, otherwise returns 'false'

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsViewOptionStatsdEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/view/optionStatsdEnabled/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/view/optionStatsdEnabled/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/view/optionStatsdEnabled/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/view/optionStatsdEnabled/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/view/optionStatsdEnabled/

Returns 'true' if a Statsd server has been correctly configured, otherwise returns 'false'

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsActionClearStats

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/action/clearStats/ \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/action/clearStats/");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/action/clearStats/', params={

}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/action/clearStats/',
  params: {
  }, headers: headers

p JSON.parse(result)

GET /JSON/stats/action/clearStats/

Clears all of the statistics

Parameters

Name	In	Type	Required	Description
keyPrefix	query	string	false	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsActionSetOptionStatsdHost

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/action/setOptionStatsdHost/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/action/setOptionStatsdHost/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/action/setOptionStatsdHost/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/action/setOptionStatsdHost/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/stats/action/setOptionStatsdHost/

Sets the Statsd service hostname, supply an empty string to stop using a Statsd service

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsActionSetOptionStatsdPrefix

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/action/setOptionStatsdPrefix/?String=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/action/setOptionStatsdPrefix/?String=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/action/setOptionStatsdPrefix/', params={
  'String': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/action/setOptionStatsdPrefix/',
  params: {
  'String' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/stats/action/setOptionStatsdPrefix/

Sets the prefix to be applied to all stats sent to the configured Statsd service

Parameters

Name	In	Type	Required	Description
String	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsActionSetOptionInMemoryEnabled

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/action/setOptionInMemoryEnabled/?Boolean=string \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/action/setOptionInMemoryEnabled/?Boolean=string");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/action/setOptionInMemoryEnabled/', params={
  'Boolean': 'string'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/action/setOptionInMemoryEnabled/',
  params: {
  'Boolean' => 'string'
}, headers: headers

p JSON.parse(result)

GET /JSON/stats/action/setOptionInMemoryEnabled/

Sets whether in memory statistics are enabled

Parameters

Name	In	Type	Required	Description
Boolean	query	string	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

statsActionSetOptionStatsdPort

Code samples

# You can also use wget
curl -X GET http://zap/JSON/stats/action/setOptionStatsdPort/?Integer=0 \
  -H 'Accept: application/json' \
  -H 'X-ZAP-API-Key: API_KEY'

URL obj = new URL("http://zap/JSON/stats/action/setOptionStatsdPort/?Integer=0");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

import requests
headers = {
  'Accept': 'application/json',
  'X-ZAP-API-Key': 'API_KEY'
}

r = requests.get('http://zap/JSON/stats/action/setOptionStatsdPort/', params={
  'Integer': '0'
}, headers = headers)

print r.json()

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-ZAP-API-Key' => 'API_KEY'
}

result = RestClient.get 'http://zap/JSON/stats/action/setOptionStatsdPort/',
  params: {
  'Integer' => 'integer'
}, headers: headers

p JSON.parse(result)

GET /JSON/stats/action/setOptionStatsdPort/

Sets the Statsd service port

Parameters

Name	In	Type	Required	Description
Integer	query	integer	true	none

Example responses

default Response

{
  "message": "string",
  "code": 100
}

Responses

Status	Meaning	Description	Schema
default	Default	unexpected error	Error

Schemas

Error

{
  "message": "string",
  "code": 100
}

Properties

Name	Type	Required	Restrictions	Description
message	string	true	none	none
code	integer	true	none	none