Palo Alto Networks · Schema

-_shared.ContainerScanResult

Cloud SecurityCybersecurityFirewallNetwork SecuritySASESOARThreat IntelligenceXDR
View JSON Schema on GitHub

JSON Schema

palo-alto-networks-shared-container-scan-result-schema.json Raw ↑
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://raw.githubusercontent.com/api-evangelist/palo-alto-networks/main/json-schema/palo-alto-networks-shared-container-scan-result-schema.json",
  "title": "-_shared.ContainerScanResult",
  "x-generated": "2026-10-03",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/palo-alto-networks-containers-api-openapi.yml#/components/schemas/-_shared.ContainerScanResult",
  "items": {
    "$ref": "#/$defs/shared.ContainerScanResult"
  },
  "type": "array",
  "$defs": {
    "common.ACIMetadata": {
      "properties": {
        "containerGroup": {
          "description": ".\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "common.AzureMetadata": {
      "properties": {
        "aci": {
          "$ref": "#/$defs/common.ACIMetadata"
        },
        "resourceGroup": {
          "description": ".\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "common.CloudMetadata": {
      "description": "CloudMetadata is the metadata for a cloud provider managed asset (e.g., as part of AWS/GCP/Azure/OCI)",
      "properties": {
        "accountID": {
          "description": "Cloud account ID.\n",
          "type": "string"
        },
        "awsExecutionEnv": {
          "description": "AWS execution environment (e.g. EC2/Fargate).\n",
          "type": "string"
        },
        "azure": {
          "$ref": "#/$defs/common.AzureMetadata"
        },
        "gcp": {
          "$ref": "#/$defs/common.GCPCloudMetadata"
        },
        "image": {
          "description": "The name of the image the cloud managed host or container is based on.\n",
          "type": "string"
        },
        "labels": {
          "description": "Cloud provider metadata labels.\n",
          "items": {
            "$ref": "#/$defs/common.ExternalLabel"
          },
          "type": "array"
        },
        "name": {
          "description": "Resource name.\n",
          "type": "string"
        },
        "ociTenantID": {
          "description": "OCI Tenant ID.\n",
          "type": "string"
        },
        "provider": {
          "$ref": "#/$defs/common.CloudProvider"
        },
        "region": {
          "description": "Resource's region.\n",
          "type": "string"
        },
        "resourceID": {
          "description": "Unique ID of the resource.\n",
          "type": "string"
        },
        "resourceURL": {
          "description": "Server-defined URL for the resource.\n",
          "type": "string"
        },
        "type": {
          "description": "Instance type.\n",
          "type": "string"
        },
        "vmID": {
          "description": "Azure unique vm ID.\n",
          "type": "string"
        },
        "vmImageID": {
          "description": "VMImageID holds the VM instance's image ID.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "common.CloudProvider": {
      "description": "CloudProvider specifies the cloud provider name",
      "enum": [
        [
          "aws",
          "azure",
          "gcp",
          "alibaba",
          "oci",
          "others"
        ]
      ],
      "type": "string"
    },
    "common.CloudRunMetadata": {
      "properties": {
        "revision": {
          "description": ".\n",
          "type": "string"
        },
        "service": {
          "description": ".\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "common.ClusterType": {
      "description": "ClusterType is the cluster type",
      "enum": [
        [
          "AKS",
          "ECS",
          "EKS",
          "GKE",
          "Kubernetes"
        ]
      ],
      "type": "string"
    },
    "common.Color": {
      "description": "Color is a hexadecimal representation of color code value",
      "type": "string"
    },
    "common.ExternalLabel": {
      "description": "ExternalLabel holds an external label with a source and timestamp",
      "properties": {
        "key": {
          "description": "Label key.\n",
          "type": "string"
        },
        "sourceName": {
          "description": "Source name (e.g., for a namespace, the source name can be 'twistlock').\n",
          "type": "string"
        },
        "sourceType": {
          "$ref": "#/$defs/common.ExternalLabelSourceType"
        },
        "timestamp": {
          "description": "Time when the label was fetched.\n",
          "format": "date-time",
          "type": "string"
        },
        "value": {
          "description": "Value of the label.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "common.ExternalLabelSourceType": {
      "description": "ExternalLabelSourceType indicates the source of the labels",
      "enum": [
        [
          "namespace",
          "deployment",
          "pod",
          "aws",
          "azure",
          "gcp",
          "oci"
        ]
      ],
      "type": "string"
    },
    "common.GCPCloudMetadata": {
      "properties": {
        "cloudRun": {
          "$ref": "#/$defs/common.CloudRunMetadata"
        }
      },
      "type": "object"
    },
    "int": {
      "type": "integer"
    },
    "packages.Type": {
      "description": "Type describes the package type",
      "enum": [
        [
          "nodejs",
          "gem",
          "python",
          "jar",
          "package",
          "windows",
          "binary",
          "nuget",
          "go",
          "app",
          "unknown"
        ]
      ],
      "type": "string"
    },
    "shared.ContainerInfo": {
      "description": "ContainerInfo contains all information gathered on a specific container",
      "properties": {
        "allCompliance": {
          "$ref": "#/$defs/vuln.AllCompliance"
        },
        "app": {
          "description": "App is the app that is hosted in the container.\n",
          "type": "string"
        },
        "cloudMetadata": {
          "$ref": "#/$defs/common.CloudMetadata"
        },
        "cluster": {
          "description": "Cluster is the provided cluster name.\n",
          "type": "string"
        },
        "clusterType": {
          "$ref": "#/$defs/common.ClusterType"
        },
        "complianceDistribution": {
          "$ref": "#/$defs/vuln.Distribution"
        },
        "complianceIssues": {
          "description": "ComplianceIssues are all the container compliance issues.\n",
          "items": {
            "$ref": "#/$defs/vuln.Vulnerability"
          },
          "type": "array"
        },
        "complianceIssuesCount": {
          "description": ".\n",
          "type": "integer"
        },
        "complianceRiskScore": {
          "description": "ComplianceRiskScore is the container's compliance risk score.\n",
          "format": "float",
          "type": "number"
        },
        "externalLabels": {
          "description": "ExternalLabels is the external labels e.g., kubernetes namespace labels.\n",
          "items": {
            "$ref": "#/$defs/common.ExternalLabel"
          },
          "type": "array"
        },
        "id": {
          "description": "ID is the container id.\n",
          "type": "string"
        },
        "image": {
          "description": "Image is the canonical image name.\n",
          "type": "string"
        },
        "imageID": {
          "description": "ImageID is the image id.\n",
          "type": "string"
        },
        "imageName": {
          "description": "The image name as stated in the docker run command.\n",
          "type": "string"
        },
        "infra": {
          "description": "Infra represents any container that belongs to the infrastructure.\n",
          "type": "boolean"
        },
        "installedProducts": {
          "$ref": "#/$defs/shared.InstalledProducts"
        },
        "labels": {
          "description": "Labels are the container labels (https://docs.docker.com/engine/userguide/labels-custom-metadata/).\n",
          "items": {
            "$ref": "#/$defs/string"
          },
          "type": "array"
        },
        "name": {
          "description": "Name is the container name.\n",
          "type": "string"
        },
        "namespace": {
          "description": "Namespace is the k8s deployment namespace.\n",
          "type": "string"
        },
        "network": {
          "$ref": "#/$defs/shared.ContainerNetwork"
        },
        "networkSettings": {
          "$ref": "#/$defs/shared.DockerNetworkInfo"
        },
        "processes": {
          "description": "Processes are the processes that are running inside the container.\n",
          "items": {
            "$ref": "#/$defs/shared.ContainerProcess"
          },
          "type": "array"
        },
        "profileID": {
          "description": "ProfileID is the container profile id.\n",
          "type": "string"
        },
        "sizeBytes": {
          "description": ".\n",
          "format": "int64",
          "type": "integer"
        },
        "startTime": {
          "description": "StartTime is the starting time of the container.\n",
          "format": "date-time",
          "type": "string"
        }
      },
      "type": "object"
    },
    "shared.ContainerNetwork": {
      "description": "ContainerNetwork contains details about the container network (ports, IPs, type etc...)",
      "properties": {
        "ports": {
          "description": "Ports are the ports details associated with the container.\n",
          "items": {
            "$ref": "#/$defs/shared.ContainerPort"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "shared.ContainerPort": {
      "description": "ContainerPort represents the state of a port in a given container",
      "properties": {
        "container": {
          "description": "Container is the mapped port inside the container.\n",
          "type": "integer"
        },
        "host": {
          "description": "Host is the host port number.\n",
          "type": "integer"
        },
        "hostIP": {
          "description": "HostIP is the host IP.\n",
          "type": "string"
        },
        "listening": {
          "description": "Listening indicates whether the port is in listening mode.\n",
          "type": "boolean"
        },
        "nat": {
          "description": "NAT indicates the port is exposed using NAT.\n",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "shared.ContainerProcess": {
      "description": "ContainerProcess represents a process inside a container",
      "properties": {
        "name": {
          "description": "Name is a process name.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "shared.ContainerScanResult": {
      "description": "ContainerScanResult contains the result of a scanning a container",
      "properties": {
        "_id": {
          "description": "ID is the container ID.\n",
          "type": "string"
        },
        "agentless": {
          "description": "Agentless indicates if the result was received by an agentless scanner.\n",
          "type": "boolean"
        },
        "agentlessScanID": {
          "description": "AgentlessScanID is the ID of the agentless scan in which the result was received.\n",
          "type": "integer"
        },
        "ais": {
          "description": "AIS indicates the scan was performed by AIS.\n",
          "type": "boolean"
        },
        "collections": {
          "description": "Collections are collections to which this container applies.\n",
          "items": {
            "$ref": "#/$defs/string"
          },
          "type": "array"
        },
        "csa": {
          "description": "CSA indicates the scan was performed by the CSA.\n",
          "type": "boolean"
        },
        "firewallProtection": {
          "$ref": "#/$defs/waas.ProtectionStatus"
        },
        "hostname": {
          "description": "Hostname is the hostname on which the container is deployed.\n",
          "type": "string"
        },
        "info": {
          "$ref": "#/$defs/shared.ContainerInfo"
        },
        "runtimeEnabled": {
          "description": "RuntimeEnabled indicates if any runtime rule applies to the container.\n",
          "type": "boolean"
        },
        "scanTime": {
          "description": "ScanTime is the container scan time.\n",
          "format": "date-time",
          "type": "string"
        }
      },
      "type": "object"
    },
    "shared.DockerNetworkInfo": {
      "description": "DockerNetworkInfo contains network-related information about a container",
      "properties": {
        "ipAddress": {
          "description": "IPAddress is the container IP.\n",
          "type": "string"
        },
        "macAddress": {
          "description": "MacAddress is the container MAC.\n",
          "type": "string"
        },
        "networks": {
          "description": "Networks are the networks the container is connected to.\n",
          "items": {
            "$ref": "#/$defs/shared.NetworkInfo"
          },
          "type": "array"
        },
        "ports": {
          "description": "Ports are the container network binding that are externally mapped.\n",
          "items": {
            "$ref": "#/$defs/shared.Port"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "shared.InstalledProducts": {
      "description": "InstalledProducts contains data regarding products running in environment\nTODO #34713: Swarm support was deprecated in Joule, remove swarm node/manager boolean (and related compliance) in Lagrange",
      "properties": {
        "agentless": {
          "description": "Agentless indicates whether the scan was performed with agentless approach.\n",
          "type": "boolean"
        },
        "apache": {
          "description": "Apache indicates the apache server version, empty in case apache not running.\n",
          "type": "string"
        },
        "awsCloud": {
          "description": "AWSCloud indicates whether AWS cloud is used.\n",
          "type": "boolean"
        },
        "clusterType": {
          "$ref": "#/$defs/common.ClusterType"
        },
        "crio": {
          "description": "CRI indicates whether the container runtime is CRI (and not docker).\n",
          "type": "boolean"
        },
        "docker": {
          "description": "Docker represents the docker daemon version.\n",
          "type": "string"
        },
        "dockerEnterprise": {
          "description": "DockerEnterprise indicates whether the enterprise version of Docker is installed.\n",
          "type": "boolean"
        },
        "hasPackageManager": {
          "description": "HasPackageManager indicates whether package manager is installed on the OS.\n",
          "type": "boolean"
        },
        "k8sApiServer": {
          "description": "K8sAPIServer indicates whether a kubernetes API server is running.\n",
          "type": "boolean"
        },
        "k8sControllerManager": {
          "description": "K8sControllerManager indicates whether a kubernetes controller manager is running.\n",
          "type": "boolean"
        },
        "k8sEtcd": {
          "description": "K8sEtcd indicates whether etcd is running.\n",
          "type": "boolean"
        },
        "k8sFederationApiServer": {
          "description": "K8sFederationAPIServer indicates whether a federation API server is running.\n",
          "type": "boolean"
        },
        "k8sFederationControllerManager": {
          "description": "K8sFederationControllerManager indicates whether a federation controller manager is running.\n",
          "type": "boolean"
        },
        "k8sKubelet": {
          "description": "K8sKubelet indicates whether kubelet is running.\n",
          "type": "boolean"
        },
        "k8sProxy": {
          "description": "K8sProxy indicates whether a kubernetes proxy is running.\n",
          "type": "boolean"
        },
        "k8sScheduler": {
          "description": "K8sScheduler indicates whether the kubernetes scheduler is running.\n",
          "type": "boolean"
        },
        "kubernetes": {
          "description": "Kubernetes represents the kubernetes version.\n",
          "type": "string"
        },
        "managedClusterVersion": {
          "description": "ManagedClusterVersion is the version of the managed Kubernetes service, e.g. AKS/EKS/GKE/etc.\n",
          "type": "string"
        },
        "openshift": {
          "description": "Openshift indicates whether openshift is deployed.\n",
          "type": "boolean"
        },
        "openshiftVersion": {
          "description": "OpenshiftVersion represents the running openshift version.\n",
          "type": "string"
        },
        "osDistro": {
          "description": "OSDistro specifies the os distribution.\n",
          "type": "string"
        },
        "serverless": {
          "description": "Serverless indicates whether evaluated on a serverless environment.\n",
          "type": "boolean"
        },
        "swarmManager": {
          "description": "SwarmManager indicates whether a swarm manager is running.\n",
          "type": "boolean"
        },
        "swarmNode": {
          "description": "SwarmNode indicates whether the node is part of an active swarm.\n",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "shared.NetworkInfo": {
      "description": "NetworkInfo contains data about a container regarding a specific network",
      "properties": {
        "ipAddress": {
          "description": "IPAddress is the container IP.\n",
          "type": "string"
        },
        "macAddress": {
          "description": "MacAddress is the container MAC.\n",
          "type": "string"
        },
        "name": {
          "description": "Name is the network name.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "shared.Port": {
      "description": "Port is a container port",
      "properties": {
        "containerPort": {
          "description": "ContainerPort is the mapped port inside the container.\n",
          "type": "string"
        },
        "hostIP": {
          "description": "HostIP is the host IP.\n",
          "type": "string"
        },
        "hostPort": {
          "description": "HostPort is the host port.\n",
          "type": "integer"
        }
      },
      "type": "object"
    },
    "string": {
      "type": "string"
    },
    "vuln.AllCompliance": {
      "description": "AllCompliance contains data regarding passed compliance checks",
      "properties": {
        "compliance": {
          "description": "Compliance are all the passed compliance checks.\n",
          "items": {
            "$ref": "#/$defs/vuln.Vulnerability"
          },
          "type": "array"
        },
        "enabled": {
          "description": "Enabled indicates whether passed compliance checks is enabled by policy.\n",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "vuln.ComplianceTemplate": {
      "description": "ComplianceTemplate represents the compliance template",
      "enum": [
        [
          "PCI",
          "HIPAA",
          "NIST SP 800-190",
          "GDPR",
          "DISA STIG"
        ]
      ],
      "type": "string"
    },
    "vuln.Distribution": {
      "description": "Distribution counts the number of vulnerabilities per type",
      "properties": {
        "critical": {
          "description": ".\n",
          "type": "integer"
        },
        "high": {
          "description": ".\n",
          "type": "integer"
        },
        "low": {
          "description": ".\n",
          "type": "integer"
        },
        "medium": {
          "description": ".\n",
          "type": "integer"
        },
        "total": {
          "description": ".\n",
          "type": "integer"
        }
      },
      "type": "object"
    },
    "vuln.Secret": {
      "description": "Secret represents a secret found on the scanned workload",
      "properties": {
        "group": {
          "description": "Group is a group name or ID of owner the file metadata containing the secret.\n",
          "type": "string"
        },
        "locationInFile": {
          "description": "LocationInFile is the line and offset in the file where the secret was found.\n",
          "type": "string"
        },
        "metadataModifiedTime": {
          "description": "MetadataModifiedTime is the modification time of the file metadata containing the secret.\n",
          "format": "int64",
          "type": "integer"
        },
        "modifiedTime": {
          "description": "ModifiedTime is the modification time of the file containing the secret.\n",
          "format": "int64",
          "type": "integer"
        },
        "originalFileLocation": {
          "description": ".\n",
          "type": "string"
        },
        "path": {
          "description": "Path is the path of the file in which the secret was found.\n",
          "type": "string"
        },
        "permissions": {
          "description": "Permissions are permission bits of the file metadata containing the secret.\n",
          "type": "string"
        },
        "secretID": {
          "description": "SecretID is the SHA1 of the secret content.\n",
          "type": "string"
        },
        "size": {
          "description": "Size is the size in bytes of the file in which the secret was found.\n",
          "format": "int64",
          "type": "integer"
        },
        "snippet": {
          "description": "Snippet is the partial plain secret.\n",
          "type": "string"
        },
        "type": {
          "$ref": "#/$defs/vuln.SecretType"
        },
        "user": {
          "description": "User is a username or ID of owner the file metadata containing the secret.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "vuln.SecretType": {
      "description": "SecretType represents a secret type",
      "enum": [
        [
          "AWS Access Key ID",
          "AWS Secret Key",
          "AWS MWS Auth Token",
          "Azure Storage Account Access Key",
          "Azure Service Principal",
          "GCP Service Account Auth Key",
          "Private Encryption Key",
          "Public Encryption Key",
          "PEM X509 Certificate Header",
          "SSH Authorized Keys",
          "Artifactory API Token",
          "Artifactory Password",
          "Basic Auth Credentials",
          "Mailchimp Access Key",
          "NPM Token",
          "Slack Token",
          "Slack Webhook",
          "Square OAuth Secret",
          "Notion Integration Token",
          "Airtable API Key",
          "Atlassian Oauth2 Keys",
          "CircleCI Personal Token",
          "Databricks Authentication Token",
          "GitHub Token",
          "GitLab Token",
          "Google API key",
          "Grafana Token",
          "Python Package Index Key (PYPI)",
          "Typeform API Token",
          "Scalr Token",
          "Braintree Access Token",
          "Braintree Payments Key",
          "Paypal Token Key",
          "Braintree Payments ID",
          "Datadog Client Token",
          "ClickUp Personal API Token",
          "OpenAI API Key",
          "Java DB Connectivity (JDBC)",
          "MongoDB",
          ".Net SQL Server"
        ]
      ],
      "type": "string"
    },
    "vuln.TagInfo": {
      "description": "TagInfo is the tag info in a specific vulnerability context",
      "properties": {
        "color": {
          "$ref": "#/$defs/common.Color"
        },
        "comment": {
          "description": "Tag comment in a specific vulnerability context.\n",
          "type": "string"
        },
        "name": {
          "description": "Name of the tag.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "vuln.Vulnerability": {
      "description": "Vulnerability is a general schema for vulnerabilities (e.g., for compliance or packages)",
      "properties": {
        "applicableRules": {
          "description": "Rules applied on the package.\n",
          "items": {
            "$ref": "#/$defs/string"
          },
          "type": "array"
        },
        "binaryPkgs": {
          "description": "Names of the distro binary package names (packages which are built from the source of the package).\n",
          "items": {
            "$ref": "#/$defs/string"
          },
          "type": "array"
        },
        "block": {
          "description": "Indicates if the vulnerability has a block effect (true) or not (false).\n",
          "type": "boolean"
        },
        "cause": {
          "description": "Additional information regarding the root cause for the vulnerability.\n",
          "type": "string"
        },
        "cri": {
          "description": "Indicates if this is a CRI-specific vulnerability (true) or not (false).\n",
          "type": "boolean"
        },
        "custom": {
          "description": "Indicates if the vulnerability is a custom vulnerability (e.g., openscap, sandbox) (true) or not (false).\n",
          "type": "boolean"
        },
        "cve": {
          "description": "CVE ID of the vulnerability (if applied).\n",
          "type": "string"
        },
        "cvss": {
          "description": "CVSS score of the vulnerability.\n",
          "format": "float",
          "type": "number"
        },
        "description": {
          "description": "Description of the vulnerability.\n",
          "type": "string"
        },
        "discovered": {
          "description": "Specifies the time of discovery for the vulnerability.\n",
          "format": "date-time",
          "type": "string"
        },
        "exploit": {
          "$ref": "#/$defs/vulnerability.ExploitType"
        },
        "exploits": {
          "$ref": "#/$defs/vulnerability.Exploits"
        },
        "fixDate": {
          "description": "Date/time when the vulnerability was fixed (in Unix time).\n",
          "format": "int64",
          "type": "integer"
        },
        "fixLink": {
          "description": "Link to the vendor's fixed-version information.\n",
          "type": "string"
        },
        "functionLayer": {
          "description": "Specifies the serverless layer ID in which the vulnerability was discovered.\n",
          "type": "string"
        },
        "gracePeriodDays": {
          "description": "Number of grace days left for a vulnerability, based on the configured grace period. Nil if no block vulnerability rule applies.\n",
          "type": "integer"
        },
        "id": {
          "description": "ID of the violation.\n",
          "type": "integer"
        },
        "isRPMModule": {
          "description": "IsRPMModule indicates whether this vulnerability is specific to an RPM module.\n",
          "type": "boolean"
        },
        "layerTime": {
          "description": "Date/time of the image layer to which the CVE belongs.\n",
          "format": "int64",
          "type": "integer"
        },
        "link": {
          "description": "Vendor link to the CVE.\n",
          "type": "string"
        },
        "packageName": {
          "description": "Name of the package that caused the vulnerability.\n",
          "type": "string"
        },
        "packageType": {
          "$ref": "#/$defs/packages.Type"
        },
        "packageVersion": {
          "description": "Version of the package that caused the vulnerability (or null).\n",
          "type": "string"
        },
        "published": {
          "description": "Date/time when the vulnerability was published (in Unix time).\n",
          "format": "int64",
          "type": "integer"
        },
        "riskFactors": {
          "$ref": "#/$defs/vulnerability.RiskFactors"
        },
        "rpmModule": {
          "description": "RPMModule specifies the RPM module containing the package affected by this vulnerability.\n",
          "type": "string"
        },
        "secret": {
          "$ref": "#/$defs/vuln.Secret"
        },
        "severity": {
          "description": "Textual representation of the vulnerability's severity.\n",
          "type": "string"
        },
        "status": {
          "description": "Vendor status for the vulnerability.\n",
          "type": "string"
        },
        "templates": {
          "description": "List of templates with which the vulnerability is associated.\n",
          "items": {
            "$ref": "#/$defs/vuln.ComplianceTemplate"
          },
          "type": "array"
        },
        "text": {
          "description": "Description of the violation.\n",
          "type": "string"
        },
        "title": {
          "description": "Compliance title.\n",
          "type": "string"
        },
        "twistlock": {
          "description": "Indicates if this is a Twistlock-specific vulnerability (true) or not (false).\n",
          "type": "boolean"
        },
        "type": {
          "$ref": "#/$defs/vulnerability.Type"
        },
        "vecStr": {
          "description": "Textual representation of the metric values used to score the vulnerability.\n",
          "type": "string"
        },
        "vulnTagInfos": {
          "description": "Tag information for the vulnerability.\n",
          "items": {
            "$ref": "#/$defs/vuln.TagInfo"
          },
          "type": "array"
        },
        "wildfireMalware": {
          "$ref": "#/$defs/vuln.WildFireMalware"
        }
      },
      "type": "object"
    },
    "vuln.WildFireMalware": {
      "description": "WildFireMalware holds the data for WildFire malicious MD5",
      "properties": {
        "md5": {
          "description": "MD5 is the hash of the malicious binary.\n",
          "type": "string"
        },
        "path": {
          "description": "Path is the path to malicious binary.\n",
          "type": "string"
        },
        "verdict": {
          "description": "Verdict is the malicious source like grayware, malware and phishing.\n",
          "type": "string"
        }
      },
      "type": "object"
    },
    "vulnerability.ExploitData": {
      "description": "ExploitData holds information about an exploit",
      "properties": {
        "kind": {
          "$ref": "#/$defs/vulnerability.ExploitKind"
        },
        "link": {
          "description": "Link is a link to information about the exploit.\n",
          "type": "string"
        },
        "source": {
          "$ref": "#/$defs/vulnerability.ExploitType"
        }
      },
      "type": "object"
    },
    "vulnerability.ExploitKind": {
      "description": "ExploitKind represents the kind of the exploit",
      "enum": [
        [
          "poc",
          "in-the-wild"
        ]
      ],
      "type": "string"
    },
    "vulnerability.ExploitType": {
      "description": "ExploitType represents the source of an exploit",
      "enum": [
        [
          "",
          "exploit-db",
          "exploit-windows",
          "cisa-kev"
        ]
      ],
      "type": "string"
    },
    "vulnerability.Exploits": {
      "description": "Exploits represents the exploits data found for a CVE",
      "items": {
        "$ref": "#/$defs/vulnerability.ExploitData"
      },
      "type": "array"
    },
    "vulnerability.RiskFactors": {
      "additionalProperties": {
        "$ref": "#/$defs/string"
      },
      "description": "RiskFactors maps the existence of vulnerability risk factors",
      "type": "object"
    },
    "vulnerability.Type": {
      "description": "Type represents the vulnerability type",
      "enum": [
        [
          "container",
          "image",
          "host_config",
          "daemon_config",
          "daemon_config_files",
          "security_operations",
          "k8s_master",
          "k8s_worker",
          "k8s_federation",
          "linux",
          "windows",
          "istio",
          "serverless",
          "custom",
          "docker_stig",
          "openshift_master",
          "openshift_worker",
          "application_control_linux",
          "gke_worker",
          "image_malware",
          "host_malware",
          "aks_worker",
          "eks_worker",
          "image_secret",
          "host_secret"
        ]
      ],
      "type": "string"
    },
    "waas.OutOfBandMode": {
      "description": "OutOfBandMode 

# --- truncated at 32 KB (33 KB total) ---
# Full source: https://raw.githubusercontent.com/api-evangelist/palo-alto-networks/refs/heads/main/json-schema/palo-alto-networks-shared-container-scan-result-schema.json

Work with this as data

Every JSON Schema here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for schemas

4 MCP tools reach this
  • find_json_schemasBrowse and filter every JSON Schema in the catalog.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This JSON Schema
curl "https://apis.io/api/v1/json-schemas/palo-alto-networks-shared-container-scan-result"
All schemas
curl "https://apis.io/api/v1/json-schemas?limit=25"

Discovery needs no key. Ratings and market analysis are Pro.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.