---
updatedAt: 2026-03-01T18:09:40.000Z
agentTools:
  siteIndex: https://techdocs.akamai.com/llms.txt
  projectIndex: https://techdocs.akamai.com/api-definitions/llms.txt
---

# List resources

Lists all resources assigned to an endpoint version. You can use the `apiResourceId` of each returned resource to modify resources individually through the [Edit a resource](ref:put-version-resource) operation, or run the [Edit a version](ref:put-endpoint-version) operation to batch-modify a group of resources.

# OpenAPI definition

```json
{
  "externalDocs": {
    "description": "See documentation for Akamai's API Endpoint Definition API",
    "url": "https://techdocs.akamai.com/api-definitions/reference"
  },
  "info": {
    "license": {
      "name": "Apache 2.0",
      "url": "https://www.apache.org/licenses/LICENSE-2.0.html"
    },
    "title": "API endpoints",
    "version": "v2"
  },
  "openapi": "3.0.0",
  "paths": {
    "/endpoints/{apiEndPointId}/versions/{versionNumber}/resources": {
      "get": {
        "description": "Lists all resources assigned to an endpoint version. You can use the `apiResourceId` of each returned resource to modify resources individually through the [Edit a resource](ref:put-version-resource) operation, or run the [Edit a version](ref:put-endpoint-version) operation to batch-modify a group of resources.",
        "externalDocs": {
          "description": "See documentation for this operation in Akamai's API Endpoint Definition API",
          "url": "https://techdocs.akamai.com/api-definitions/reference/get-endpoint-version-resources"
        },
        "operationId": "get-endpoint-version-resources",
        "parameters": [
          {
            "description": "For customers who manage more than one account, this [runs the operation from another account](https://techdocs.akamai.com/developer/docs/manage-many-accounts-with-one-api-client). The Identity and Access Management API provides a [list of available account switch keys](https://techdocs.akamai.com/iam-api/reference/get-client-account-switch-keys).",
            "in": "query",
            "name": "accountSwitchKey",
            "required": false,
            "schema": {
              "example": "1-5C0YLB:1-8BYUX",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "example": [
                  {
                    "apiResourceClonedFromId": null,
                    "apiResourceId": 2926712,
                    "apiResourceLogicId": 118435,
                    "apiResourceMethodNameLists": [
                      "POST",
                      "GET"
                    ],
                    "apiResourceName": "book",
                    "createDate": "2019-06-12T13:06:52+0000",
                    "createdBy": "bookstore_admin",
                    "description": "A book item within the bookstore API.",
                    "link": "/api-definitions/v1/endpoints/574127/resources",
                    "lockVersion": 0,
                    "private": false,
                    "resourcePath": "/book/{bookId}",
                    "updateDate": "2019-06-12T13:06:52+0000",
                    "updatedBy": "bookstore_admin"
                  },
                  {
                    "apiResourceClonedFromId": null,
                    "apiResourceId": 2935128,
                    "apiResourceLogicId": 126224,
                    "apiResourceMethodNameLists": [
                      "POST",
                      "GET",
                      "PUT"
                    ],
                    "apiResourceName": "user",
                    "createDate": "2019-06-17T08:17:23+0000",
                    "createdBy": "bookstore_admin",
                    "description": "A registered bookstore user.",
                    "link": "/api-definitions/v1/endpoints/574127/resources",
                    "lockVersion": 0,
                    "private": false,
                    "resourcePath": "/user/{userId}",
                    "updateDate": "2019-06-17T08:17:23+0000",
                    "updatedBy": "bookstore_admin"
                  },
                  {
                    "apiResourceClonedFromId": null,
                    "apiResourceId": 2935139,
                    "apiResourceLogicId": 126269,
                    "apiResourceMethodNameLists": [
                      "GET"
                    ],
                    "apiResourceName": "magazine",
                    "createDate": "2019-06-17T08:26:59+0000",
                    "createdBy": "bookstore_admin",
                    "description": "A magazine item within the bookstore API.",
                    "link": "/api-definitions/v1/endpoints/574127/resources",
                    "lockVersion": 0,
                    "private": false,
                    "resourcePath": "/magazine/{magazineId}",
                    "updateDate": "2019-06-17T08:26:59+0000",
                    "updatedBy": "bookstore_admin"
                  }
                ],
                "schema": {
                  "allOf": [
                    {
                      "description": "A resource assigned to an endpoint.",
                      "properties": {
                        "apiResourceClonedFromId": {
                          "description": "For cloned resources, the unique identifier for the source resource.",
                          "nullable": true,
                          "type": "integer"
                        },
                        "apiResourceId": {
                          "description": "The unique identifier for the resource.",
                          "type": "integer"
                        },
                        "apiResourceLogicId": {
                          "description": "The unique identifier for the resource across all endpoint versions.",
                          "type": "integer"
                        },
                        "apiResourceMethodNameLists": {
                          "description": "HTTP methods the resource may respond to.",
                          "items": {
                            "type": "string"
                          },
                          "type": "array"
                        },
                        "apiResourceName": {
                          "description": "The name of the resource.",
                          "type": "string"
                        },
                        "createDate": {
                          "description": "The ISO 8601 timestamp indicating when you created the resource.",
                          "format": "date-time",
                          "type": "string"
                        },
                        "createdBy": {
                          "description": "The identifier for the user who created the resource.",
                          "type": "string"
                        },
                        "description": {
                          "description": "The description to clarify the resource's function within the API. If you specify `null` in the request or omit this member from the object, the JSON response reflects it as an empty string.",
                          "nullable": true,
                          "type": "string"
                        },
                        "link": {
                          "description": "The location of the navigable resource within this API, for use by API clients.",
                          "nullable": true,
                          "type": "string"
                        },
                        "lockVersion": {
                          "description": "The identifier used for optimistic locking. See [Concurrency control](ref:concurrency-control) for details.",
                          "type": "integer"
                        },
                        "private": {
                          "description": "Whether the resource is private. API consumers can access private resources only if they identify with an appropriate API key.",
                          "type": "boolean"
                        },
                        "resourcePath": {
                          "description": "The URL path relative to the hostnames on which the resource resides. When entering a resource path, you can use curly brackets (`{}`) to define path parameters (for example, `/path/{pathparam}`). If you decide to do so, ensure that the value of the `apiParameterName` member in the corresponding parameter definition matches the name that you specified in the resource path.",
                          "type": "string"
                        },
                        "updateDate": {
                          "description": "The ISO 8601 timestamp indicating when you last modified the resource.",
                          "format": "date-time",
                          "type": "string"
                        },
                        "updatedBy": {
                          "description": "The identifier for the user who last modified the resource.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "apiResourceName",
                        "resourcePath"
                      ],
                      "type": "object",
                      "x-akamai": {
                        "file-path": "schemas/api-resource-meth-params-dto.yaml"
                      }
                    },
                    {
                      "required": [
                        "type",
                        "instance"
                      ],
                      "type": "object"
                    },
                    {
                      "properties": {
                        "apiResourceMethods": {
                          "description": "HTTP methods the resource may respond to.",
                          "items": {
                            "allOf": [
                              {
                                "required": [
                                  "type",
                                  "instance"
                                ],
                                "type": "object"
                              },
                              {
                                "description": "An HTTP method to which a resource may respond.",
                                "properties": {
                                  "apiResourceMethod": {
                                    "description": "The core HTTP method to which the resource may respond, either `GET`, `PUT`, `POST`, `DELETE`, `HEAD`, `PATCH`, or `OPTIONS`.",
                                    "enum": [
                                      "GET",
                                      "PUT",
                                      "POST",
                                      "DELETE",
                                      "HEAD",
                                      "PATCH",
                                      "OPTIONS"
                                    ],
                                    "type": "string"
                                  },
                                  "apiResourceMethodId": {
                                    "description": "__Read-only__ The unique identifier for the resource's allowed method.",
                                    "nullable": true,
                                    "readOnly": true,
                                    "type": "integer"
                                  },
                                  "apiResourceMethodLogicId": {
                                    "description": "__Read-only__ The unique identifier for the resource's method across all endpoint versions.",
                                    "nullable": true,
                                    "readOnly": true,
                                    "type": "integer"
                                  }
                                },
                                "required": [
                                  "apiResourceMethod"
                                ],
                                "type": "object",
                                "x-akamai": {
                                  "file-path": "schemas/api-method-parameters-dto.yaml"
                                }
                              },
                              {
                                "properties": {
                                  "apiParameters": {
                                    "description": "Parameter objects assigned to the method.",
                                    "items": {
                                      "allOf": [
                                        {
                                          "description": "A method's parameter.",
                                          "properties": {
                                            "apiChildParameters": {
                                              "description": "Child JSON members or XML elements for JSON or XML body type parameters.",
                                              "items": {
                                                "description": "A further nested endpoint object.",
                                                "type": "object",
                                                "x-akamai": {
                                                  "file-path": "schemas/api-parameter-dto-nested.yaml"
                                                }
                                              },
                                              "type": "array"
                                            },
                                            "apiParamLogicId": {
                                              "description": "__Read-only__ The unique identifier for the parameter across all endpoint versions.",
                                              "readOnly": true,
                                              "type": "integer"
                                            },
                                            "apiParameterId": {
                                              "description": "__Read-only__ The unique identifier for the parameter.",
                                              "readOnly": true,
                                              "type": "integer"
                                            },
                                            "apiParameterLocation": {
                                              "description": "The location of the parameter in an HTTP request, either `query`, `header`, `path`, `cookie`, or `body` for a JSON or XML body type parameter.",
                                              "enum": [
                                                "query",
                                                "header",
                                                "path",
                                                "cookie",
                                                "body"
                                              ],
                                              "type": "string"
                                            },
                                            "apiParameterName": {
                                              "description": "The name of the parameter. If the corresponding `apiParameterLocation` is `path`, ensure that this value matches the parameter name you specified in the `resourcePath`.",
                                              "type": "string"
                                            },
                                            "apiParameterNotes": {
                                              "description": "The description to clarify the parameter's function. If you specify an empty string in the request or omit this member from the object, the JSON response reflects it as `null`.",
                                              "nullable": true,
                                              "type": "string"
                                            },
                                            "apiParameterRequired": {
                                              "description": "Specifies whether the API user needs to specify the parameter. If the corresponding `apiParameterLocation` is `path`, set this member to `true`.",
                                              "type": "boolean"
                                            },
                                            "apiParameterRestriction": {
                                              "additionalProperties": false,
                                              "description": "Restrictions and XML representation rules specified for the parameter.",
                                              "nullable": true,
                                              "properties": {
                                                "arrayRestriction": {
                                                  "additionalProperties": false,
                                                  "description": "Restrictions for array type parameters. Define this object only if you enabled the corresponding `array` member.",
                                                  "nullable": true,
                                                  "properties": {
                                                    "collectionFormat": {
                                                      "default": "csv",
                                                      "description": "The format of the array that specifies how you separated array values, either the default `csv` for comma separated values, `ssv` for space separated values, `tsv` for tab separated values, `pipes` for pipe separated values, or `multi` for several parameter instances instead of several values for a single instance.",
                                                      "enum": [
                                                        "csv",
                                                        "ssv",
                                                        "tsv",
                                                        "pipes",
                                                        "multi"
                                                      ],
                                                      "type": "string"
                                                    },
                                                    "maxItems": {
                                                      "description": "The maximum allowed number of array items.",
                                                      "maximum": 256,
                                                      "minimum": 0,
                                                      "type": "integer"
                                                    },
                                                    "minItems": {
                                                      "description": "The minimum allowed number of array items.",
                                                      "maximum": 256,
                                                      "minimum": 0,
                                                      "type": "integer"
                                                    },
                                                    "uniqueItems": {
                                                      "description": "Whether the array contains only unique items.",
                                                      "type": "boolean"
                                                    }
                                                  },
                                                  "type": "object"
                                                },
                                                "lengthRestriction": {
                                                  "additionalProperties": false,
                                                  "description": "Length restrictions for string type parameters.",
                                                  "nullable": true,
                                                  "properties": {
                                                    "lengthMax": {
                                                      "description": "The maximum allowed number of characters in the string.",
                                                      "nullable": true,
                                                      "type": "integer"
                                                    },
                                                    "lengthMin": {
                                                      "description": "The minimum allowed number of characters in the string.",
                                                      "nullable": true,
                                                      "type": "integer"
                                                    }
                                                  },
                                                  "type": "object"
                                                },
                                                "numberRangeRestriction": {
                                                  "additionalProperties": false,
                                                  "description": "Range restrictions for number type parameters.",
                                                  "nullable": true,
                                                  "properties": {
                                                    "numberRangeMax": {
                                                      "description": "The maximum range restriction.",
                                                      "nullable": true,
                                                      "type": "number"
                                                    },
                                                    "numberRangeMin": {
                                                      "description": "The minimum range restriction.",
                                                      "nullable": true,
                                                      "type": "number"
                                                    }
                                                  },
                                                  "type": "object"
                                                },
                                                "rangeRestriction": {
                                                  "additionalProperties": false,
                                                  "description": "Range restrictions for integer type parameters.",
                                                  "nullable": true,
                                                  "properties": {
                                                    "rangeMax": {
                                                      "description": "The maximum range restriction.",
                                                      "nullable": true,
                                                      "type": "integer"
                                                    },
                                                    "rangeMin": {
                                                      "description": "The minimum range restriction.",
                                                      "nullable": true,
                                                      "type": "integer"
                                                    }
                                                  },
                                                  "type": "object"
                                                },
                                                "responseRestriction": {
                                                  "additionalProperties": false,
                                                  "description": "Response restrictions on the status codes and the response body size.",
                                                  "properties": {
                                                    "maxBodySize": {
                                                      "description": "Limit how large the response body can be before tripping the firewall action. The default is `SIZE_6K`. You can choose `SIZE_8K`, `SIZE_12K`, or `NO_LIMIT`, which allows a response of any size.",
                                                      "enum": [
                                                        "SIZE_6K",
                                                        "SIZE_8K",
                                                        "SIZE_12K",
                                                        "NO_LIMIT"
                                                      ],
                                                      "type": "string"
                                                    },
                                                    "statusCodes": {
                                                      "description": "The response status codes to match to a particular response body format. A `null` or empty value means the response body definition applies to any response body.",
                                                      "items": {
                                                        "type": "integer"
                                                      },
                                                      "nullable": true,
                                                      "type": "array"
                                                    }
                                                  },
                                                  "type": "object"
                                                },
                                                "xmlConversionRule": {
                                                  "additionalProperties": false,
                                                  "description": "An XML representation of a JSON-encoded parameter.",
                                                  "nullable": true,
                                                  "properties": {
                                                    "attribute": {
                                                      "default": false,
                                                      "description": "Whether the parameter should be represented as an attribute.",
                                                      "type": "boolean"
                                                    },
                                                    "name": {
                                                      "description": "The name of the parameter in XML. By default, the XML name is the same as the parameter name specified in the API definition.",
                                                      "type": "string"
                                                    },
                                                    "namespace": {
                                                      "description": "The XML namespace.",
                                                      "type": "string"
                                                    },
                                                    "prefix": {
                                                      "description": "The prefix for the XML namespace.",
                                                      "type": "string"
                                                    },
                                                    "wrapped": {
                                                      "default": false,
                                                      "description": "Whether the parameter should be wrapped in a parent XML element.",
                                                      "type": "boolean"
                                                    }
                                                  },
                                                  "type": "object",
                                                  "x-akamai": {
                                                    "file-path": "schemas/xml-restriction-dto.yaml"
                                                  }
                                                }
                                              },
                                              "type": "object"
                                            },
                                            "apiParameterType": {
                                              "description": "The data type of the parameter, either `string`, `integer`, `number`, `boolean`, or `json/xml` for JSON or XML objects.",
                                              "enum": [
                                                "string",
                                                "integer",
                                                "number",
                                                "boolean",
                                                "json/xml"
                                              ],
                                              "type": "string"
                                            },
                                            "apiResourceMethParamId": {
                                              "description": "__Read-only__ The unique identifier for the parameter's parent method.",
                                              "nullable": true,
                                              "readOnly": true,
                                              "type": "integer"
                                            },
                                            "array": {
                                              "description": "Whether the parameter can express more than one value. This member is only applicable for `apiChildParameters` that you can specify if the corresponding `apiParameterLocation` is `body` and the `apiParameterType` is `json/xml`. If you enable this, also define the `arrayRestriction` member.",
                                              "type": "boolean"
                                            },
                                            "arrayItemNullable": {
                                              "description": "Indicates whether items in an array parameter can be `null`.",
                                              "nullable": true,
                                              "type": "boolean"
                                            },
                                            "nullable": {
                                              "default": false,
                                              "description": "Indicates whether the parameter value can be `null`.",
                                              "nullable": true,
                                              "type": "boolean"
                                            },
                                            "pathParamLocationId": {
                                              "description": "The index of a segment that includes a path parameter in a resource path. For example, given a path `\\books\\{bookId}`, the `books` segment has index `0`, and the path parameter `{bookId}` has index `1`.",
                                              "nullable": true,
                                              "type": "integer"
                                            },
                                            "response": {
                                              "description": "Whether the parameter is within a response type.",
                                              "type": "boolean"
                                            }
                                          },
                                          "required": [
                                            "apiParameterName",
                                            "apiParameterType",
                                            "apiParameterRequired",
                                            "apiParameterLocation"
                                          ],
                                          "type": "object",
                                          "x-akamai": {
                                            "file-path": "schemas/api-parameter-dto.yaml"
                                          }
                                        },
                                        {
                                          "required": [
                                            "type",
                                            "instance"
                                          ],
                                          "type": "object"
                                        },
                                        {
                                          "properties": {
                                            "apiParameterContentType": {
                                              "description": "The content type of the parameter, either `json`, `xml`, `any`, or `none`. Only applicable for top-level body parameters.",
                                              "enum": [
                                                "json",
                                                "xml",
                                                "any",
                                                "none"
                                              ],
                                              "type": "string"
                                            }
                                          },
                                          "type": "object"
                                        }
                                      ],
                                      "description": "A method's parameter.",
                                      "x-akamai": {
                                        "file-path": "schemas/api-parameter-dto-response.yaml"
                                      }
                                    },
                                    "nullable": true,
                                    "type": "array"
                                  }
                                },
                                "type": "object"
                              }
                            ],
                            "description": "An HTTP method to which a resource may respond.",
                            "x-akamai": {
                              "file-path": "schemas/api-method-parameters-dto-response.yaml"
                            }
                          },
                          "type": "array"
                        }
                      },
                      "type": "object"
                    }
                  ],
                  "description": "A resource assigned to an endpoint.",
                  "x-akamai": {
                    "file-path": "schemas/api-resource-meth-params-dto-response.yaml"
                  }
                }
              }
            },
            "description": "The response lists API endpoint resources you have access to."
          },
          "403": {
            "content": {
              "application/problem+json": {
                "example": {
                  "detail": "You have insufficient permissions to perform this action. Ensure that you have the correct permissions set in Identity and Access Management.",
                  "instance": "2602aedd-38a9-41c3-a607-8a6ad8129e6b",
                  "status": 403,
                  "title": "Forbidden",
                  "type": "/api-definitions/error-types/forbidden"
                },
                "schema": {
                  "additionalProperties": true,
                  "description": "Contains debugging information for error responses.",
                  "properties": {
                    "detail": {
                      "description": "The detailed error message.",
                      "type": "string"
                    },
                    "errors": {
                      "description": "Nested error responses.",
                      "items": {
                        "description": "A further nested problem detail object.",
                        "type": "object",
                        "x-akamai": {
                          "file-path": "schemas/http-problem-details-recurse.yaml"
                        }
                      },
                      "type": "array"
                    },
                    "instance": {
                      "description": "The non-referenceable URL for the error instance.",
                      "type": "string"
                    },
                    "status": {
                      "description": "The HTTP status code.",
                      "type": "integer"
                    },
                    "title": {
                      "description": "The title of the error.",
                      "type": "string"
                    },
                    "type": {
                      "description": "The URL for the error type.",
                      "type": "string"
                    }
                  },
                  "type": "object",
                  "x-akamai": {
                    "file-path": "schemas/http-problem-details.yaml"
                  }
                }
              }
            },
            "description": "[Forbidden](ref:403). You don't have permission to access the API endpoint.",
            "x-akamai": {
              "file-path": "errors/403.yaml"
            }
          }
        },
        "summary": "List resources",
        "tags": [
          "Resources"
        ]
      },
      "parameters": [
        {
          "description": "The unique identifier for the endpoint version.",
          "in": "path",
          "name": "versionNumber",
          "required": true,
          "schema": {
            "example": 1,
            "type": "integer"
          },
          "x-akamai": {
            "file-path": "parameters/version-number-path.yaml"
          }
        },
        {
          "description": "The unique identifier for the endpoint.",
          "in": "path",
          "name": "apiEndPointId",
          "required": true,
          "schema": {
            "example": 1,
            "type": "integer"
          },
          "x-akamai": {
            "file-path": "parameters/api-end-point-id-path.yaml"
          }
        }
      ],
      "x-akamai": {
        "file-path": "paths/resources.yaml",
        "path-info": "/endpoints/{apiEndPointId}/versions/{versionNumber}/resources"
      }
    }
  },
  "servers": [
    {
      "url": "https://{hostname}/api-definitions/v2"
    }
  ],
  "x-akamai": {
    "auth-type": "EDGE_GRID",
    "file-path": "03-api-endpoint-resource.yaml"
  },
  "x-readme": {
    "samples-languages": [
      "curl",
      "python",
      "node"
    ],
    "explorer-enabled": true,
    "proxy-enabled": true
  }
}
```

# Sibling pages

* [Create a resource](https://techdocs.akamai.com/api-definitions/reference/post-resource.md)
* [Get a version](https://techdocs.akamai.com/api-definitions/reference/get-version-details.md)
* [Get a resource](https://techdocs.akamai.com/api-definitions/reference/get-endpoint-version-resource.md)
* [Edit a resource](https://techdocs.akamai.com/api-definitions/reference/put-version-resource.md)
* [Delete a resource](https://techdocs.akamai.com/api-definitions/reference/delete-endpoint-version-resource.md)