---
updatedAt: 2026-07-01T08:06:06.000Z
agentTools:
  projectIndex: https://docs.pixop.com/llms.txt
---

# Update an API key

Updates the name or description of an existing API key. To activate or deactivate an API key, use the respective endpoints.

# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "Pixop API",
    "description": "\nThe Pixop API provides a comprehensive RESTful interface for interacting with the Pixop Platform.\nIt allows users to manage API keys, projects, videos, and more.\n\nThe Pixop Platform offers video processing features such as upscaling, format conversion, and compression. It uses\nAI-driven algorithms to optimize video quality, reduce file sizes, and improve playback performance.\n\n**Quick Start Guide**\n- Explore the [Pixop API Documentation](https://docs.pixop.com/reference/) to familiarize yourself with the API's capabilities.\n\n**Required Headers**\nInclude the following headers in all API requests:\n- `Accept`: `application/json`\n- `Content-Type`: `application/json`\n- `X-API-Key`: Your API key for authentication (e.g., `X-API-Key: <your-api-key>`).  \n  **Note:** API key management endpoints that use Basic Authentication do not require the `X-API-Key` header.\n\n**Rate Limits**\nAll endpoints, except those related to API key management, enforce rate limits. Response headers provide the following rate limit details:\n- `X-RateLimit-Limit`: The maximum number of requests allowed per minute.\n- `X-RateLimit-Remaining`: The number of requests remaining in the current rate limit window.\n- `X-RateLimit-Reset`: The number of seconds until the current rate limit window resets.\n",
    "termsOfService": "https://docs.pixop.com/reference/terms-of-service",
    "contact": {
      "email": "api@pixop.com"
    },
    "version": "2.1.0"
  },
  "x-proxy-enabled": false,
  "externalDocs": {
    "description": "Learn more about Pixop",
    "url": "https://www.pixop.com"
  },
  "servers": [
    {
      "url": "https://api.pixop.com/api",
      "description": "Production environment"
    },
    {
      "url": "https://staging-api.pixop.com/api",
      "description": "Staging environment"
    }
  ],
  "tags": [
    {
      "name": "api key",
      "description": "Operations for managing API keys. These endpoints use Basic Authentication with an email and password."
    }
  ],
  "security": [
    {
      "api_key": []
    }
  ],
  "paths": {
    "/v1/api-keys/{id}": {
      "patch": {
        "tags": [
          "api key"
        ],
        "summary": "Update an API key",
        "description": "Updates the name or description of an existing API key. To activate or deactivate an API key, use the respective endpoints.",
        "operationId": "patchApiKey",
        "security": [
          {
            "basic_auth": []
          }
        ],
        "parameters": [
          {
            "$ref": "#/components/parameters/IdPathParam"
          }
        ],
        "requestBody": {
          "$ref": "#/components/requestBodies/ApiKeyPatchRequest"
        },
        "responses": {
          "200": {
            "description": "API key successfully updated.",
            "$ref": "#/components/responses/ApiKeyResponse"
          },
          "400": {
            "$ref": "#/components/responses/BadRequest"
          },
          "401": {
            "$ref": "#/components/responses/Unauthorized"
          },
          "403": {
            "$ref": "#/components/responses/Forbidden"
          },
          "404": {
            "$ref": "#/components/responses/NotFound"
          },
          "500": {
            "$ref": "#/components/responses/InternalServerError"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "UUID": {
        "type": "string",
        "format": "uuid",
        "description": "A universally unique identifier (UUID) compliant with [RFC 4122](https://tools.ietf.org/html/rfc4122). Used as a unique key to identify resources or entities across systems.",
        "examples": [
          "123e4567-e89b-12d3-a456-426614174000"
        ]
      },
      "BaseObject": {
        "type": "object",
        "description": "A base schema for common object attributes shared across multiple entities. Includes metadata such as ID and timestamps. Extended by specific schemas to inherit these common attributes.",
        "required": [
          "id",
          "createdAt",
          "updatedAt"
        ],
        "properties": {
          "id": {
            "description": "Unique identifier for the object.",
            "$ref": "#/components/schemas/UUID",
            "readOnly": true
          },
          "createdAt": {
            "description": "Date and time when the object was created.",
            "type": "string",
            "format": "date-time",
            "readOnly": true,
            "examples": [
              1734520108148
            ]
          },
          "updatedAt": {
            "description": "Date and time when the object was last updated.",
            "type": "string",
            "format": "date-time",
            "readOnly": true,
            "examples": [
              1734520708148
            ]
          }
        }
      },
      "ApiKeyActive": {
        "type": "boolean",
        "description": "Indicates whether this API key is active and can be used for authentication. An inactive API key cannot be used to access the platform's services."
      },
      "ApiKeyName": {
        "type": "string",
        "description": "A user-defined name to associate with the API key.",
        "maxLength": 47,
        "minLength": 1,
        "examples": [
          "My API Key"
        ]
      },
      "ApiKeyDescription": {
        "type": "string",
        "description": "A user-defined description of the API key, providing additional context or details about its purpose or usage.",
        "maxLength": 255,
        "minLength": 1,
        "examples": [
          "API key used for accessing video processing endpoints"
        ]
      },
      "SecretString": {
        "type": "string",
        "description": "A secret string where only the last three characters are visible, while the rest are masked for security purposes. \nTypically used for securely displaying sensitive values such as API keys.\n",
        "readOnly": true,
        "minLength": 20,
        "maxLength": 20,
        "examples": [
          "*****************123"
        ]
      },
      "ApiKey": {
        "allOf": [
          {
            "$ref": "#/components/schemas/BaseObject"
          },
          {
            "type": "object",
            "description": "Represents an API key associated with a user, providing authentication for API access.",
            "required": [
              "userId",
              "active",
              "name",
              "apiKeyHidden"
            ],
            "properties": {
              "userId": {
                "$ref": "#/components/schemas/UUID",
                "description": "The ID of the user this API key is associated with.",
                "readOnly": true
              },
              "active": {
                "$ref": "#/components/schemas/ApiKeyActive",
                "readOnly": true
              },
              "name": {
                "$ref": "#/components/schemas/ApiKeyName",
                "readOnly": true
              },
              "description": {
                "$ref": "#/components/schemas/ApiKeyDescription",
                "readOnly": true
              },
              "apiKeyHidden": {
                "$ref": "#/components/schemas/SecretString",
                "description": "The masked representation of the API key for display purposes.",
                "readOnly": true
              },
              "apiKey": {
                "type": "string",
                "description": "The full API key. This field is only present in the response when a new API key is created. \nAfterward, the API key is no longer retrievable for security reasons.\n",
                "readOnly": true
              },
              "deletionEligibleAt": {
                "type": "string",
                "format": "date",
                "readOnly": true,
                "description": "Calendar date (YYYY-MM-DD) indicating when this API key becomes eligible for automatic deletion due to inactivity. If the key is successfully used for authentication before this date, it will not be automatically deleted on that date and will remain active for at least another 90 days (a new inactivity window). After that, if it is again unused for a full inactivity window, a new deletionEligibleAt date may be assigned. If this field is null or omitted, the key is not currently eligible for automatic deletion.\n"
              }
            }
          }
        ]
      },
      "ApiKeyPatch": {
        "type": "object",
        "description": "Represents the fields that can be updated for an existing API key.",
        "properties": {
          "name": {
            "$ref": "#/components/schemas/ApiKeyName"
          },
          "description": {
            "$ref": "#/components/schemas/ApiKeyDescription"
          }
        }
      },
      "Error": {
        "description": "Represents an error response returned by the API. Provides details such as the error code, status, and any associated validation errors.\n",
        "type": "object",
        "required": [
          "timestamp",
          "requestId",
          "requestPath",
          "errorCode",
          "message",
          "statusCode"
        ],
        "properties": {
          "timestamp": {
            "description": "The date and time indicating when the error occurred.",
            "readOnly": true,
            "type": "string",
            "format": "date-time"
          },
          "requestId": {
            "description": "The unique identifier for the request that caused the error.",
            "readOnly": true,
            "type": "string",
            "format": "uuid"
          },
          "requestPath": {
            "description": "The API path that was accessed when the error occurred.",
            "readOnly": true,
            "type": "string"
          },
          "errorCode": {
            "description": "A code representing the specific error.",
            "readOnly": true,
            "type": "string"
          },
          "errorCodeEnum": {
            "description": "If present, the `errorCode` corresponds to one of Pixop’s documented error codes.",
            "readOnly": true,
            "$ref": "#/components/schemas/ErrorCodeEnum"
          },
          "message": {
            "description": "A human-readable message explaining the error.",
            "readOnly": true,
            "type": "string",
            "examples": [
              "Invalid input"
            ]
          },
          "statusCode": {
            "description": "The HTTP status code associated with the error.",
            "readOnly": true,
            "type": "integer",
            "examples": [
              400
            ]
          },
          "validationErrors": {
            "description": "A list of validation errors, if any.",
            "readOnly": true,
            "type": "array",
            "x-nullable": true,
            "default": null,
            "items": {
              "$ref": "#/components/schemas/ValidationError"
            }
          },
          "errorDetails": {
            "description": "Additional details about the error, if available.",
            "readOnly": true,
            "additionalProperties": true
          }
        }
      },
      "ErrorField": {
        "description": "The field in the request that caused the error.",
        "readOnly": true,
        "type": "string",
        "examples": [
          "name"
        ]
      },
      "ValidationError": {
        "description": "Represents a validation error for a specific field in the request. Provides details about the field, the invalid value, and the error message.",
        "type": "object",
        "properties": {
          "field": {
            "$ref": "#/components/schemas/ErrorField"
          },
          "value": {
            "description": "The invalid value provided for the field.",
            "readOnly": true,
            "type": "string",
            "examples": [
              48
            ]
          },
          "message": {
            "description": "A human-readable message explaining the validation error.",
            "readOnly": true,
            "type": "string",
            "examples": [
              "size must be between 1 and 47"
            ]
          }
        }
      },
      "ErrorCodeEnum": {
        "type": "string",
        "description": "Enumerates the known error codes returned by the API.\nNot all possible codes are listed here, and additional codes may be introduced in the future.\nWhen present, these values correspond to well-defined application or HTTP errors.\n",
        "enum": [
          "UNKNOWN",
          "TOO_MANY_REQUESTS",
          "INVALID_CREDENTIALS",
          "ACCOUNT_LOCKED",
          "ACCOUNT_DISABLED",
          "ACCOUNT_EXPIRED",
          "MISSING_API_KEY",
          "INVALID_API_KEY",
          "ACCESS_DENIED",
          "RESOURCE_NOT_FOUND",
          "TEAM_NOT_FOUND",
          "DEFAULT_TEAM_NOT_API_ENABLED",
          "INVALID_INPUT",
          "FORBIDDEN",
          "VALIDATION_ERROR",
          "WEBHOOK_NOT_ACTIVE",
          "TOO_MANY_WEBHOOK_TEST_EVENTS",
          "CONTAINER_IS_NOT_SUPPORTED_FOR_SELECTED_CODEC",
          "INSUFFICIENT_PROJECTED_BALANCE_ERROR",
          "PROJECT_WITH_VIDEOS_CANNOT_BE_DELETED",
          "ACTIVE_API_KEY_CANNOT_BE_DELETED",
          "VIDEO_IN_OPERATION_NOT_FAILED",
          "VIDEO_OUT_OPERATION_NOT_FAILED",
          "VIDEO_ALREADY_BEING_COPIED_TO_OUTPUT_LOCATION",
          "ONGOING_COPY_TO_OUTPUT_NEEDS_TO_BE_RESTARTED_OR_ABANDONED",
          "BUCKET_NOT_FOUND",
          "KEY_NOT_FOUND",
          "HEAD_BUCKET_ERROR",
          "HEAD_OBJECT_ERROR",
          "RESOLVE_OBJECT_METADATA_ERROR",
          "CONTENT_RANGE_HEADER_INVALID",
          "CONTENT_NOT_PARTIAL_ERROR",
          "PARSE_CONTENT_TYPE_ERROR",
          "NO_CONTENT",
          "OBJECT_ALREADY_EXISTS",
          "CONFLICTING_DERIVED_VIDEO_IDS",
          "MAXIMUM_AMOUNT_OF_ACTIVE_API_KEYS_REACHED",
          "MAXIMUM_AMOUNT_OF_ACTIVE_WEBHOOKS_REACHED",
          "INVALID_REQUEST_BODY",
          "MISSING_REQUEST_BODY",
          "TARGET_RESOLUTION_OUT_OF_ALLOWED_RANGE",
          "TARGET_RESOLUTION_CANNOT_BE_LOWER_THAN_CALCULATED_ASPECT_RATIO_RESOLUTION",
          "INVALID_START_POSITION",
          "INVALID_END_POSITION",
          "INVALID_DATE_TIME_RANGE",
          "MISSING_CUSTOM_RESOLUTION",
          "INVALID_INPUT_COLOR_CONVERSION",
          "INVALID_OUTPUT_COLOR_CONVERSION",
          "UNSUPPORTED_CONTENT_TYPE",
          "CHECKSUM_MISMATCH",
          "VIDEO_IN_RESTART_CHECKSUM_MISMATCH",
          "INVALID_HTTPS_URL",
          "UNEXPECTED_CONTENT_RANGE",
          "VIDEO_PROCESSING_NOT_DONE",
          "WEBHOOK_RATE_LIMIT_EXCEEDED",
          "VIDEO_NOT_FULLY_INGESTED",
          "VIDEO_COMPARISON_CONFLICT",
          "APPRAISAL_BILLING_OUT_DATED",
          "AWS_MARKETPLACE_ACCESS_NOT_AVAILABLE",
          "TEAM_NOT_BILLED_THROUGH_AWS_MARKETPLACE",
          "BAD_REQUEST",
          "UNAUTHORIZED",
          "NOT_FOUND",
          "CONFLICT",
          "INTERNAL_SERVER_ERROR"
        ],
        "x-enumDescriptions": {
          "UNKNOWN": "Unknown error",
          "TOO_MANY_REQUESTS": "Too many requests",
          "INVALID_CREDENTIALS": "Invalid credentials",
          "ACCOUNT_LOCKED": "Account is locked",
          "ACCOUNT_DISABLED": "Account is disabled or API key is not active",
          "ACCOUNT_EXPIRED": "Account has expired",
          "MISSING_API_KEY": "Missing API key",
          "INVALID_API_KEY": "Invalid API key",
          "ACCESS_DENIED": "Access denied",
          "RESOURCE_NOT_FOUND": "Resource not found",
          "TEAM_NOT_FOUND": "Team not found. Either the team does not exist, is not apiEnabled, or the authenticated ApiUser does not have access to it.",
          "DEFAULT_TEAM_NOT_API_ENABLED": "Default team not API enabled",
          "INVALID_INPUT": "Invalid input",
          "FORBIDDEN": "Unauthorized",
          "VALIDATION_ERROR": "Validation error",
          "WEBHOOK_NOT_ACTIVE": "Webhook not active",
          "TOO_MANY_WEBHOOK_TEST_EVENTS": "Too many webhook test events",
          "CONTAINER_IS_NOT_SUPPORTED_FOR_SELECTED_CODEC": "Container is not supported for selected codec",
          "INSUFFICIENT_PROJECTED_BALANCE_ERROR": "Insufficient projected balance",
          "PROJECT_WITH_VIDEOS_CANNOT_BE_DELETED": "Project with videos cannot be deleted",
          "ACTIVE_API_KEY_CANNOT_BE_DELETED": "Active API key cannot be deleted",
          "VIDEO_IN_OPERATION_NOT_FAILED": "Video-in operation not failed",
          "VIDEO_OUT_OPERATION_NOT_FAILED": "Video-out operation not failed",
          "VIDEO_ALREADY_BEING_COPIED_TO_OUTPUT_LOCATION": "Video is already being copied to an output location",
          "ONGOING_COPY_TO_OUTPUT_NEEDS_TO_BE_RESTARTED_OR_ABANDONED": "Video is already being copied to an output location. Needs to be restarted or abandoned.",
          "BUCKET_NOT_FOUND": "Bucket not found",
          "KEY_NOT_FOUND": "The given key does not exist in the bucket",
          "HEAD_BUCKET_ERROR": "Error in HeadBucket",
          "HEAD_OBJECT_ERROR": "Error in HeadObject",
          "RESOLVE_OBJECT_METADATA_ERROR": "Error resolving object metadata",
          "CONTENT_RANGE_HEADER_INVALID": "Content-Range header invalid or not found",
          "CONTENT_NOT_PARTIAL_ERROR": "Partial content not received",
          "PARSE_CONTENT_TYPE_ERROR": "Error parsing content type",
          "NO_CONTENT": "No content",
          "OBJECT_ALREADY_EXISTS": "Object already exists",
          "CONFLICTING_DERIVED_VIDEO_IDS": "Conflicting derived video IDs",
          "MAXIMUM_AMOUNT_OF_ACTIVE_API_KEYS_REACHED": "Maximum amount of active API keys reached",
          "MAXIMUM_AMOUNT_OF_ACTIVE_WEBHOOKS_REACHED": "Maximum amount of active webhooks reached",
          "INVALID_REQUEST_BODY": "Invalid request body",
          "MISSING_REQUEST_BODY": "Missing request body",
          "TARGET_RESOLUTION_OUT_OF_ALLOWED_RANGE": "Target resolution out of allowed range",
          "TARGET_RESOLUTION_CANNOT_BE_LOWER_THAN_CALCULATED_ASPECT_RATIO_RESOLUTION": "Target resolution cannot be lower than calculated aspect ratio resolution",
          "INVALID_START_POSITION": "Invalid start position",
          "INVALID_END_POSITION": "Invalid end position",
          "INVALID_DATE_TIME_RANGE": "Invalid date time range",
          "MISSING_CUSTOM_RESOLUTION": "Width and height must be provided when tag and aspectRatioTag are not",
          "INVALID_INPUT_COLOR_CONVERSION": "Invalid input color conversion",
          "INVALID_OUTPUT_COLOR_CONVERSION": "Invalid output color conversion",
          "UNSUPPORTED_CONTENT_TYPE": "Unsupported content type",
          "CHECKSUM_MISMATCH": "Checksum mismatch",
          "VIDEO_IN_RESTART_CHECKSUM_MISMATCH": "Cannot restart a VideoInOperation that failed due to checksum mismatch without also setting skipChecksumValidation to true",
          "INVALID_HTTPS_URL": "Invalid HTTPS URL",
          "UNEXPECTED_CONTENT_RANGE": "Unexpected content range",
          "VIDEO_PROCESSING_NOT_DONE": "Video processing not done",
          "WEBHOOK_RATE_LIMIT_EXCEEDED": "Webhook rate limit exceeded",
          "VIDEO_NOT_FULLY_INGESTED": "Video not fully ingested",
          "VIDEO_COMPARISON_CONFLICT": "Video comparison conflict.",
          "APPRAISAL_BILLING_OUT_DATED": "Appraisal billing out of date.",
          "AWS_MARKETPLACE_ACCESS_NOT_AVAILABLE": "AWS Marketplace access not available.",
          "TEAM_NOT_BILLED_THROUGH_AWS_MARKETPLACE": "Team not billed through AWS Marketplace.",
          "BAD_REQUEST": "Standard HTTP 400 Bad Request",
          "UNAUTHORIZED": "Standard HTTP 401 Unauthorized",
          "NOT_FOUND": "Standard HTTP 404 Not Found",
          "CONFLICT": "Standard HTTP 409 Conflict",
          "INTERNAL_SERVER_ERROR": "Standard HTTP 500 Internal Server Error"
        }
      }
    },
    "parameters": {
      "IdPathParam": {
        "name": "id",
        "in": "path",
        "required": true,
        "description": "The unique identifier for the object.",
        "schema": {
          "$ref": "#/components/schemas/UUID"
        }
      }
    },
    "requestBodies": {
      "ApiKeyPatchRequest": {
        "description": "Fields of an API key that can be updated.",
        "required": true,
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ApiKeyPatch"
            }
          }
        }
      }
    },
    "responses": {
      "ApiKeyResponse": {
        "description": "Successfully retrieved API key details.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/ApiKey"
            }
          }
        }
      },
      "BadRequest": {
        "description": "Invalid request. Inspect the details of the error for more information.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "Unauthorized": {
        "description": "Authentication failed. Missing or invalid `X-API-Key` or basic authentication credentials.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "WWW-Authenticate": {
            "description": "The authentication method that should be used to gain access to the resource.",
            "schema": {
              "type": "string"
            }
          },
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "Forbidden": {
        "description": "Access denied. You do not have the necessary permissions to access this resource.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "NotFound": {
        "description": "The requested resource could not be found.",
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      },
      "InternalServerError": {
        "description": "An unexpected error occurred on the server.",
        "content": {
          "application/json": {
            "schema": {
              "$ref": "#/components/schemas/Error"
            }
          }
        },
        "headers": {
          "X-RateLimit-Limit": {
            "$ref": "#/components/headers/X-RateLimit-Limit"
          },
          "X-RateLimit-Remaining": {
            "$ref": "#/components/headers/X-RateLimit-Remaining"
          },
          "X-RateLimit-Reset": {
            "$ref": "#/components/headers/X-RateLimit-Reset"
          }
        }
      }
    },
    "headers": {
      "X-RateLimit-Limit": {
        "description": "The maximum number of requests allowed per minute.",
        "schema": {
          "type": "integer"
        }
      },
      "X-RateLimit-Remaining": {
        "description": "The number of requests remaining in the current rate limit window.",
        "schema": {
          "type": "integer"
        }
      },
      "X-RateLimit-Reset": {
        "description": "The number of seconds until the current rate limit window resets.",
        "schema": {
          "type": "integer"
        }
      }
    },
    "securitySchemes": {
      "basic_auth": {
        "type": "http",
        "scheme": "basic",
        "description": "Basic HTTP authentication using an email and password. The `Authorization` header must be set as:\n  - `Authorization: Basic <base64-encoded-credentials>`\nWhere `<base64-encoded-credentials>` is the Base64 encoding of `email:password`.\nExample:\n  - `Authorization: Basic dXNlckBleGFtcGxlLmNvbTpwYXNzd29yZA==`\n"
      },
      "api_key": {
        "type": "apiKey",
        "name": "X-API-Key",
        "in": "header",
        "description": "API key authentication using the `X-API-Key` header. \nProvide the API key as part of the request headers:\n  - `X-API-Key: <your-api-key>`\nExample:\n  - `X-API-Key: gTF1d6iQKyu8gzXO4pNCt10WlTjhKzrWtUm1wwTGuMA`\n"
      }
    }
  }
}
```