AppSpider

Introduction

 

All API calls require an API Token to be submitted. Be aware of the type of permissions the API call you are using. When creating your API calls you may need to utilize multiple accounts to get the results you are looking for.

example:

Use case: automating the deployment of a scan engine to scan a web application in an "on demand" scenario for highly changing environments.

All scan engine actions will require a system administrator (SA) account's Token to be used.

All scan configuration and the launching of the scan will require a client account's Token to be used.

When creating a script to automate this process you would need to have variables for both an SA Token and a client Token..

/Authentication/Login

User Account Login (logs you into a "Client")

 

apiKey Auth

 Authentication is required for this endpoint.
posthttp://[[app:server]]/AppSpiderEnterprise/rest/v1/Authentication/Login
require 'uri'
require 'net/http'
require 'json'
require 'ase_connection'

# Identifying the ASE console you are connecting into
protocol = 'http'
server = 'insert server'

base_url = "#{protocol}://#{server}/AppSpiderEnterprise/rest/v1"

# Client User Info
uname = 'insert user name'
password = 'insert password'

# API Call
uri = URI("#{base_url}/Authentication/Login")

http = Net::HTTP.new(uri.host, uri.port)

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'

# Request body
request.body = {:name => uname, :password => password}.to_json
# Send Request
response = http.request(request)
puts response.body
# Response
access_token = JSON.parse(response.body)
token = access_token['Token']
A binary file was returned

You couldn't be authenticated

{
  "Token": "",
  "IsSuccess": true,
  "Reason": null,
  "ErrorMessage": null
}
{
  "Token": null,
  "IsSuccess": false,
  "Reason": "InvalidCredentials",
  "ErrorMessage": "Invalid username or password."
}
{
  "IsSuccess": false,
  "Reason": "InvalidJsonSchema",
  "ErrorMessage": "Required properties are missing from object: password."
}

Body Params

name
string
required
password
string
required
 
require 'uri'
require 'net/http'
require 'json'
require 'ase_connection'

# Identifying the ASE console you are connecting into
protocol = 'http'
server = 'insert server'

base_url = "#{protocol}://#{server}/AppSpiderEnterprise/rest/v1"

# Client User Info
uname = 'insert user name'
password = 'insert password'

# API Call
uri = URI("#{base_url}/Authentication/Login")

http = Net::HTTP.new(uri.host, uri.port)

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'

# Request body
request.body = {:name => uname, :password => password}.to_json
# Send Request
response = http.request(request)
puts response.body
# Response
access_token = JSON.parse(response.body)
token = access_token['Token']
import http.client

conn = http.client.HTTPConnection("insertConsole")

payload = "{\n    \"name\": \"insertUsername\",\n    \"password\": \"insertPassword\"\n}"

headers = {
    'content-type': "application/json",
    'cache-control': "no-cache"
    }

