---
updatedAt: 2026-04-20T19:20:27.000Z
---

# Remove a node

This operation removes a node.

# OpenAPI definition

```json
{
  "openapi": "3.0.0",
  "info": {
    "title": "Nodes",
    "version": "v1"
  },
  "servers": [
    {
      "url": "https://{hostname}/api/infrastructure/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": {
              "coblitz.co": "d",
              "coblitz.obs": "d",
              "infrastructure.admin": "d",
              "infrastructure.read": "d"
            }
          }
        }
      }
    }
  },
  "paths": {
    "/nodes": {
      "get": {
        "operationId": "get-nodes",
        "summary": "List nodes",
        "description": "This operation returns a list of all configured nodes.",
        "parameters": [
          {
            "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 view parameter may be used to request that either the summary or detailed view be returned.\n",
            "in": "query",
            "name": "view",
            "schema": {
              "default": "summary",
              "type": "string"
            }
          },
          {
            "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 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 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": 50
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response\n"
          },
          "201": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "Node collection.\n",
                  "properties": {
                    "nodes": {
                      "items": {
                        "description": "Node read summary schema.\n",
                        "properties": {
                          "hostname": {
                            "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/hostname"
                          },
                          "nodeId": {
                            "$ref": "#/paths/~1nodes~1%7BnodeId%7D/put/requestBody/content/application~1json/schema/properties/nodeId"
                          }
                        },
                        "required": [
                          "nodeId",
                          "hostname"
                        ],
                        "type": "object"
                      },
                      "type": "array"
                    },
                    "page": {
                      "description": "Common page properties for search results.\n",
                      "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"
                        }
                      },
                      "required": [
                        "pageNumber",
                        "pageSize"
                      ]
                    }
                  },
                  "required": [
                    "nodes",
                    "page"
                  ],
                  "type": "object"
                },
                "example": {
                  "page": {
                    "pageNumber": 1,
                    "pageSize": 100,
                    "totalPages": 1,
                    "totalResults": 2
                  },
                  "nodes": [
                    {
                      "nodeId": 1,
                      "hostname": "node1.us-ma-east-1.example.com"
                    },
                    {
                      "nodeId": 2,
                      "hostname": "node2.us-ma-east-1.example.com"
                    }
                  ]
                }
              }
            },
            "description": "Successful response\n"
          },
          "403": {
            "content": {
              "application/json": {
                "schema": {
                  "description": "Unauthorized access HTTP problem.\n",
                  "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"
                        }
                      }
                    }
                  ],
                  "required": [
                    "type",
                    "instance",
                    "entity",
                    "permission"
                  ]
                }
              }
            },
            "description": "An HTTP 403 will be returned if the principal is not authorized to access the instance of node that the request was made against.\n"
          }
        },
        "security": [
          {
            "oauth_v2": [
              "coblitz.co",
              "coblitz.obs",
              "infrastructure.admin",
              "infrastructure.read"
            ]
          }
        ]
      },
      "post": {
        "operationId": "post-nodes",
        "summary": "Create a new node",
        "description": "This operation creates a new node.",
        "requestBody": {
          "content": {
            "application/json": {
              "example": {
                "hostname": "node1.us-ma-east-1.example.com",
                "siteId": 1,
                "bootState": "BOOT",
                "administrativeState": "ACTIVE",
                "dnsServers": [
                  "8.8.8.8"
                ],
                "attributes": [
                  {
                    "attributeTypeId": 1,
                    "value": "MA"
                  },
                  {
                    "attributeTypeId": 2,
                    "value": "Cambridge"
                  }
                ],
                "interfaces": [
                  {
                    "name": "eth0",
                    "macAddress": "00:11:22:33:44:55",
                    "type": "ETHERNET",
                    "ip4Addresses": [
                      {
                        "ipAddress": "1.1.1.1/24",
                        "management": true
                      }
                    ],
                    "ip4Routes": [
                      {
                        "destination": "2.2.2.0/24",
                        "nextHop": "1.1.1.10",
                        "metric": 1
                      }
                    ],
                    "ip6Addresses": [
                      {
                        "ipAddress": "2001::8000:1234/64"
                      }
                    ],
                    "ip6Routes": [
                      {
                        "destination": "2001::8000:2000/64",
                        "nextHop": "2001::8000:1",
                        "metric": 100
                      }
                    ]
                  },
                  {
                    "name": "eth1",
                    "macAddress": "00:11:22:33:44:61",
                    "type": "ETHERNET",
                    "master": "lag0"
                  },
                  {
                    "name": "eth2",
                    "macAddress": "00:11:22:33:44:62",
                    "type": "ETHERNET",
                    "master": "lag0"
                  },
                  {
                    "name": "lag0",
                    "type": "BOND",
                    "slaveInterfaces": [
                      "eth1",
                      "eth2"
                    ]
                  }
                ]
              },
              "schema": {
                "description": "A node represents an aggregation of relevant parts that include a list of interfaces, each containing a list of addresses and routes, and a list of attribute\nvalues.\n",
                "properties": {
                  "administrativeState": {
                    "description": "The administrative state of the node, either `ACTIVE` or `MAINTENANCE`. The default is `ACTIVE`. Use `MAINTENANCE` to remove a node from service, do routine software maintenance, or add or remove storage devices on a service node.\n",
                    "type": "string",
                    "enum": [
                      "ACTIVE",
                      "MAINTENANCE"
                    ]
                  },
                  "attributes": {
                    "description": "Array of mappings of attributeType to value for this node.\n",
                    "type": "array",
                    "maxItems": 20,
                    "items": {
                      "description": "Array of mappings of attributeType to value for this node.\n",
                      "type": "object",
                      "properties": {
                        "attributeTypeId": {
                          "type": "integer",
                          "description": "Unique identifier for attributeType.\n"
                        },
                        "value": {
                          "description": "Value to assign for this node.\n",
                          "type": "string",
                          "minLength": 1,
                          "maxLength": 256
                        }
                      },
                      "required": [
                        "attributeTypeId",
                        "value"
                      ]
                    }
                  },
                  "bootState": {
                    "description": "When booting, the action the node should take `BOOT`, `REINSTALL`, `INSTALL`, or `UPGRADE`. In `BOOT` state, the node completes a normal boot process and runs in production mode. `REINSTALL` causes the node to reinstall and overwrite the system partition and boot partition on all disks and the associated data, but does not update the kernel partition. Use the `INSTALL` state for a node on which no Aura software is installed. Do not use `UPGRADE` to upgrade the software on a service node; use the upgrade_step.py script. For detailed information about upgrading a service node using the upgrade_step.py script, see the \"Service Node Upgrade with upgrade_step.py\" in the  [Aura LCDN/LMS Upgrade Guide](https://control.akamai.com/wh/CUSTOMER/AKAMAI/en-US/WEBHELP/portal-guides/aura-licensed-cdn/GUID-867C3390-F48F-4845-9EDD-BDD5F917B71A.html).\n",
                    "type": "string",
                    "enum": [
                      "BOOT",
                      "REINSTALL",
                      "INSTALL",
                      "UPGRADE"
                    ]
                  },
                  "dnsServers": {
                    "type": "array",
                    "description": "List of DNS Server IP addresses.\n",
                    "minItems": 1,
                    "maxItems": 2,
                    "items": {
                      "type": "string",
                      "format": "ipv4, ipv6"
                    }
                  },
                  "hostname": {
                    "type": "string",
                    "format": "hostname",
                    "description": "The unique fully qualified domain name (FQDN) for this node.\n"
                  },
                  "interfaces": {
                    "type": "array",
                    "minItems": 1,
                    "maxItems": 36,
                    "description": "List of interfaces for the node.  Bond interfaces `lag0`, `lag1`, `lag2`, and `lag3` must exist.  If not supplied on a POST, they will be added.  A minimum of one and maximum of 32 ethernet interfaces must exist.  One of the ethernet interfaces must contain the management address, and this interface may not be part of a bond.\n",
                    "items": {
                      "oneOf": [
                        {
                          "description": "A node ethernet interface.\n",
                          "type": "object",
                          "properties": {
                            "name": {
                              "type": "string",
                              "description": "Interface name, such as `eth0`.\n",
                              "pattern": "^eth([1-9][0-9]|[0-9])$"
                            },
                            "macAddress": {
                              "type": "string",
                              "description": "Interface MAC address.\n",
                              "pattern": "^([0-9A-F]{2}[:-]){5}([0-9A-F]{2})$"
                            },
                            "type": {
                              "type": "string",
                              "description": "Identifies the interface type. The only supported type is `ETHERNET`.\n",
                              "enum": [
                                "ETHERNET"
                              ]
                            },
                            "master": {
                              "type": "string",
                              "description": "Designates the master bonding interface for this interface.\n",
                              "readOnly": true
                            },
                            "ip4Addresses": {
                              "type": "array",
                              "minItems": 0,
                              "maxItems": 32,
                              "items": {
                                "description": "An IPv4 address.\n",
                                "properties": {
                                  "ipAddress": {
                                    "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip4Routes/items/properties/destination"
                                  },
                                  "management": {
                                    "type": "boolean",
                                    "description": "Indicates whether this is the management address.  There may only be one management address.\n",
                                    "default": false
                                  }
                                },
                                "required": [
                                  "ipAddress"
                                ]
                              }
                            },
                            "ip6Addresses": {
                              "type": "array",
                              "minItems": 0,
                              "maxItems": 32,
                              "items": {
                                "description": "An IPv6 address.\n",
                                "properties": {
                                  "ipAddress": {
                                    "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip6Routes/items/properties/destination"
                                  }
                                },
                                "required": [
                                  "ipAddress"
                                ]
                              }
                            },
                            "ip4Routes": {
                              "type": "array",
                              "maxItems": 256,
                              "items": {
                                "description": "A single IPv4 route.\n",
                                "properties": {
                                  "destination": {
                                    "type": "string",
                                    "description": "An IPv4 address.\n",
                                    "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])$"
                                  },
                                  "nextHop": {
                                    "type": "string",
                                    "description": "The address of the next gateway to which packets should be forwarded along the path to their final destination.\n",
                                    "format": "ipv4"
                                  },
                                  "sourceIpAddress": {
                                    "type": "string",
                                    "description": "The IPv4 source address for this IPv4 route.\n",
                                    "format": "ipv4"
                                  },
                                  "metric": {
                                    "type": "integer",
                                    "description": "A value up to 9999 that represents the cost metric for this static route. The route with the lowest metric is chosen among multiple routes that most closely match the destination address of a packet being forwarded.\n",
                                    "minimum": 0
                                  }
                                },
                                "required": [
                                  "destination",
                                  "nextHop"
                                ]
                              }
                            },
                            "ip6Routes": {
                              "type": "array",
                              "maxItems": 256,
                              "items": {
                                "description": "A single IPv6 route.\n",
                                "properties": {
                                  "destination": {
                                    "oneOf": [
                                      {
                                        "type": "string",
                                        "description": "An IPv6 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 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])$"
                                      }
                                    ]
                                  },
                                  "nextHop": {
                                    "type": "string",
                                    "description": "The address of the next gateway to which packets should be forwarded along the path to their final destination.\n",
                                    "format": "ipv6"
                                  },
                                  "sourceIpAddress": {
                                    "type": "string",
                                    "description": "The IPv6 source address for this IPv6 route.\n",
                                    "format": "ipv6"
                                  },
                                  "metric": {
                                    "type": "integer",
                                    "description": "A value up to 9999 that represents the cost metric for this static route. The route with the lowest metric is chosen among multiple routes that most closely match the destination address of a packet being forwarded.\n",
                                    "minimum": 0
                                  }
                                },
                                "required": [
                                  "destination",
                                  "nextHop"
                                ]
                              }
                            }
                          },
                          "required": [
                            "name",
                            "macAddress",
                            "type"
                          ]
                        },
                        {
                          "description": "A node bonding virtual interface.\n",
                          "type": "object",
                          "properties": {
                            "name": {
                              "type": "string",
                              "description": "Interface name, such as `lag0`.\n",
                              "pattern": "^(bond|lag)([1-9][0-9]|[0-9])$"
                            },
                            "type": {
                              "type": "string",
                              "description": "Identifies the interface type. The only supported type is `BOND`.\n",
                              "enum": [
                                "BOND"
                              ]
                            },
                            "slaveInterfaces": {
                              "description": "List of slave interfaces for this bond.\n",
                              "type": "array",
                              "items": {
                                "type": "string",
                                "description": "Interface name of slave interface.\n"
                              }
                            },
                            "ip4Addresses": {
                              "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip4Addresses"
                            },
                            "ip6Addresses": {
                              "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip6Addresses"
                            },
                            "ip4Routes": {
                              "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip4Routes"
                            },
                            "ip6Routes": {
                              "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces/items/oneOf/0/properties/ip6Routes"
                            }
                          },
                          "required": [
                            "name",
                            "type"
                          ]
                        }
                      ]
                    }
                  },
                  "siteId": {
                    "description": "The unique identifier for a site.\n",
                    "type": "integer",
                    "minimum": 1
                  }
                },
                "required": [
                  "siteId",
                  "hostname",
                  "dnsServers",
                  "interfaces"
                ],
                "type": "object"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": {
                  "$ref": "#/paths/~1nodes~1%7BnodeId%7D/put/requestBody/content/application~1json/example"
                },
                "schema": {
                  "description": "Node read detailed schema.\n",
                  "properties": {
                    "administrativeState": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/administrativeState"
                    },
                    "attributes": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/attributes"
                    },
                    "bootState": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/bootState"
                    },
                    "dnsServers": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/dnsServers"
                    },
                    "hostname": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/hostname"
                    },
                    "interfaces": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/interfaces"
                    },
                    "nodeId": {
                      "$ref": "#/paths/~1nodes~1%7BnodeId%7D/put/requestBody/content/application~1json/schema/properties/nodeId"
                    },
                    "siteId": {
                      "$ref": "#/paths/~1nodes/post/requestBody/content/application~1json/schema/properties/siteId"
                    }
                  },
                  "required": [
                    "nodeId",
                    "siteId",
                    "hostname",
                    "bootState",
                    "administrativeState",
                    "dnsServers",
                    "interfaces"
                  ],
                  "type": "object"
                }
              }
            },
            "description": "Successful response\n",
            "headers": {
              "Location": {
                "description": "The `Location` header specifies a URL pointing to the newly created resource.\n",
                "schema": {
                  "type": "string"
                }
              }
            }
          },
          "201": {
            "description": "An HTTP 201 will be returned if the request is successfully processed, and a new node object is created. The location of the new object will be specified in the `Location` header.\n",
            "headers": {
              "$ref": "#/paths/~1nodes/post/responses/200/headers"
            }
          },
          "400": {
            "content": {
              "application/json": {
                "example": {
                  "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/errors#core.constraint-violation",
                  "title": "The request entity is invalid",
                  "detail": "Constraint violations were detected",
                  "instance": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/v1/nodes#7284f092-f2f1-4131-a9dc-f8a5b7b6980f",
                  "violations": [
                    {
                      "property": "#/hostname",
                      "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/errors#core.not-null-violation",
                      "detail": "may not be null"
                    }
                  ]
                },
                "schema": {
                  "description": "An HTTP 400 will be returned if the request is badly formed or has constraint violations\n",
                  "anyOf": [
                    {
                      "description": "Invalid path param HTTP problem.  Used when the server can't process a path param due to incorrect type/formatting.\n",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "pathParamName": {
                              "type": "string"
                            },
                            "pathParamValue": {
                              "description": "The value supplied in the request.\n"
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "pathParamName",
                        "pathParamValue"
                      ]
                    },
                    {
                      "description": "JSON mapping HTTP problem.\n",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "property": {
                              "type": "string"
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "property"
                      ]
                    },
                    {
                      "$ref": "#/paths/~1nodes/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",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "uriParameterName": {
                              "type": "string",
                              "description": "The name of the URI parameter.\n"
                            },
                            "uriParameterValue": {
                              "description": "The supplied value of the URI parameter.\n"
                            },
                            "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"
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "uriParameterName",
                        "uriParameterValue",
                        "property",
                        "propertyValue"
                      ]
                    },
                    {
                      "description": "Invalid parameter HTTP problem.\n",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/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"
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "parameter",
                        "value"
                      ]
                    },
                    {
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "violations": {
                              "type": "array",
                              "items": {
                                "anyOf": [
                                  {
                                    "allOf": [
                                      {
                                        "properties": {
                                          "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"
                                          },
                                          "type": {
                                            "type": "string",
                                            "format": "uri",
                                            "description": "Uniquely identifies this HTTP problem.\n"
                                          },
                                          "detail": {
                                            "type": "string",
                                            "description": "Human readable description of the problem.\n"
                                          }
                                        },
                                        "required": [
                                          "property",
                                          "type"
                                        ]
                                      }
                                    ]
                                  },
                                  {
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1nodes/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",
                                      "min"
                                    ]
                                  },
                                  {
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1nodes/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",
                                      "max"
                                    ]
                                  },
                                  {
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1nodes/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",
                                      "size"
                                    ]
                                  },
                                  {
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1nodes/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",
                                      "pattern"
                                    ]
                                  },
                                  {
                                    "allOf": [
                                      {
                                        "$ref": "#/paths/~1nodes/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"
                                          }
                                        }
                                      }
                                    ],
                                    "required": [
                                      "property",
                                      "type",
                                      "value",
                                      "requiredValue"
                                    ]
                                  }
                                ]
                              }
                            }
                          }
                        }
                      ]
                    }
                  ]
                }
              }
            },
            "description": "An HTTP 400 will be returned if the request is badly formed or has constraint violations\n"
          },
          "403": {
            "$ref": "#/paths/~1nodes/get/responses/403"
          },
          "409": {
            "content": {
              "application/json": {
                "example": {
                  "type": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/errors#core.entity-property-conflict",
                  "title": "The request has conflicting properties with existing configuration",
                  "detail": "An entity with property 'hostname' of 'test.akamai.com' already exists",
                  "instance": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/v1/nodes#a4e84e37-ec37-4a13-83d7-ba1d75a36029",
                  "conflictingProperty": "#/hostname",
                  "conflictingValue": "test.akamai.com",
                  "conflictingEntity": {
                    "entityHref": "https://akzz-xxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx.luna.akamaiapis.net/api/infrastructure/v1/nodes/1",
                    "entityType": "Node",
                    "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",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "conflictingProperty": {
                              "type": "string"
                            },
                            "conflictingValue": {
                              "description": "The supplied value.\n"
                            },
                            "conflictingEntity": {
                              "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/1/properties/entity",
                              "description": "The existing entity which the proposed change is in conflict with.\n"
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "conflictingProperty",
                        "conflictingValue",
                        "conflictingEntity"
                      ]
                    },
                    {
                      "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",
                      "allOf": [
                        {
                          "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "referencedEntity": {
                              "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/1/properties/entity"
                            },
                            "referringEntities": {
                              "type": "array",
                              "items": {
                                "$ref": "#/paths/~1nodes/get/responses/403/content/application~1json/schema/allOf/1/properties/entity"
                              }
                            }
                          }
                        }
                      ],
                      "required": [
                        "type",
                        "instance",
                        "referencedEntity",
                        "referringEntities"
                      ]
                    },
                    {
                      "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/~1nodes/get/responses/403/content/application~1json/schema/allOf/0"
                        },
                        {
                          "properties": {
                            "referencedType": {
                              "type": "string",
                              "description": "The type of the object that was referenced.\n"
                            },
                            "referencedId": {
                              "description": "The Id of the object that was referenced.\n"
                            }
                          }
                        }
                      ]
                    }
                  ]
                }
              }
            },
            "description": "An HTTP 409 will be returned if the node offered for create/update would lead to a conflicting state.\n"
          }
        },
        "security": [
          {
            "oauth_v2": [
              "coblitz.co",
              "infrastructure.admin"
            ]
          }
        ]
      }
    },
    "/nodes/{nodeId}": {
      "delete": {
        "operationId": "delete-node",
        "summary": "Remove a node",
        "description": "This operation removes a node.",
        "responses": {
          "204": {
            "description": "The node was successfully removed.\n"
          },
          "400": {
            "description": "An HTTP 400 will be returned if the request could not be processed.  For example, if another entity is referring to this entity, and the delete could not be processed.\n"
          },
          "403": {
            "$ref": "#/paths/~1nodes/get/responses/403"
          },
          "404": {
            "$ref": "#/paths/~1nodes~1%7BnodeId%7D/get/responses/404"
          },
          "409": {
            "$ref": "#/paths/~1nodes/post/responses/409"
          }
        },
        "security": [
          {
            "oauth_v2": [
              "coblitz.co",
              "infrastructure.admin"
            ]
          }
        ]
      },
      "parameters": [
        {
          "description": "Uniquely identifies a node.\n",
          "in": "path",
          "name": "nodeId",
          "required": true,
          "schema": {
            "type": "integer",
            "example": 1
          }
        }
      ]
    }
  },
  "x-readme": {
    "explorer-enabled": true,
    "proxy-enabled": true
  }
}
```

# Sibling pages

* [Get a node](https://techdocs.akamai.com/aura-infrastructure/reference/get-node.md)
* [Update a node](https://techdocs.akamai.com/aura-infrastructure/reference/put-node.md)