# Network Security Scanner (`dz_omar/network-security-scanner`) Actor

The SSL Checker actor scans IPs or subnets for SSL certificate details using masscan. It retrieves response headers, titles, and redirected URLs for HTTP and HTTPS. Customize parameters and set result limits for efficient scanning

- **URL**: https://apify.com/dz\_omar/network-security-scanner.md
- **Developed by:** [FlowExtract API](https://apify.com/dz_omar) (community)
- **Categories:** Developer tools, Automation, SEO tools
- **Stats:** 25 total users, 1 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$4.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

---

#### What does the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) do?

The **[SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)** is a powerful tool that allows users to scan IP ranges, including AWS and Google Cloud networks, to discover critical information such as services running behind Web Application Firewalls (WAFs), potential vulnerabilities, subdomains, and endpoints. It operates like a Shodan-style search engine but offers deeper insights into small companies' infrastructure that larger search engines might overlook. 

This actor is designed for security professionals, including hackers, bug bounty hunters, and penetration testers, to increase their attack surface and identify vulnerable endpoints across vast networks.

##### Key features:
- **WAF Bypass:** Identify IPs hidden behind WAFs.
- **Fast IP Scanning:** Efficiently scan millions of IP addresses in a short time.
- **Subdomain Discovery:** Reveal new subdomains to extend your attack surface.
- **Vulnerability Detection:** Identify weaknesses in web servers, services, and applications.
- **Endpoint Discovery:** Locate and assess potentially vulnerable endpoints.

#### How to Run the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)

If you're new to [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) or ethical hacking, don't worry. The **[SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)** tool is easy to use and highly flexible. You can either use **Masscan** for a fast scan or provide a list of IP addresses to skip Masscan. Here's how:

1. Create a free Apify account using your email.
2. Open the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) tool in the Apify console.
3. Choose whether to use **Masscan** for scanning by checking or unchecking the **Masscan** option:
   - **If you check the box:** You must provide at least one IP range (in CIDR format).
   - **If you uncheck the box:** You can directly provide a list of individual IP addresses, and the tool will skip the **Masscan** scan.
4. Optionally, you can configure a proxy for the scan, Ensure that you won't be blocked by WAF and access to specific geographical regions.
5. Click the “Start” button to initiate the scan.
6. Analyze the results and download them in structured formats like JSON, XML, CSV, Excel, or HTML for further analysis.