conn.request("POST", "/AppSpiderEnterprise/rest/v1/Authentication/Login", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

Trying out the API

When using the "Try It" function you can click on the icon shaped like a person next to the "Try It" to set environmental variables such as setting your server to be used when testing the API.

/Engine/GetEngines

 

apiKey Auth

 Authentication is required for this endpoint.
gethttps://[[app:server]]/AppSpiderEnterprise/rest/v1/Engine/GetEngines
require 'uri'
require 'net/http'
require 'json'


# API Call
uri = URI("#{base_url}//Engine/GetEngines")

http = Net::HTTP.new(uri.host, uri.port)

# Method
request = Net::HTTP::Get.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'
request["Authorization"] = "basic #{token}"

response = http.request(request)
puts response.body
A binary file was returned

You couldn't be authenticated

{
  "IsSuccess": true,
  "Reason": null,
  "ErrorMessage": null
}
{
  "IsSuccess": false,
  "Reason": "InvalidJsonSchema",
  "ErrorMessage": "Required properties are missing from object: password."
}
{
  "Message": "Unauthorized"
}
{
  "Message": "Forbidden"
}

Headers

Authorization
string
required

Basic + Token

 
require 'uri'
require 'net/http'
require 'json'

###########Authentication Section#################################

# Identifying the ASE console you are connecting into
protocol = 'http'
server = 'x.x.x.x'
#@ase_ssl

base_url = "#{protocol}://#{server}/AppSpiderEnterprise/rest/v1"

# SA Account Info
uname_sa = 'xxxxx'
password_sa = 'xxxxx'

# API Call
uri = URI("#{base_url}/Authentication/Login")

http = Net::HTTP.new(uri.host, uri.port)
#http.use_ssl = true if @ase_ssl
#http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ase_ssl_verify

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'

# Request body
request.body = {:name => uname_sa, :password => password_sa}.to_json
# Send Request
response = http.request(request)

# Response
access_token = JSON.parse(response.body)
token = access_token['Token']

###########End###################################################

# API Call
uri = URI("#{base_url}//Engine/GetEngines")

http = Net::HTTP.new(uri.host, uri.port)
# http.use_ssl = true if @ase_ssl
# http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ase_ssl_verify

# Method
request = Net::HTTP::Get.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'
request["Authorization"] = "basic #{token}"

response = http.request(request)
puts response.body

/Engine/SaveEngine

 

apiKey Auth

 Authentication is required for this endpoint.
posthttps://[[app:server]]/AppSpiderEnterprise/rest/v1/Engine/SaveEngine
curl --request POST \
  --url https://example.com/AppSpiderEnterprise/rest/v1/Engine/SaveEngine \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'https://example.com/AppSpiderEnterprise/rest/v1/Engine/SaveEngine',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("https://example.com/AppSpiderEnterprise/rest/v1/Engine/SaveEngine")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "https://example.com/AppSpiderEnterprise/rest/v1/Engine/SaveEngine");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "https://example.com/AppSpiderEnterprise/rest/v1/Engine/SaveEngine"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

id
string

if id not provided new engine will be created. if id provided engine update performed.

url
string
required

Scan engine URL. URL scheme should be {scheme}://{domain}/{path}/default.asmx

virtualName
string
required

Scan engine name

login
string
required

Scan engine username

password
string
required

Scan engine password

note
string
donotupdate
string

Do not update engine property

Headers

Authorization
string
required

Basic + Token

 

/Engine/DeleteEngine

 

apiKey Auth

 Authentication is required for this endpoint.
posthttps://[[app:server]]/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine
require 'uri'
require 'net/http'
require 'json'

base_url = "#{protocol}://#{server}/AppSpiderEnterprise/rest/v1"

# API Call

# Sets the engine guid Id to be deleted
ids = '"insertguid"'

uri = URI("#{base_url}//Engine/DeleteEngines")

http = Net::HTTP.new(uri.host, uri.port)
# http.use_ssl = true if @ase_ssl
# http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ase_ssl_verify

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'
request["Authorization"] = "basic #{token}"
request.body = "ids=#{ids}"
puts request.body

response = http.request(request)
puts response.body
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Basic + Token

ids
string

Scan engine IDs

 

Lorem ipsum dolor sit amet, consectetur adipiscing elit.

require 'uri'
require 'net/http'
require 'json'

###########Authentication Section#################################

# Identifying the ASE console you are connecting into
protocol = 'http'
server = 'x.x.x.x'
#@ase_ssl

base_url = "#{protocol}://#{server}/AppSpiderEnterprise/rest/v1"

# SA Account Info
uname_sa = 'xxxxx'
password_sa = 'xxxxx'

# API Call
uri = URI("#{base_url}/Authentication/Login")

http = Net::HTTP.new(uri.host, uri.port)
#http.use_ssl = true if @ase_ssl
#http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ase_ssl_verify

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'

# Request body
request.body = {:name => uname_sa, :password => password_sa}.to_json
# Send Request
response = http.request(request)

# Response
access_token = JSON.parse(response.body)
token = access_token['Token']

###########End###################################################

# API Call

# Sets the engine guid Id to be deleted
ids = '"insertguid"'

uri = URI("#{base_url}//Engine/DeleteEngines")

http = Net::HTTP.new(uri.host, uri.port)
# http.use_ssl = true if @ase_ssl
# http.verify_mode = OpenSSL::SSL::VERIFY_NONE if @ase_ssl_verify

# Method
request = Net::HTTP::Post.new(uri)
# Headers
request["Content-Type"] = 'application/json'
request["Cache-Control"] = 'no-cache'
request["Accept"] = 'application/json'
request["Authorization"] = "basic #{token}"
request.body = "ids=#{ids}"
puts request.body

response = http.request(request)
puts response.body

1-Authentication Operations

 

/Authentication/Login - SA

User Account Login (logs you in as an SA)

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login \
  --header 'content-type: Content-Type'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login',
  headers: { 'content-type': 'Content-Type' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["content-type"] = 'Content-Type'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login");
xhr.setRequestHeader("content-type", "Content-Type");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Authentication/Login"

headers = {'content-type': 'Content-Type'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

name
string
required
password
string
required

Headers

Content-Type
string
required

Response

2-Scan Engine Operations

 

/Engine/GetEngines

Retrieves the list of scan engines

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/GetEngines"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/Engine/SaveEngine

Creates or updates a scan engine

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/SaveEngine"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

id
string
required
url
string
required
virtualName
string
required
login
string
required
password
string
required
notes
string
required
donotupdate
string
required

Headers

Authorization
string
required

Response

/Engine/DeleteEngine

Deletes one or more scan engines

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Engine/DeleteEngine"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

id
string
required

Headers

Authorization
string
required

Response

3-Scan Engine Group Operations

 

/EngineGroup/GetAllEngineGroups

Retrieves the list of scan engine groups

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetAllEngineGroups"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/EngineGroup/GetEngineGroupsForClient

Retrieves the list of scan engine for groups for client. Note: user permissions required to retrieve the list of scan engine groups

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/GetEngineGroupsForClient"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/EngineGroup/SaveEngineGroup

Creates or updates a scan engine group

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/SaveEngineGroup"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

id
string
required
name
string
required
description
string
required
monitoring
string
required

Headers

Authorization
string
required

Response

/EngineGroup/DeleteEngineGroup

Deletes a scan engine group

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineGroup"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

ids
string
required

Headers

Authorization
string
required

Response

/EngineGroup/AddEngineToGroup

Adds a scan engine to a scan engine group

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/AddEngineToGroup"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

groupId
string
required
engineId
string
required

Headers

Authorization
string
required

Response

/EngineGroup/DeleteEngineFromGroup

Deletes a scan engine from a scan engine group

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/EngineGroup/DeleteEngineFromGroup"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

groupId
string
required
engineId
string
required

Headers

Authorization
string
required

Response

4-Scan Configuration Operations

 

/Config/SaveConfig

Creates or updates a scan configuration

JSON Example:

{ "DefendEnabled": false, "MonitoringDelay": 0, "MonitoringTriggerScan": false, "Xml": "<ScanConfig>...</ScanConfig>", "Id": null, "Name": "Webscantest", "ClientId": "4b3c1f62-8a19-4c81-a9d8-061aeb758ddd", "EngineGroupId": "92bfcd05-239a-4a90-ade7-5b637e3cb877", "Monitoring": false, "IsApproveRequired": false }

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig \
  --header 'accept: Accept' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig',
  headers:
   { accept: 'Accept',
     authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'
request["accept"] = 'Accept'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig");
xhr.setRequestHeader("authorization", "Authorization");
xhr.setRequestHeader("accept", "Accept");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/SaveConfig"

headers = {
    'authorization': "Authorization",
    'accept': "Accept"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

Config
string
required

Headers

Authorization
string
required
Accept
string
required

Response

DeleteConfigs

Deletes a scan config

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs \
  --header 'authorization: Authorization' \
  --header 'content-type: Content-Type'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs',
  headers:
   { 'content-type': 'Content-Type',
     authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'
request["content-type"] = 'Content-Type'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs");
xhr.setRequestHeader("authorization", "Authorization");
xhr.setRequestHeader("content-type", "Content-Type");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/DeleteConfigs"

headers = {
    'authorization': "Authorization",
    'content-type': "Content-Type"
    }

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

configIds
array of strings
required

Headers

Authorization
string
required
Content-Type
string
required

Response

/Config/GetConfigs

Retrieves scan configs for the client

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfigs"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/Config/GetConfig

Retrieves a specified scan config

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig?id=id' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig',
  qs: { id: 'id' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig?id=id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig?id=id");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetConfig"

querystring = {"id":"id"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

id
string
required

Headers

Authorization
string
required

Response

/Config/GetAttachment

Retrieves auxiliary files (such as macro, traffic recording, etc), referenced in the scan config

fileType:
Values are: "Authentication", "Certificate", "Crawling", "Selenium", "Traffic", "Wsdl"

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment?configid=configid&fileName=fileName&fileType=fileType' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment',
  qs:
   { configid: 'configid',
     fileName: 'fileName',
     fileType: 'fileType' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment?configid=configid&fileName=fileName&fileType=fileType")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment?configid=configid&fileName=fileName&fileType=fileType");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachment"

querystring = {"configid":"configid","fileName":"fileName","fileType":"fileType"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

configid
string
required
fileName
string
required
fileType
string
required

Headers

Authorization
string
required

Response

/Config/GetAttachments

Retrieves all auxiliary files (such as macro, traffic recording, etc), referenced in the scan configuration.

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments?configId=configId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments',
  qs: { configId: 'configId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments?configId=configId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments?configId=configId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Config/GetAttachments"

querystring = {"configId":"configId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

configId
string
required

Headers

Authorization
string
required

Response

5-Blackout Operations

 

/Blackout/GetBlackouts

Retrieves the blackout list for the client

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/GetBlackouts"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

SaveBlackout

Creates or updates a blackout

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/SaveBlackout"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

id
string
required
name
string
required
startTime
string
required
stopTime
string
required
targetHost
string
required
isRecurring
string
required
recurrence
string
required

Headers

Authorization
string
required

Response

DeleteBlackouts

Removes a blackout

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Blackout/DeleteBlackouts"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

blackoutIds
string
required

Headers

Authorization
string
required

Response

6-Scan Management

 

/Scan/GetScans

Retrieves the scans list for the client

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScans"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/Scan/RunScan

Start a scan. One of parameters should be provided to start scan.

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/RunScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

configId
string
required
configName
string
required

Headers

Authorization
string
required

Response

/Scan/CancelScan

Cancels “Starting” or “Waiting for Cloud” scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/PauseScan

Pauses a running scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/ResumeScan

Resumes a paused scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/StopScan

Stops a running scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/PauseAllScans

Pauses all running scans for the client

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/PauseAllScans"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/Scan/ResumeAllScans

Start a scan. One of parameters should be provided to start scan.

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/ResumeAllScans"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

configId
string
required
configName
string
required

Response

/Scan/StopAllScans

Start a scan. One of parameters should be provided to start scan.

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/StopAllScans"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

configId
string
required
configName
string
required

Headers

Authorization
string
required

Response

/Scan/CancelAllScans

Start a scan. One of parameters should be provided to start scan.

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/CancelAllScans"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

configId
string
required
configName
string
required

Headers

Authorization
string
required

Response

/Scan/GetScanStatus

Retrieves the scan status represented by a string

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus?scanid=scanid' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus',
  qs: { scanid: 'scanid' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus?scanid=scanid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus?scanid=scanid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/GetScanStatus"

querystring = {"scanid":"scanid"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanid
string
required

Headers

Authorization
string
required

Response

/Scan/IsScanActive

Tests whether the specified scan is active

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive?scanId=scanId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive',
  qs: { scanId: 'scanId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive?scanId=scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive?scanId=scanId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanActive"

querystring = {"scanId":"scanId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/IsScanFinished

Tests whether the specified scan was completed

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished?scanId=scanId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished',
  qs: { scanId: 'scanId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished?scanId=scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished?scanId=scanId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/IsScanFinished"

querystring = {"scanId":"scanId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/HasReport

Tests whether the specified scan has a report

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport?scanId=scanId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport',
  qs: { scanId: 'scanId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport?scanId=scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport?scanId=scanId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Scan/HasReport"

querystring = {"scanId":"scanId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanId
string
required

Headers

Authorization
string
required

Response

/Scan/GetScanErrors

Gets scan error log

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors?scanid=scanid' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors',
  qs: { scanid: 'scanid' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors?scanid=scanid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors?scanid=scanid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetScanErrors"

querystring = {"scanid":"scanid"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanid
string
required

Headers

Authorization
string
required

Response

7-Report Management

 

/Report/ImportStandardReport

Creates a new scan in the scan history or updates the report for the specified scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportStandardReport"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required
reportData
string
required
configId
string
required

Headers

Authorization
string
required

Response

/Report/ImportCheckmarxReport

Uploads checkmarx report

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/ImportCheckmarxReport"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scanId
string
required
file
string
required

Headers

Authorization
string
required

Response

/Report/GetReportZip

Gets ReportAllFiles.zip for the scan. Only scans in Completed and Stopped states may have a report

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip?scanId=scanId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip',
  qs: { scanId: 'scanId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip?scanId=scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip?scanId=scanId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetReportZip"

querystring = {"scanId":"scanId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanId
string
required

Headers

Authorization
string
required

Response

/Report/GetVulnerabilitiesSummaryXml

Gets VulnerabilitiesSummary.xml for the scan. Only scans in the Completed and Stopped states may have a report

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml?scanId=scanId' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml',
  qs: { scanId: 'scanId' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml?scanId=scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml?scanId=scanId");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesSummaryXml"

querystring = {"scanId":"scanId"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanId
string
required

Headers

Authorization
string
required

Response

/Report/GetCrawledLinksXml

Gets CrawledLinks.xml for the scan. Only scans in Completed and Stopped states may have report.

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml?scanid=scanid' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml',
  qs: { scanid: 'scanid' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml?scanid=scanid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml?scanid=scanid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetCrawledLinksXml"

querystring = {"scanid":"scanid"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanid
string
required

Headers

Authorization
string
required

Response

/Scan/GetVulnerabilitiesXml

Gets Vulnerabilities.xml for the scan. Only scans in Completed and Stopped states may have report.

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml
curl --request GET \
  --url 'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml?scanid=scanid' \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml',
  qs: { scanid: 'scanid' },
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml?scanid=scanid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml?scanid=scanid");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Report/GetVulnerabilitiesXml"

querystring = {"scanid":"scanid"}

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Query Params

scanid
string
required

Headers

Authorization
string
required

Response

8-Scheduled Scan Management

 

/ScanSchedule/ScheduleScan

Schedules a scan

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/ScheduleScan"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

configId
string
required
startTime
string
required
stopTime
string
required
isRecurring
string
required
recurrence
string
required

Headers

Authorization
string
required

Response

/ScanSchedule/DeleteScanSchedules

Deletes a scheduled scan from a client

 
posthttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules
curl --request POST \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'POST',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/DeleteScanSchedules"

headers = {'authorization': 'Authorization'}

response = requests.request("POST", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Form Data

scheduleIds
string
required

Headers

Authorization
string
required

Response

/ScanSchedule/GetScanSchedules

Retrieves a list of scheduled scans for the client

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/ScanSchedule/GetScanSchedules"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

9-Findings Management

 

/Finding/GetVulnerabilities

Retrieves the list of vulnerabilities filtered by the specific parameters

 
gethttp://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities
curl --request GET \
  --url http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities \
  --header 'authorization: Authorization'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities',
  headers: { authorization: 'Authorization' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)
request["authorization"] = 'Authorization'

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities");
xhr.setRequestHeader("authorization", "Authorization");

xhr.send(data);
import requests

url = "http://example.com/://DefaultParameterValue/AppSpiderEnterprise/rest/v1/Finding/GetVulnerabilities"

headers = {'authorization': 'Authorization'}

response = requests.request("GET", url, headers=headers)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Headers

Authorization
string
required

Response

/service_msg

 

get

Gets greeting message from REST service.

 

Basic Auth

 Authentication is required for this endpoint.
get/service_msg
curl --request GET \
  --url http://example.com/appspider/v1/service_msg
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/service_msg' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/service_msg")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/service_msg");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/service_msg"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "greeting": "Service is alive!"
}

Response

Successful response

greetingstring

the greeting message

50x response

resultstring
errorMessagestring

/scan_engine_msg

 

get

Gets greeting message from Scan Engine.

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scan_engine_msg
curl --request GET \
  --url http://example.com/appspider/v1/scan_engine_msg
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/scan_engine_msg' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scan_engine_msg")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scan_engine_msg");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scan_engine_msg"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

{
  "greeting": "Engine is alive!"
}

Response

Successful response

greetingstring

the greeting message

50x response

resultstring
errorMessagestring

/license_info

 

get

Gets current license information.

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/license_info
curl --request GET \
  --url http://example.com/appspider/v1/license_info
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/license_info' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/license_info")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/license_info");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/license_info"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successful response

validboolean

a status of current license

licenseTypestring

a type of current license

expirationDatestring

an expiration date of current license

referenceCodestring

a reference code of current license

50x response

resultstring
errorMessagestring

post

posts a valid license key.

 

Basic Auth

 Authentication is required for this endpoint.
posthttp://example.com/appspider/v1/license_info
curl --request POST \
  --url http://example.com/appspider/v1/license_info
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/appspider/v1/license_info' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/license_info")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/appspider/v1/license_info");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/license_info"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

licenseKey
string

the license key to update current license

Response

Successful response

50x response

resultstring
errorMessagestring

/license

 

post

posts a valid product key.

 

Basic Auth

 Authentication is required for this endpoint.
posthttp://example.com/appspider/v1/license
curl --request POST \
  --url http://example.com/appspider/v1/license
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/appspider/v1/license' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/license")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/appspider/v1/license");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/license"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

productKey
string

the product key to update current license

Response

Successful response

50x response

resultstring
errorMessagestring

/default_config

 

get

Gets default scan config.

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/default_config
curl --request GET \
  --url http://example.com/appspider/v1/default_config
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/default_config' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/default_config")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/default_config");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/default_config"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successful response

scanConfigXmlstring

a xml content of default scan configuration

50x response

resultstring
errorMessagestring

/sys_info

 

get

Gets current system information.

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/sys_info
curl --request GET \
  --url http://example.com/appspider/v1/sys_info
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/sys_info' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/sys_info")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/sys_info");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/sys_info"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successful response

ipstring

an ip address of server machine

cpustring

a cpu type of server machine

coresinteger

a number of cpu cores of server machine

totalRAMinteger

a number of total RAM installed on server machine

freeRAMinteger

a number of free RAM available on server machine

totalSystemDiskSpaceinteger

a number of total HDD space of System Disk on server machine

freeSystemDiskSpaceinteger

a number of free HDD space of System Disk available on server machine

totalDataDiskSpaceinteger

a number of total HDD space of Data Disk on server machine

freeDataDiskSpaceinteger

a number of free HDD space of Data Disk available on server machine

50x response

resultstring
errorMessagestring

/version

 

get

Gets version of AppSpider Scan Engine

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/version
curl --request GET \
  --url http://example.com/appspider/v1/version
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/appspider/v1/version' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/version")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/version");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/version"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successful response

versionstring

a Scan Engine version number

50x response

resultstring
errorMessagestring

/file/{scanId}

 

put

Puts a file to the service data directory (Usually a traffic file attached to a scan configuration)

 

Basic Auth

 Authentication is required for this endpoint.
puthttp://example.com/appspider/v1/file/scanId
curl --request PUT \
  --url http://example.com/appspider/v1/file/scanId
var request = require("request");

var options = { method: 'PUT',
  url:
   'http://example.com/appspider/v1/file/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/file/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/appspider/v1/file/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/file/scanId"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the scan token

Body Params

fileName
string

the corresponding file name that is specified in the scan config

location
string

the type of uploaded file

content
string

the binary content of uploaded file

offset
integer

the number of bytes previously uploaded for the current file

Response

Successful response

fileLengthBytesinteger

a number of bytes previously uploaded for the current file ( a file length)

50x response

resultstring
errorMessagestring

/update

 

put

Puts a new instalation distributive file to the service update directory

 

Basic Auth

 Authentication is required for this endpoint.
puthttp://example.com/appspider/v1/update
curl --request PUT \
  --url http://example.com/appspider/v1/update
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/appspider/v1/update' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/update")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/appspider/v1/update");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/update"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

fileName
string

the installer filename

location
string

the constant value

content
string

the binary content of uploaded installer

offset
integer

the offset of binary content of uploaded installer

Response

Successful response

fileLengthBytesinteger

a number of bytes previously uploaded for the current file ( a file length)

50x response

resultstring
errorMessagestring

/scans

 

get

Gets a complete list of running scans with token information

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scans
curl --request GET \
  --url http://example.com/appspider/v1/scans
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/appspider/v1/scans' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scans");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scans"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Response

Successful response

scanIdsarray

an array of scan Ids of scans that are currently running on the server

50x response

resultstring
errorMessagestring

post

Posts scan configuration, returns a new scan token (parameter ScanConfigXml is base 64 encoded xml configuration file)

 

Basic Auth

 Authentication is required for this endpoint.
posthttp://example.com/appspider/v1/scans
curl --request POST \
  --url http://example.com/appspider/v1/scans
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/appspider/v1/scans' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scans")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/appspider/v1/scans");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scans"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Body Params

scanConfigXml
string

the content os scan configuration file

Response

Successful response

tokenstring

a created scan token

50x response

resultstring
errorMessagestring

/scans/{scanId}

 

get

Gets a status of a scan

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scans/scanId
curl --request GET \
  --url http://example.com/appspider/v1/scans/scanId
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/scans/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scans/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scans/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scans/scanId"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Response

Successful response

tokenstring

a created scan token

scanNamestring

a scan name

scanProgressinteger

a scan progress

timeRemainingstring

a time remaining for this scan to be completed

timeElapsedstring

a time this scan has been running

timeStartstring

a time this scan started

timeEndstring

a time this scan is going to complete

statestring

a current scan state

loggedInboolean

a current session status for this scan

linksInQueueinteger

a number of links in this scan's queue

linksCrawledinteger

a number of links crawled

attacksInQueueinteger

a number of attacks in this scan's queue

attackedinteger

a number of performed attacks

vulnerableinteger

a number of vulnerabilities discovered

requestsinteger

a number of requests done

failedRequestsinteger

a number of failed requests

networkSpeedinteger

a network speed

dripDelayinteger

a number of delay in milliseconds

avgRespTimeinteger

an average response time in milliseconds

50x response

resultstring
errorMessagestring

put

Puts an action for a scan

 

Basic Auth

 Authentication is required for this endpoint.
puthttp://example.com/appspider/v1/scans/scanId
curl --request PUT \
  --url http://example.com/appspider/v1/scans/scanId
var request = require("request");

var options = { method: 'PUT',
  url:
   'http://example.com/appspider/v1/scans/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scans/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/appspider/v1/scans/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scans/scanId"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Body Params

action
string

the action you want to apply to the scan

generateReport
boolean

the flag that specifies you want to generate a report. this value is used for the action "stop" only

Response

Successful response

50x response

resultstring
errorMessagestring

delete

deletes scan directory from the hard drive after scan finished

 

Basic Auth

 Authentication is required for this endpoint.
deletehttp://example.com/appspider/v1/scans/scanId
curl --request DELETE \
  --url http://example.com/appspider/v1/scans/scanId
var request = require("request");

var options = { method: 'DELETE',
  url:
   'http://example.com/appspider/v1/scans/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scans/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/appspider/v1/scans/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scans/scanId"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Response

Successful response

50x response

resultstring
errorMessagestring

/scan_events/{scanId}

 

get

Gets events of a scan

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scan_events/scanId
curl --request GET \
  --url http://example.com/appspider/v1/scan_events/scanId
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/scan_events/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scan_events/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scan_events/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scan_events/scanId"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Response

Successful response

eventListarray

an array of operational scan events

50x response

resultstring
errorMessagestring

/scan_modules/{scanId}

 

get

Gets modules of a scan

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scan_modules/scanId
curl --request GET \
  --url http://example.com/appspider/v1/scan_modules/scanId
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/scan_modules/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scan_modules/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scan_modules/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scan_modules/scanId"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Response

Successful response

scanModuleListarray

an array of scan modules

50x response

resultstring
errorMessagestring

/scan_log/{scanId}

 

get

Gets the list of all log events of the scan

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scan_log/scanId
curl --request GET \
  --url http://example.com/appspider/v1/scan_log/scanId
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/scan_log/scanId' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scan_log/scanId")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scan_log/scanId");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scan_log/scanId"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Response

Successful response

scanLogarray

an array of scan log events

50x response

resultstring
errorMessagestring

/scan_log_new/{scanId}

 

get

Gets the list of new log events of the scan

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/scan_log_new/scanId
curl --request GET \
  --url 'http://example.com/appspider/v1/scan_log_new/scanId?nlast=nlast'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/scan_log_new/scanId',
  qs: { nlast: 'nlast' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/scan_log_new/scanId?nlast=nlast")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/scan_log_new/scanId?nlast=nlast");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/scan_log_new/scanId"

querystring = {"nlast":"nlast"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Query Params

nlast
string
required

the number of latest entries you want to be returned

Response

Successful response

scanLogarray

an array of scan log events

50x response

resultstring
errorMessagestring

/finding/{scanId}

 

get

Gets vulnerability finding xml

 

Basic Auth

 Authentication is required for this endpoint.
gethttp://example.com/appspider/v1/finding/scanId
curl --request GET \
  --url 'http://example.com/appspider/v1/finding/scanId?ifinding=ifinding'
var request = require("request");

var options = { method: 'GET',
  url:
   'http://example.com/appspider/v1/finding/scanId',
  qs: { ifinding: 'ifinding' } };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/appspider/v1/finding/scanId?ifinding=ifinding")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/appspider/v1/finding/scanId?ifinding=ifinding");

xhr.send(data);
import requests

url = "http://example.com/appspider/v1/finding/scanId"

querystring = {"ifinding":"ifinding"}

response = requests.request("GET", url, params=querystring)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results

Path Params

scanId
string
required

the id of scan returned by post /appspider/v1/scans

Query Params

ifinding
string
required

the index of finding

json
boolean

the format of output

Response

Successful response

findingstring

an xml content describing the finding you requested

50x response

resultstring
errorMessagestring