> ## Documentation Index
> Fetch the complete documentation index at: https://pixelcut.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Generate Background

> Generates a new background for an image. Generated images are 1024x1024 by default.<br/><br/> **Input Image Limits:**
  - Max size: 25MB
  - Min resolution: 64x64px
  - Max resolution: 6000x6000px




## OpenAPI

````yaml POST /v1/generate-background
openapi: 3.1.0
info:
  description: >-
    The Pixelcut API specification, learn more about the API at at
    https://www.pixelcut.ai/docs
  version: 0.0.2
  title: Pixelcut API
  termsOfService: >-
    https://pixelcut.notion.site/Pixelcut-API-Terms-of-Service-11b3b550490080d89a91e943d010efdf
  contact:
    name: API Support
    email: api@pixelcut.ai
servers:
  - url: https://api.developer.pixelcut.ai
    description: Pixelcut API server
security: []
paths:
  /v1/generate-background:
    post:
      tags:
        - Endpoints
      summary: Generate Background
      description: >
        Generates a new background for an image. Generated images are 1024x1024
        by default.<br/><br/> **Input Image Limits:**
          - Max size: 25MB
          - Min resolution: 64x64px
          - Max resolution: 6000x6000px
      operationId: generate-background
      parameters:
        - in: header
          name: Accept
          required: false
          schema:
            type: string
          description: >-
            Acceptable response media type(s). `application/json` or `image/*`.
            Default is `application/json`.
      requestBody:
        content:
          application/json:
            schema:
              type: object
              required:
                - image
              properties:
                image_url:
                  $ref: '#/components/schemas/GenerateImageURLParameter'
                image_transform:
                  $ref: '#/components/schemas/ImageTransform'
                scene:
                  $ref: '#/components/schemas/GenerateImageScene'
                prompt:
                  $ref: '#/components/schemas/GenerateImagePrompt'
                negative_prompt:
                  $ref: '#/components/schemas/GenerateImageNegativePrompt'
          multipart/form-data:
            schema:
              type: object
              properties:
                image_url:
                  $ref: '#/components/schemas/ImageURLParameter'
                image:
                  $ref: '#/components/schemas/BinaryImageParameter'
                image_transform:
                  $ref: '#/components/schemas/ImageTransform'
                scene:
                  $ref: '#/components/schemas/GenerateImageScene'
                prompt:
                  $ref: '#/components/schemas/GenerateImagePrompt'
                negative_prompt:
                  $ref: '#/components/schemas/GenerateImageNegativePrompt'
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/JpegImageJSONResponse'
            image/*:
              schema:
                $ref: '#/components/schemas/JpegBinaryResponse'
        '400':
          $ref: '#/components/responses/Error400'
        '401':
          $ref: '#/components/responses/Error401'
        '403':
          $ref: '#/components/responses/Error403'
        '429':
          $ref: '#/components/responses/Error429'
        '500':
          $ref: '#/components/responses/Error500'
      security:
        - ApiKeyAuth: []
components:
  schemas:
    GenerateImageURLParameter:
      type: string
      format: url
      description: >-
        URL of the image. If the image is RGB the background will automatically
        be removed, if the image is RGBA the background will not be removed and
        the alpha channel will be respected.
      example: https://cdn3.pixelcut.app/product.jpg
    ImageTransform:
      type: object
      properties:
        scale:
          type: number
          default: 1
          description: >-
            Scales the input image. Scale of 1 means the longest edge of the
            image fits the canvas, 1 is the default value if the background was
            not removed automatically. If the background was removed, the alpha
            around the subject is automatically trimmed so we use a scale of 0.6
            to provide padding around the subject in the final image.
        x_center:
          type: number
          default: 0.5
          description: >-
            Positions the horizontal center of the image within the canvas.
            Ranges from 0 to 1.
        y_center:
          type: number
          default: 0.5
          description: >-
            Positions the vertical center of the image within the canvas. Ranges
            from 0 to 1.
    GenerateImageScene:
      type: string
      format: string
      enum:
        - marble
        - wood
        - industrial
        - linen
        - brick
        - counter
      description: >-
        Select a preset scene type. If provided prompt and negative_prompt will
        be ignored.
    GenerateImagePrompt:
      type: string
      format: string
      description: >-
        A description of the desired scene used to guide the image generation
        process.
    GenerateImageNegativePrompt:
      type: string
      format: string
      description: >-
        A comma seperated list of attributes which should be discouraged in the
        image generation.
    ImageURLParameter:
      type: string
      format: url
      description: URL of the image to be processed.
      example: https://cdn3.pixelcut.app/product.jpg
    BinaryImageParameter:
      type: string
      format: binary
      description: >-
        Binary file of the image to be processed, this is mutually exclusive
        with image_url, if both are provided the image will be used.
    JpegImageJSONResponse:
      type: object
      properties:
        result_url:
          type: string
          description: >-
            A URL to access the resultant image which is valid for 1 hour. File
            format will be jpeg.
          example: >-
            https://assets.pixelcut.app/public/result/a16646be-91c8-4e3a-b359.jpg
    JpegBinaryResponse:
      type: string
      format: binary
      properties:
        image:
          description: Resultant image in binary format. The file format will be jpeg.
  responses:
    Error400:
      description: >-
        The input could not be processed, often returned when the input image
        exceeds API limits.
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                description: A description of the error.
                example: File size too large
              error_code:
                type: string
                enum:
                  - invalid_request_body
                  - missing_parameter
                  - invalid_parameter
                  - unsupported_content_type
                  - malformed_image
                  - unsupported_image_format
                  - file_size_too_large
                  - resolution_too_high
                  - unknown_foreground
                example: file_size_too_large
                description: >
                  The error codes provide a way to programmatically handle
                  errors.  


                  The following error codes are currently in use:  

                  - `invalid_request_body`: The request body was empty or
                  invalid.

                  - `missing_parameter`: A required parameter was not provided.

                  - `invalid_parameter`: A parameter was provided but it was
                  invalid.

                  - `unsupported_content_type`: The content type of the request
                  was not application/json or multipart/form-data.

                  - `malformed_image`: The image could not be decoded.

                  - `unsupported_image_format`: The image format is not
                  supported.

                  - `file_size_too_large`: The image file size is too large.

                  - `resolution_too_high`: The image resolution is too high.

                  - `unknown_foreground`: The foreground subject of the image
                  could not be detected.
    Error401:
      description: The authentication token is missing or invalid.
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: API Token not found
              error_code:
                type: string
                enum:
                  - invalid_auth_token
    Error403:
      description: >-
        Returned when you have insufficient credits to perform the requested
        action.
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: Insufficient credits available
              error_code:
                type: string
                enum:
                  - insufficient_api_credits
    Error429:
      description: Rate limit exceeded
      content:
        application/json:
          schema:
            type: object
            properties:
              error:
                type: string
                example: Too many requests
              error_code:
                type: string
                enum:
                  - rate_limit_exceeded
    Error500:
      description: Internal service error
  securitySchemes:
    ApiKeyAuth:
      description: >
        All API requests require a valid api key. Include your token as a HTTP
        request header in the following format: `X-API-Key: skXXXXXXXXXXXXXXXX`.
        You can obtain an api key by signing up for developer access in your
        Pixelcut account.
      type: apiKey
      name: X-API-KEY
      in: header

````