Quick [Video Tutorial](https://youtu.be/gxbYKRHLX_8) on YouTube:

[Video Tutorial](https://youtu.be/gxbYKRHLX_8)

#### Input
To start scanning IP ranges or IP addresses, simply fill in the input form. The **[SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)** tool recognizes the following input parameters:
> [!NOTE]
> If you are provided more than one IP range, the result won't show up until Masscan is complete from scanning all provided IP ranges.

- **Use Masscan for Scanning (Checkbox)...**: A boolean flag indicating whether or not to use **Masscan** for scanning.
  ![download](https://github.com/user-attachments/assets/1cb2306d-3fca-4c66-8d53-12d07bf18749)
- **CIDR or IP Addresses**: A list of IP ranges in CIDR format or individual IP addresses for scanning.
  - **Using IP ranges (CIDR)**:
        ![download](https://github.com/user-attachments/assets/df0c6412-c011-4225-bbaf-9a4e15cc5c5c)
  - **Using IP Addresses**:
        ![download](https://github.com/user-attachments/assets/b8b1a101-b0c3-44dc-b143-433dee2037f5)

- **Masscan Ports**: (Optional) The port(s) you wish to scan with Masscan The default Port of Masscan is 443 you can add more Port if needed like (e.g., 80, 443 or 0-65535). Required only when Masscan is used.
- **Masscan Rate**: (Optional) The rate limit for **Masscan** (number of packets per second). Required only when Masscan is used.
- **Maximum Results Limit**: (Optional) Set the maximum number of results you want to receive.
- **Proxy Configuration**: (Optional) Use Apify's proxy services to anonymize your scan or access results from a specific geographical location.

#### Example Input (Using Masscan):
```json
{
    "Ips_or_CIDR": [
        "3.80.0.0/12",
        "3.208.0.0/12"
    ],
    "Used_Or_Not_Used_Masscan": true,
    "masscan_port": "443",
    "masscan_rate": 10000,
    "max_results": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BW"
    }
}
````

#### Example Input (Skipping Masscan):

```json
{
    "Ips_or_CIDR": [
        "3.91.85.6",
        "3.84.160.117",
        "3.92.19.235"
    ],
    "Used_Or_Not_Used_Masscan": false,
    "max_results": 33,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BW"
    }
}
```

#### Additional Notes:

- You can choose how many results you want by adjusting the `max_results` parameter.
- The **proxyConfiguration** feature allows you to run the scan using Apify's proxy services, ensuring anonymity or access to specific regions.

***

##### Output

You get the output from [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) Data Extractor stored in a tab. Here's an example of some of the output after the scan is complete :

- **In this example I provided this input**:

```json
{
  "Ips_or_CIDR": [
    "3.80.0.0/12"
  ],
  "Used_Or_Not_Used_Masscan": true,
  "masscan_port": "443",
  "masscan_rate": 10000,
  "max_results": 2000,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

- **The output of this input**:

```json
[
  {
    "title": "",
    "redirected_url": "",
    "request": "https://3.94.15.209:443",
    "port": "443",
    "ip": "3.94.15.209",
    "domain": "*.execute-api.us-east-1.amazonaws.com",
    "response_text": "{\"message\":\"Forbidden\"}",
    "response_headers": {
      "Date": "Mon, 07 Oct 2024 23:21:14 GMT",
      "Content-Type": "application/json",
      "Content-Length": "23",
      "Connection": "keep-alive",
      "x-amzn-RequestId": "c1f2ff47-007d-481e-9a76-02f2bd2c21bc",
      "x-amzn-ErrorType": "ForbiddenException",
      "x-amz-apigw-id": "fTX0oGxcoAMEawg="
    }
  },
...
]
```

![cf6f6720-2ebe-4ca5-9753-6425b9755a22](https://github.com/user-attachments/assets/a92a365f-a2fc-4c84-9a4d-e55780fd84d6)

##### Who can benefit from using [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)?

- **Security Assessment:** Perform vulnerability assessments and identify exploitable endpoints.
- **Bug Bounties:** Increase your chances of finding vulnerabilities in bug bounty programs.
- **Red/Blue Teaming:** Simulate attacks or fortify network defenses by identifying potential entry points.
- **Penetration Testing:** Discover hidden servers and services for penetration testing.

##### Integrations with the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)

The [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) integrates seamlessly with Apify’s platform and other tools such as:

- **Slack**
- **Zapier**
- **Google Drive**
- **GitHub**

You can also use **webhooks** to trigger alerts or actions whenever a scan completes.

***

#### FAQ

SSL and Web Analyzer

- **How much does the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer) cost?**
  The pricing is based on the number of results obtained. For instance, scanning 2,000 IPs costs approximately $0.33, which includes computing units, dataset writes, and external data transfer. You can estimate that scanning 1,000 IPs would cost around $0.165. Apify provides $5 worth of credits for free on their basic plan, which allows you to scan up to 30,303 IPs per month.
- **Is it legal to scan IPs with the [SSL and Web Analyzer](https://apify.com/dz_omar/ssl-and-web-analyzer)?**
  Yes, as long as you comply with relevant legal guidelines, such as obtaining permission to scan certain IP ranges, especially for companies or cloud providers.

### Support

For issues and support, please create a ticket or contact <fridaytechnolog@gmail.com>.

# Actor input Schema

## `used_masscan` (type: `boolean`):

Check this box to use Masscan for scanning a CIDR. If unchecked, you can directly provide specific IP addresses without using Masscan.

## `Ips_or_CIDR` (type: `array`):

Specify the CIDR ranges or IP addresses you wish to scan. You can include multiple CIDR notations or IPs in the list.

## `masscan_port` (type: `string`):

Define the ports you wish to scan, separated by commas. You can specify individual ports (e.g., '443,80'), a range of ports (e.g., '1-1024'), or all ports by entering '0-65535'.

## `masscan_rate` (type: `integer`):

Specify the rate of packets to be sent per second during the scan. Increasing this value will speed up the scanning process but may risk overloading the network or being rate-limited by firewalls. A balance is recommended for optimal results.

## `max_results` (type: `integer`):

Set a limit on the number of results to return from the scan. Leave this field blank for no limit (infinite results).

## `proxyConfiguration` (type: `object`):

Configure proxy settings to use during the scan. Utilizing proxies can help you avoid IP bans, bypass WAF (Web Application Firewall) restrictions, and access specific geographical regions. This ensures smooth crawling across various environments and enhances the overall efficiency and reliability of your scanning activities.

## `Ports` (type: `array`):

Specify the HTTP/HTTPS ports to be checked for connections (e.g., 80, 8080, 443).

## `timeout` (type: `integer`):

Specify the timeout value in seconds for HTTP/HTTPS requests.

## `semaphore_limit` (type: `integer`):

Limit the number of concurrent requests sent during the scan to manage server load.

## Actor input object example

```json
{
  "Ips_or_CIDR": [
    "8.8.8.8"
  ],
  "masscan_port": "443",
  "masscan_rate": 10000,
  "max_results": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "Ports": [
    80,
    443
  ],
  "timeout": 3,
  "semaphore_limit": 70
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "used_masscan": false,
    "Ips_or_CIDR": [
        "8.8.8.8"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "Ports": [
        80,
        443
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dz_omar/network-security-scanner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "used_masscan": False,
    "Ips_or_CIDR": ["8.8.8.8"],
    "proxyConfiguration": { "useApifyProxy": False },
    "Ports": [
        80,
        443,
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dz_omar/network-security-scanner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "used_masscan": false,
  "Ips_or_CIDR": [
    "8.8.8.8"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "Ports": [
    80,
    443
  ]
}' |
apify call dz_omar/network-security-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dz_omar/network-security-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Network Security Scanner",
        "description": "The SSL Checker actor scans IPs or subnets for SSL certificate details using masscan. It retrieves response headers, titles, and redirected URLs for HTTP and HTTPS. Customize parameters and set result limits for efficient scanning",
        "version": "1.1",
        "x-build-id": "NQwPYnXr0TQgkBlvf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dz_omar~network-security-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dz_omar-network-security-scanner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dz_omar~network-security-scanner/runs": {
            "post": {
                "operationId": "runs-sync-dz_omar-network-security-scanner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dz_omar~network-security-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-dz_omar-network-security-scanner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "Ips_or_CIDR",
                    "used_masscan"
                ],
                "properties": {
                    "used_masscan": {
                        "title": "Use Masscan for Scanning (Checkbox) and provide CIDR IF NOT Provide IP Address Directly",
                        "type": "boolean",
                        "description": "Check this box to use Masscan for scanning a CIDR. If unchecked, you can directly provide specific IP addresses without using Masscan."
                    },
                    "Ips_or_CIDR": {
                        "title": "CIDR or IP Addresses",
                        "type": "array",
                        "description": "Specify the CIDR ranges or IP addresses you wish to scan. You can include multiple CIDR notations or IPs in the list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "masscan_port": {
                        "title": "Masscan Ports",
                        "type": "string",
                        "description": "Define the ports you wish to scan, separated by commas. You can specify individual ports (e.g., '443,80'), a range of ports (e.g., '1-1024'), or all ports by entering '0-65535'.",
                        "default": "443"
                    },
                    "masscan_rate": {
                        "title": "Masscan Rate",
                        "type": "integer",
                        "description": "Specify the rate of packets to be sent per second during the scan. Increasing this value will speed up the scanning process but may risk overloading the network or being rate-limited by firewalls. A balance is recommended for optimal results.",
                        "default": 10000
                    },
                    "max_results": {
                        "title": "Maximum Results Limit",
                        "type": "integer",
                        "description": "Set a limit on the number of results to return from the scan. Leave this field blank for no limit (infinite results).",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings to use during the scan. Utilizing proxies can help you avoid IP bans, bypass WAF (Web Application Firewall) restrictions, and access specific geographical regions. This ensures smooth crawling across various environments and enhances the overall efficiency and reliability of your scanning activities."
                    },
                    "Ports": {
                        "title": "HTTP/HTTPS Ports",
                        "type": "array",
                        "description": "Specify the HTTP/HTTPS ports to be checked for connections (e.g., 80, 8080, 443).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "timeout": {
                        "title": "Request Timeout",
                        "type": "integer",
                        "description": "Specify the timeout value in seconds for HTTP/HTTPS requests.",
                        "default": 3
                    },
                    "semaphore_limit": {
                        "title": "Semaphore Limit",
                        "type": "integer",
                        "description": "Limit the number of concurrent requests sent during the scan to manage server load.",
                        "default": 70
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
