---
updatedAt: 2026-04-20T19:21:34.000Z
---

# Update a blocklist

This operation updates the details of a blocklist.

# OpenAPI definition

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "BlockLists",
    "version": "v1"
  },
  "servers": [
    {
      "url": "https://{hostname}/api/network-policy/v1"
    }
  ],
  "components": {
    "securitySchemes": {
      "oauth_v2": {
        "type": "oauth2",
        "description": "This API uses OAuth 2 with the implicit grant flow.\n",
        "flows": {
          "authorizationCode": {
            "authorizationUrl": "/api/identity/v1/oauth/authorize",
            "tokenUrl": "/api/identity/v1/oauth/token",
            "scopes": {
              "network-policy.admin": "d",
              "network-policy.read": "d"
            }
          }
        }
      }
    }
  },
  "paths": {
    "/blocklists": {
      "get": {
        "operationId": "get-blocklists",
        "summary": "List blocklists",
        "description": "This operation returns a list of all configured blocklists.",
        "parameters": [
          {
            "description": "The pageNumber parameter may be used to specify an offset into the results. Useful to use in conjunction with pageSize.  Page number offset is 1-based.\n",
            "in": "query",
            "name": "pageNumber",
            "schema": {
              "default": 1,
              "minimum": 1,
              "type": "integer",
              "example": 2
            }
          },
          {
            "description": "The filter parameter may be used to filter the returned collection.\n",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string",
              "example": "filter=name==foo"
            }
          },
          {
            "description": "The pageSize parameter may be used to specify the page size of the returned results.  Useful to use in conjunction with pageNumber.\n",
            "in": "query",
            "name": "pageSize",
            "schema": {
              "default": 100,
              "maximum": 1000,
              "minimum": 1,
              "type": "integer",
              "example": 200
            }
          },
          {
            "description": "The sortBy parameter may be used to specify the sort order of the returned collection.\n",
            "in": "query",
            "name": "sortBy",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "The view parameter may be used to request that either the summary or detailed view be returned.\n",
            "in": "query",
            "name": "view",
            "schema": {
              "enum": [
                "summary",
                "detailed"
              ],
              "default": "summary",
              "type": "string",
              "example": "summary"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "page": {
                    "pageNumber": 1,
                    "pageSize": 100,
                    "totalPages": 1,
                    "totalResults": 2
                  },
                  "blocklists": [
                    {
                      "blockListId": 1,
                      "name": "SeaPirates1"
                    },
                    {
                      "blockListId": 2,
                      "name": "SeaPirates2"
                    }
                  ]
                },
                "schema": {
                  "description": "Blocklists collection.\n",
                  "required": [
                    "blocklists",
                    "page"
                  ],
                  "properties": {
                    "blocklists": {
                      "type": "array",
                      "items": {
                        "required": [
                          "blockListId",
                          "name"
                        ],
                        "properties": {
                          "blockListId": {
                            "$ref": "#/paths/~1blocklists/post/responses/201/content/application~1json/schema/properties/blockListId"
                          },
                          "name": {
                            "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/name"
                          }
                        }
                      }
                    },
                    "page": {
                      "description": "Common page properties for search results.\n",
                      "required": [
                        "pageNumber",
                        "pageSize"
                      ],
                      "properties": {
                        "pageNumber": {
                          "type": "integer",
                          "description": "Indicates the page number of the current results, given the page size.\n"
                        },
                        "pageSize": {
                          "type": "integer",
                          "description": "Indicates the page size for the current results.\n"
                        },
                        "totalPages": {
                          "type": "integer",
                          "description": "Indicates the total number of pages, taking the pages size into consideration.\n"
                        },
                        "totalResults": {
                          "type": "integer",
                          "description": "Indicates the total number of results from the search.\n"
                        }
                      }
                    }
                  }
                }
              }
            },
            "description": "Successful response\n"
          },
          "403": {
            "description": "An HTTP 403 will be returned if the principal is not authorized to access the instance of blocklist that the request was made against.\n",
            "content": {
              "application/json": {
                "schema": {
                  "description": "Unauthorized access HTTP problem.\n",
                  "required": [
                    "type",
                    "instance",
                    "entity",
                    "permission"
                  ],
                  "allOf": [
                    {
                      "description": "Base HTTP problem type.\n",
                      "properties": {
                        "status": {
                          "type": "integer",
                          "description": "Optionally specified HTTP status code.\n"
                        },
                        "type": {
                          "type": "string",
                          "format": "uri"
                        },
                        "title": {
                          "type": "string",
                          "description": "Human readable title of the class of problem that occurred.\n"
                        },
                        "detail": {
                          "type": "string",
                          "description": "Human readable description of the class of problem that occurred.\n"
                        },
                        "instance": {
                          "type": "string",
                          "description": "Unique identifier for an instance of a problem.\n",
                          "format": "uri"
                        }
                      },
                      "required": [
                        "type",
                        "instance"
                      ]
                    },
                    {
                      "properties": {
                        "entity": {
                          "description": "A summary of an entity involved in a problem.\n",
                          "properties": {
                            "entityType": {
                              "type": "string",
                              "description": "Name of the entity type.\n"
                            },
                            "entityId": {
                              "description": "Id of the entity in question.\n"
                            },
                            "entityName": {
                              "type": "string",
                              "description": "Human readable name of the entity, if provided by the entity type.\n"
                            },
                            "entityHref": {
                              "type": "string",
                              "format": "uri",
                              "description": "URI pointing to the entity.\n"
                            }
                          },
                          "required": [
                            "entityType",
                            "entityId",
                            "entityHref"
                          ]
                        },
                        "permission": {
                          "type": "string",
                          "description": "The permission required to access the entity.\n"
                        }
                      }
                    }
                  ]
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth_v2": [
              "network-policy.admin",
              "network-policy.read"
            ]
          }
        ]
      },
      "post": {
        "operationId": "post-blocklist",
        "summary": "Create a new blocklist",
        "description": "This operation creates a new blocklist.",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "name": "SeaPirates",
                "description": "Pirates of the Caribbean",
                "endDate": "2020-03-11T20:30:00",
                "entries": [
                  "1.1.1.1",
                  "2.2.2.2",
                  "172.19.116.131/24"
                ]
              },
              "schema": {
                "type": "object",
                "description": "A blocklist has a list of IP/CIDRs that will be blocklisted from the CDN for certain duration.\n",
                "required": [
                  "name",
                  "entries"
                ],
                "properties": {
                  "description": {
                    "type": "string",
                    "maxLength": 256
                  },
                  "endDate": {
                    "type": "string",
                    "format": "date-time",
                    "description": "The associated date time.\n"
                  },
                  "entries": {
                    "type": "array",
                    "description": "List of IP addresses and/or CIDRs\n",
                    "maxItems": 10000,
                    "items": {
                      "oneOf": [
                        {
                          "type": "string",
                          "format": "ipv4",
                          "description": "An IPv4 address.\n"
                        },
                        {
                          "type": "string",
                          "format": "ipv6",
                          "description": "An IPv6 address.\n"
                        },
                        {
                          "description": "AN IPv4 CIDR block.\n",
                          "type": "string",
                          "pattern": "^([01]?\\d\\d?|2[0-4]\\d|25[0-5])(\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])){3}/(3[0-2]|[12][0-9]|[0-9])$"
                        },
                        {
                          "description": "An IPv6 CIDR block.\n",
                          "oneOf": [
                            {
                              "type": "string",
                              "description": "An IPv6 compressed address.\n",
                              "pattern": "^((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)::((?:[0-9A-Fa-f]{1,4}(?::[0-9A-Fa-f]{1,4})*)?)/([1][0-1][0-9]|[1][2][0-8]|[1-9]?[0-9])$"
                            },
                            {
                              "type": "string",
                              "description": "An IPv6 extended address.\n",
                              "pattern": "^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}/([1][0-1][0-9]|[1][2][0-8]|[1-9]?[0-9])$"
                            }
                          ]
                        }
                      ]
                    }
                  },
                  "name": {
                    "type": "string",
                    "maxLength": 128,
                    "minLength": 1
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/json": {
                "example": {
                  "blockListId": 1,
                  "name": "SeaPirates",
                  "description": "Pirates of the Caribbean",
                  "endDate": "2020-03-11T20:30:00",
                  "entries": [
                    "1.1.1.1",
                    "2.2.2.2",
                    "172.19.116.131/24"
                  ]
                },
                "schema": {
                  "description": "Blocklist detailed read schema.\n",
                  "required": [
                    "blockListId",
                    "name",
                    "entries"
                  ],
                  "properties": {
                    "blockListId": {
                      "type": "integer",
                      "description": "The unique identifier for a blocklist.\n",
                      "minimum": 1
                    },
                    "description": {
                      "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/description"
                    },
                    "endDate": {
                      "type": "string",
                      "format": "date-time"
                    },
                    "entries": {
                      "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/entries"
                    },
                    "name": {
                      "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/name"
                    }
                  }
                }
              }
            },
            "description": "An HTTP 201 will be returned if the request is successfully processed, and a new blocklist object is created.  The location of the new object will be specified in the location header.\n",
            "headers": {
              "Location": {
                "description": "The location header will specify a URI pointing to the newly created resource.\n",
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "400": {
            "description": "An HTTP 400 will be returned if the request is badly formed or has constraint violations\n",
            "content": {
              "application/json": {
                "example": {
                  "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/errors#core.constraint-violation",
                  "title": "The request entity is invalid",
                  "detail": "Constraint violations were detected",
                  "instance": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/v1/blocklists#7284f092-f2f1-4131-a9dc-f8a5b7b6980f",
                  "violations": [
                    {
                      "property": "#/name",
                      "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/errors#core.not-null-violation",
                      "detail": "may not be null"
                    }
                  ]
                },
                "schema": {
                  "description": "Super type to enumerate 400 class errors.\n",
                  "anyOf": [
                    {
                      "description": "Invalid path param HTTP problem. Used when the server can't process a path param due to incorrect type/formatting.\n",
                      "required": [
                        "type",
                        "instance",
                        "pathParamName",
                        "pathParamValue"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "pathParamName": {
                              "type": "string"
                            },
                            "pathParamValue": {
                              "description": "The value supplied in the request.\n"
                            }
                          }
                        }
                      ]
                    },
                    {
                      "description": "JSON mapping HTTP problem.\n",
                      "required": [
                        "type",
                        "instance",
                        "property"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "property": {
                              "type": "string"
                            }
                          }
                        }
                      ]
                    },
                    {
                      "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/0"
                    },
                    {
                      "description": "Path-param/entity-field mismatch HTTP problem.  In many situations, we have entities referenced via a URI that includes their identifier.  That identifier may also be in the body. If they don't match, it's unclear what the intended operation is, so this error is used.\n",
                      "required": [
                        "type",
                        "instance",
                        "uriParameterName",
                        "uriParameterValue",
                        "property",
                        "propertyValue"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "property": {
                              "type": "string",
                              "description": "The name of the field in the entity that must match the URI param.\n"
                            },
                            "propertyValue": {
                              "description": "The supplied value of the field.\n"
                            },
                            "uriParameterName": {
                              "type": "string",
                              "description": "The name of the URI parameter.\n"
                            },
                            "uriParameterValue": {
                              "description": "The supplied value of the URI parameter.\n"
                            }
                          }
                        }
                      ]
                    },
                    {
                      "description": "Invalid parameter HTTP problem.\n",
                      "required": [
                        "type",
                        "instance",
                        "parameter",
                        "value"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "parameter": {
                              "type": "string",
                              "description": "The parameter that is in error.\n"
                            },
                            "value": {
                              "description": "The value that was provided.\n"
                            }
                          }
                        }
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "violations": {
                              "type": "array",
                              "items": {
                                "anyOf": [
                                  {
                                    "allOf": [
                                      {
                                        "required": [
                                          "property",
                                          "type"
                                        ],
                                        "properties": {
                                          "type": {
                                            "type": "string",
                                            "description": "Uniquely identifies this HTTP problem.\n",
                                            "format": "uri"
                                          },
                                          "detail": {
                                            "type": "string",
                                            "description": "Human readable description of the problem.\n"
                                          },
                                          "property": {
                                            "type": "string",
                                            "description": "The property in the request that has caused a violation.\n"
                                          },
                                          "value": {
                                            "description": "The value in the request that has caused a violation.\n"
                                          }
                                        }
                                      }
                                    ]
                                  },
                                  {
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "min"
                                    ],
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/5/allOf/1/properties/violations/items/anyOf/0/allOf/0"
                                      },
                                      {
                                        "properties": {
                                          "min": {
                                            "type": "integer",
                                            "description": "Specifies the minimum allowable value for the given property.\n"
                                          }
                                        }
                                      }
                                    ]
                                  },
                                  {
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "max"
                                    ],
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/5/allOf/1/properties/violations/items/anyOf/0/allOf/0"
                                      },
                                      {
                                        "properties": {
                                          "min": {
                                            "type": "integer",
                                            "description": "Specifies the maximum allowable value for the given property.\n"
                                          }
                                        }
                                      }
                                    ]
                                  },
                                  {
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "size"
                                    ],
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/5/allOf/1/properties/violations/items/anyOf/0/allOf/0"
                                      },
                                      {
                                        "properties": {
                                          "min": {
                                            "type": "integer",
                                            "description": "Specifies the maximum allowable size for the given property.  For strings this is the string length.\n"
                                          }
                                        }
                                      }
                                    ]
                                  },
                                  {
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "pattern"
                                    ],
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/5/allOf/1/properties/violations/items/anyOf/0/allOf/0"
                                      },
                                      {
                                        "properties": {
                                          "pattern": {
                                            "type": "string",
                                            "description": "Specifies the allowable pattern for a property.  This would usually be a regular expression.\n"
                                          }
                                        }
                                      }
                                    ]
                                  },
                                  {
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "requiredValue"
                                    ],
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1blocklists/post/responses/400/content/application~1json/schema/anyOf/5/allOf/1/properties/violations/items/anyOf/0/allOf/0"
                                      },
                                      {
                                        "properties": {
                                          "requiredValue": {
                                            "type": "boolean",
                                            "description": "Specifies the allowable condition value for a property.\n"
                                          }
                                        }
                                      }
                                    ]
                                  }
                                ]
                              }
                            }
                          }
                        }
                      ]
                    }
                  ]
                }
              }
            }
          },
          "403": {
            "$ref": "#/paths/~1blocklists/get/responses/403"
          },
          "409": {
            "description": "An HTTP 409 will be returned if the blocklist offered for create/update would lead to a conflicting state.\n",
            "content": {
              "application/json": {
                "example": {
                  "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/errors#core.entity-property-conflict",
                  "title": "The request has conflicting properties with existing configuration",
                  "detail": "An entity with property 'name' of 'SeaPirates' already exists",
                  "instance": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/v1/blocklists#a4e84e37-ec37-4a13-83d7-ba1d75a36029",
                  "conflictingProperty": "#/name",
                  "conflictingValue": "SeaPirates",
                  "conflictingEntity": {
                    "entityHref": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/network-policy/v1/blocklists/1",
                    "entityType": "BlockList",
                    "entityId": 1
                  }
                },
                "schema": {
                  "description": "Super type to enumerate 409 class errors.\n",
                  "anyOf": [
                    {
                      "description": "Entity property conflict HTTP problem.  Used when an attempt is made to set a property on an entity that would cause conflict with an existent entity. For example, attempting to set duplicate surrogate identifiers.\n",
                      "required": [
                        "type",
                        "instance",
                        "conflictingProperty",
                        "conflictingValue",
                        "conflictingEntity"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "conflictingEntity": {
                              "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/1/properties/entity",
                              "description": "The existing entity which the proposed change is in conflict with.\n"
                            },
                            "conflictingProperty": {
                              "type": "string"
                            },
                            "conflictingValue": {
                              "description": "The supplied value.\n"
                            }
                          }
                        }
                      ]
                    },
                    {
                      "description": "Entity referenced HTTP problem. Used in cases where an attempt is made to delete an entity that other entities are referring to, and simply removing the reference would not lead to a valid state.\n",
                      "required": [
                        "type",
                        "instance",
                        "referencedEntity",
                        "referringEntities"
                      ],
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "referencedEntity": {
                              "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/1/properties/entity"
                            },
                            "referringEntities": {
                              "type": "array",
                              "items": {
                                "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/1/properties/entity"
                              }
                            }
                          }
                        }
                      ]
                    },
                    {
                      "description": "Non-existent reference HTTP problem. Used when a mutable operation attempts to refer to another resource that does not exist.\n",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1blocklists/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "referencedId": {
                              "description": "The Id of the object that was referenced.\n"
                            },
                            "referencedType": {
                              "type": "string",
                              "description": "The type of the object that was referenced.\n"
                            }
                          }
                        }
                      ]
                    }
                  ]
                }
              }
            }
          }
        },
        "security": [
          {
            "oauth_v2": [
              "network-policy.admin"
            ]
          }
        ]
      }
    },
    "/blocklists/{blockListId}": {
      "parameters": [
        {
          "description": "Uniquely identifies a blocklist.\n",
          "in": "path",
          "name": "blockListId",
          "required": true,
          "schema": {
            "type": "integer",
            "example": 1
          }
        }
      ],
      "put": {
        "operationId": "put-blocklist",
        "summary": "Update a blocklist",
        "description": "This operation updates the details of a blocklist.",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/example"
              },
              "schema": {
                "type": "object",
                "additionalProperties": false,
                "description": "Blocklist update schema.\n",
                "required": [
                  "blockListId",
                  "name",
                  "entries"
                ],
                "properties": {
                  "blockListId": {
                    "$ref": "#/paths/~1blocklists/post/responses/201/content/application~1json/schema/properties/blockListId",
                    "readOnly": true,
                    "description": "The system-generated unique ID for this blocklist.\n"
                  },
                  "description": {
                    "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/description",
                    "description": "A description of the blocklist.\n"
                  },
                  "endDate": {
                    "$ref": "#/paths/~1blocklists/post/responses/201/content/application~1json/schema/properties/endDate",
                    "description": "The date in the future when the blocklist ends, expressed as an ISO 8601 timestamp. If the member is omitted or the value is set to an empty string, the corresponding entries are always blocked.\n"
                  },
                  "entries": {
                    "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/entries",
                    "type": "array",
                    "items": {
                      "description": "Lists up to 10,000 addresses to block in any combination of IPv4 and IPv6 addresses and CIDR block values.\n",
                      "type": "string"
                    }
                  },
                  "name": {
                    "$ref": "#/paths/~1blocklists/post/requestBody/content/application~1json/schema/properties/name",
                    "description": "The unique name for this blocklist.\n"
                  }
                }
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "$ref": "#/paths/~1blocklists/post/responses/201/content/application~1json/example"
                },
                "schema": {
                  "$ref": "#/paths/~1blocklists/post/responses/201/content/application~1json/schema"
                }
              }
            },
            "description": "Successful response\n"
          },
          "400": {
            "$ref": "#/paths/~1blocklists/post/responses/400"
          },
          "403": {
            "$ref": "#/paths/~1blocklists/get/responses/403"
          },
          "404": {
            "$ref": "#/paths/~1blocklists~1%7BblockListId%7D/get/responses/404"
          },
          "409": {
            "$ref": "#/paths/~1blocklists/post/responses/409"
          }
        },
        "security": [
          {
            "oauth_v2": [
              "network-policy.admin"
            ]
          }
        ]
      }
    }
  },
  "x-readme": {
    "explorer-enabled": true,
    "proxy-enabled": true
  }
}
```

# Sibling pages

* [Remove a blocklist](https://techdocs.akamai.com/aura-network-policy/reference/delete-blocklist.md)
* [Get a blocklist](https://techdocs.akamai.com/aura-network-policy/reference/get-blocklist.md)