{
  "openapi": "3.0.1",
  "info": {
    "title": "Winston AI API",
    "description": "Winston AI API specification",
    "license": {
      "name": "MIT"
    },
    "version": "4.11.4"
  },
  "servers": [
    {
      "url": "https://api.gowinston.ai/"
    }
  ],
  "security": [
    {
      "bearerAuth": []
    }
  ],
  "paths": {
    "/v2/fact-checker": {
      "post": {
        "description": "The Fact Checker endpoint is a powerful tool designed to verify the accuracy of a given piece of content by checking it against a a variety of trusted sources. The cost is 2 credits per word.",
        "requestBody": {
          "description": "The Fact Checker request body",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/FactCheckerRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Fact Checker response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/FactCheckerResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "415": {
            "description": "Unsupported Media Type",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNSUPPORTED_MEDIA_TYPE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request content type is not supported. Make sure you pass a valid content type."
                    }
                  }
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "SERVICE_UNAVAILABLE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The service is currently unavailable. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v2/advanced-image-detection": {
      "post": {
        "description": "Runs an advanced forensic analysis on a public image URL. The API authenticates the caller with a bearer token, checks the user's credit balance, analyzes the image, charges 500 credits after a successful analysis, and returns a structured forensic report.",
        "requestBody": {
          "description": "The Advanced Image Detection request body",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdvancedImageDetectionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Advanced Image Detection response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AdvancedImageDetectionResponse"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request — image_url is missing, empty, malformed, not a string, or fails public URL validation.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "Invalid URL provided"
                    },
                    "description": {
                      "type": "string",
                      "default": "The URL provided is not a valid public image URL."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized — the Authorization header is missing, malformed, or the token is unknown.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "Unauthorized"
                    },
                    "description": {
                      "type": "string",
                      "default": "Missing or invalid authentication token, please provide a valid token in the Authorization header."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden — the user does not have at least 500 credits.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "Insufficient credits"
                    },
                    "description": {
                      "type": "string",
                      "default": "The user does not have enough credits to perform this action."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error — the analysis pipeline failed or did not produce a successful response.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "Error while analyzing image, please try again later or contact support"
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v1/ai-content-detection": {
      "post": {
        "description": "The Human Score is a metric used by Winston AI to estimate the likelihood that a given piece of content was generated by an AI tool versus being written by a human.",
        "requestBody": {
          "description": "The Ai content detection request body",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AiContentDetection"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Ai content detection response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AiContentDetection-response"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "415": {
            "description": "Unsupported Media Type",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNSUPPORTED_MEDIA_TYPE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request content type is not supported. Make sure you pass a valid content type."
                    }
                  }
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "SERVICE_UNAVAILABLE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The service is currently unavailable. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v2/ai-content-detection": {
      "post": {
        "description": "The Human Score is a metric used by Winston AI to estimate the likelihood that a given piece of content was generated by an AI tool versus being written by a human.",
        "requestBody": {
          "description": "The Ai content detection request V2",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AiContentDetection"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AiContentDetection-response"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "415": {
            "description": "Unsupported Media Type",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNSUPPORTED_MEDIA_TYPE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request content type is not supported. Make sure you pass a valid content type."
                    }
                  }
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "SERVICE_UNAVAILABLE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The service is currently unavailable. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v1/plagiarism": {
      "post": {
        "description": "Winston AI's plagiarism API is a powerful tool designed to check text for plagiarism by scouring the internet for similar content. It queries multiple websites and compares the input text with the content found on these websites. This can be particularly useful in academic settings, content creation, legal scenarios or any other situation where originality of content is required.",
        "requestBody": {
          "description": "",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Plagiarism"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Plagiarism response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Plagiarism-response"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/v2/plagiarism": {
      "post": {
        "description": "Winston AI's plagiarism API is a powerful tool designed to check text for plagiarism by scouring the internet for similar content. It queries multiple websites and compares the input text with the content found on these websites. This can be particularly useful in academic settings, content creation, legal scenarios or any other situation where originality of content is required.",
        "requestBody": {
          "description": "",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/PlagiarismV2"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Plagiarism response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Plagiarism-response-v2"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "415": {
            "description": "Unsupported Media Type",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNSUPPORTED_MEDIA_TYPE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request content type is not supported. Make sure you pass a valid content type."
                    }
                  }
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "SERVICE_UNAVAILABLE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The service is currently unavailable. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v1/image-detection": {
      "post": {
        "description": "Our image detection feature enables AI-generated image detection by verifying image metadata and using a machine learning system trained to differentiate between human and AI-generated images.",
        "requestBody": {
          "description": "",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ImageDetection"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Image detection Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ImageDetection-Response"
                }
              }
            }
          },
          "400": {
            "description": "unexpected error",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Error"
                }
              }
            }
          }
        }
      }
    },
    "/v2/image-detection": {
      "post": {
        "description": "Our image detection feature enables AI-generated image detection by verifying image metadata and using a machine learning system trained to differentiate between human and AI-generated images.",
        "requestBody": {
          "description": "",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ImageDetection"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Image detection Response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ImageDetection-Response"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "415": {
            "description": "Unsupported Media Type",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNSUPPORTED_MEDIA_TYPE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request content type is not supported. Make sure you pass a valid content type."
                    }
                  }
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "503": {
            "description": "Service Unavailable",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "SERVICE_UNAVAILABLE"
                    },
                    "description": {
                      "type": "string",
                      "default": "The service is currently unavailable. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    },
    "/v2/text-compare": {
      "post": {
        "description": "Compare two texts to find similarities and differences between them. This endpoint analyzes both texts and returns detailed information about matching content, word counts, and similarity scores.",
        "requestBody": {
          "description": "The text comparison request body",
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TextCompare"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Text comparison response",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TextCompare-response"
                }
              }
            }
          },
          "400": {
            "description": "Bad Request",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "BAD_REQUEST"
                    },
                    "description": {
                      "type": "string",
                      "default": "The request was invalid and could not be processed. Make sure you pass valid arguments."
                    }
                  }
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "UNAUTHORIZED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Pass a valid API key in the Authorization header as a Bearer token."
                    }
                  }
                }
              }
            }
          },
          "402": {
            "description": "Payment Required (insufficient credits)",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "PAYMENT_REQUIRED"
                    },
                    "description": {
                      "type": "string",
                      "default": "Insufficient credits. Make sure you have enough credits to make the request."
                    }
                  }
                }
              }
            }
          },
          "403": {
            "description": "Forbidden",
            "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "error": {
                        "type": "string",
                        "default": "FORBIDDEN"
                      },
                      "description": {
                        "type": "string",
                        "default": "The request was forbidden. Make sure you pass a valid URL or document that we can access."
                      }
                    }
                  } 
              }
            }
          },
          "429": {
            "description": "Too Many Requests",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "TOO_MANY_REQUESTS"
                    },
                    "description": {
                      "type": "string",
                      "default": "You have exceeded the rate limit. Please try again later."
                    }
                  }
                }
              }
            }
          },
          "500": {
            "description": "Internal Server Error",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "error": {
                      "type": "string",
                      "default": "INTERNAL_SERVER_ERROR"
                    },
                    "description": {
                      "type": "string",
                      "default": "An unexpected error occurred. Please try again later."
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "AdvancedImageDetectionRequest": {
        "type": "object",
        "required": ["image_url"],
        "properties": {
          "image_url": {
            "description": "Public HTTP or HTTPS URL of the image to analyze. The API rejects empty values, non-string values, URLs without a hostname, URLs with embedded credentials, `localhost`, `.localhost`, and direct private or reserved IP addresses.",
            "type": "string",
            "example": "https://example.com/image.png"
          }
        }
      },
      "AdvancedImageDetectionResponse": {
        "type": "object",
        "properties": {
          "status": {
            "type": "integer",
            "description": "Internal analysis status from the image analysis pipeline. The external HTTP status for a successful API request is 200 OK.",
            "example": 200
          },
          "cost": {
            "type": "integer",
            "description": "Number of credits charged for this API request. Current value is 500.",
            "example": 500
          },
          "language": {
            "type": "string",
            "description": "Language used for the generated analysis text.",
            "example": "en"
          },
          "title": {
            "type": "string",
            "description": "Short generated title describing the analyzed image.",
            "example": "Portrait of a Person"
          },
          "tags": {
            "type": "array",
            "description": "Tags extracted or inferred from the image metadata and analysis pipeline.",
            "items": {
              "type": "string"
            },
            "example": ["portrait", "face"]
          },
          "tool_used": {
            "type": "array",
            "description": "List of internal forensic tool IDs used during the analysis. Possible values include `classify_image`, `extract_metadata`, `ela_image`, `residual_noise_maps`, `edge_anomaly_heat_map`, and `cfa_pattern_analysis`.",
            "items": {
              "type": "string"
            },
            "example": ["classify_image", "extract_metadata", "ela_image"]
          },
          "label": {
            "type": "string",
            "description": "Final classification label for the image.",
            "enum": ["AI-Generated", "Human"],
            "example": "AI-Generated"
          },
          "confidence": {
            "type": "string",
            "description": "Confidence level for the final classification.",
            "enum": ["High", "Moderate", "Low"],
            "example": "High"
          },
          "authenticity": {
            "type": "string",
            "description": "Final authenticity assessment.",
            "enum": ["Authentic", "Manipulated"],
            "example": "Manipulated"
          },
          "conclusion": {
            "type": "string",
            "description": "Short final conclusion summarizing the forensic result.",
            "example": "The image shows strong indicators of AI generation."
          },
          "analysis": {
            "type": "string",
            "description": "Complete human-readable forensic analysis, including a summary of the tools used and their findings."
          },
          "tools_used_analysis": {
            "type": "array",
            "description": "Per-tool analysis results. Each item contains the tool ID, a generated explanation of that tool's result, and the underlying tool output.",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "string",
                  "description": "Internal ID of the forensic tool. Examples: `extract_metadata`, `classify_image`, `ela_image`.",
                  "example": "extract_metadata"
                },
                "analysis": {
                  "type": "string",
                  "description": "Natural-language explanation of what the tool result indicates.",
                  "example": "The metadata is stripped of EXIF and C2PA information."
                },
                "result": {
                  "description": "Structured tool output when the tool returns data, such as metadata or classification scores. For generated image artifacts (e.g. ELA heatmaps), this is a temporary presigned S3 URL valid for 5 minutes.",
                  "oneOf": [
                    {
                      "type": "object"
                    },
                    {
                      "type": "string"
                    }
                  ]
                }
              }
            }
          },
          "balance": {
            "type": "integer",
            "description": "User's remaining credit balance after the successful request is charged.",
            "example": 9500
          }
        }
      },
      "FactCheckerRequest": {
        "type": "object",
        "required": ["text"],
        "properties": {
          "text": {
            "description": "The text to scan. It is required except if you supply a website or a file. Minimum 300 characters. Maximum 10,000 characters per request.",
            "type": "string"
          },
          "file": {
            "description": "A publicly accessible URL to a file to scan. The file must be publicly available online (not a local file path) so our API can access it. The file must be in plain .pdf, .doc or .docx format. The file has priority over the text, so if you give a text and a file, it's the file that will be scanned.",
            "type": "string"
          },
          "website": {
            "description": "A website URL to scan. If you supply a website, the API will fetch the content of the website and scan it. The website must be publicly accessible. It's important to know that the website has priority over the text and the file, so if you give a text, a file and a website, it's the website that will be scanned.",
            "type": "string"
          },
          "language": {
            "description": "2 letter language code. Default: auto.\n\nIf you put 'auto', the API will automatically detect the language based on the text.\n\nSupported languages:\n\nArabic (ar), Bengali (bn), Bulgarian (bg), Chinese simplified and traditional (zh), Croatian (hr), Czech (cs), Danish (da), Dutch (nl), English (en), Estonian (et), Finnish (fi), French (fr), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Indonesian (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Norwegian (no), Polish (pl), Portuguese (pt), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es), Swahili (sw), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), Vietnamese (vi).",
            "type": "string",
            "default": "auto"
          }
        }
      },
      "FactCheckerResponse": {
        "type": "object",
        "properties": {
          "status": {
            "type": "integer",
            "description": "HTTP status code for the response",
            "example": 200
          },
          "claims": {
            "type": "array",
            "description": "List of claims detected in the text along with their fact-checking results.",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "integer",
                  "description": "The unique identifier of the sentence in the input text.",
                  "example": 1
                },
                "sentence": {
                  "type": "string",
                  "description": "Exact input sentence from which the claim was extracted."
                },
                "claim": {
                  "type": "string",
                  "description": "The distinct claim to be fact-checked."
                },
                "verdict": {
                  "type": "string",
                  "description": "Fact-checking verdict about the claim.",
                  "enum": ["SUPPORTED", "PARTIALLY_SUPPORTED", "NOT_ENOUGH_EVIDENCE", "REFUTED"]
                },
                "score": {
                  "type": "integer",
                  "description": "Confidence score (0-100) for the verdict.",
                  "example": 100
                },
                "explanation": {
                  "type": "string",
                  "description": "Explanation of the verdict, including supporting reasoning and factual basis."
                },
                "links": {
                  "type": "array",
                  "description": "List of supporting sources for the claim.",
                  "items": {
                    "type": "object",
                    "properties": {
                      "url": {
                        "type": "string",
                        "description": "URL of the supporting reference."
                      },
                      "title": {
                        "type": "string",
                        "description": "Title or domain of the referenced article."
                      }
                    }
                  }
                }
              }
            }
          },
          "score": {
            "type": "integer",
            "description": "Overall confidence score (0-100) that the provided text is accurate.",
            "example": 100
          },
          "claimsCount": {
            "type": "integer",
            "description": "Total number of claims extracted from the text. Maximum 12 per request.",
            "example": 11
          },
          "text": {
            "type": "string",
            "description": "The full original text that was analyzed."
          },
          "sentences": {
            "type": "array",
            "description": "List of sentences from the analyzed text, with IDs for mapping claims to the sentences.",
            "items": {
              "type": "object",
              "properties": {
                "id": {
                  "type": "integer",
                  "description": "Unique identifier for the sentence in the input text.",
                  "example": 1
                },
                "text": {
                  "type": "string",
                  "description": "Sentence text."
                }
              }
            }
          },
          "input": {
            "type": "string",
            "description": "Indicates the input type, e.g., 'text', 'file', or 'website'."
          },
          "language": {
            "type": "string",
            "description": "Detected or specified input language (2 letter code).",
            "example": "en"
          },
          "creditsUsed": {
            "type": "integer",
            "description": "The number of credits used to process this request.",
            "example": 1234
          },
          "creditsRemaining": {
            "type": "integer",
            "description": "The number of remaining credits for the account.",
            "example": 34567
          },
          "wordCount": {
            "type": "integer",
            "description": "Word count of the input text.",
            "example": 617
          }
        }
      },
      "AiContentDetection": {
        "type": "object",
        "required": ["text"],
        "properties": {
          "text": {
            "description": "The text to scan. It is required except if you supply a website or a file. Minimum 300 characters. Texts under 600 characters may produce unreliable results and should be avoided. Maximum 150 000 characters per request.",
            "type": "string"
          },
          "file": {
            "description": "A publicly accessible URL to a file to scan. The file must be publicly available online (not a local file path) so our API can access it. The file must be in plain .pdf, .doc or .docx format. The file has priority over the text, so if you give a text and a file, it's the file that will be scanned.",
            "type": "string"
          },
          "website": {
            "description": "A website URL to scan. If you supply a website, the API will fetch the content of the website and scan it. The website must be publicly accessible. It's important to know that the website has priority over the text and the file, so if you give a text, a file and a website, it's the website that will be scanned.",
            "type": "string"
          },
          "version": {
            "description": "The model version to use. Our latest and most accurate version is \"4.14\". Using \"latest\" will make sure you are always using the latest version. Options: 4.14, 4.13, 4.12, 4.11, 4.10, 4.9, 4.8, 4.7, 4.6, 4.5, 4.4, 4.3, 4.2, 4.1, 4.0, 3.1, 3.0, 2.0, latest. Default: 4.14. Note: Version 3.1 is identical to 3.0 but preserves newline characters in the returned sentences, while 3.0 removes them.",
            "type": "string"
          },
          "sentences": {
            "description": "Whether the response should include an array of sentences and their scores. Default: true.",
            "type": "boolean"
          },
          "language": {
            "description": "2 letter language code. Default: auto. \n\n If you put 'auto', the API will automatically detect the language based on the text. \n\n Supported languages:\n\nEnglish (en), French (fr), Spanish (es), Portuguese (pt), Dutch (nl), German (de), Polish (pl), Italian (it), Romanian (ro), Indonesian (id), Tagalog (tl), Russian (ru), Bulgarian (bg) and Chinese simplified (zh).",
            "type": "string",
            "default": "auto"
          }
        }
      },
      "AiContentDetection-response": {
        "type": "object",
        "properties": {
          "status": {
            "description": "This is a standard HTTP status code. A 200 status means the request was successful.",
            "type": "integer"
          },
          "score": {
            "description": "A \"human\" score between 0 and 100. A low score means our system believes that the text is written by AI, and a higher score means that the system believes that the text is written by a Human.",
            "type": "integer"
          },
          "sentences": {
            "description": "This is an array of sentence objects. Each object contains two fields: text and score. Please note that assessments on smaller samples are less accurate than the general score.",
            "type": "object",
            "properties": {
              "text": {
                "description": "The text field contains the actual text of the sentence that was analyzed.",
                "type": "string"
              },
              "score": {
                "description": "The score field within each sentence object indicates the sentiment score assigned to that particular sentence by the AI.",
                "type": "integer"
              }
            }
          },
          "input": {
            "description": "The type of input we scan based on the input you provided. It can be `text | file | website` .",
            "type": "string"
          },
          "attack_detected": {
            "type": "object",
            "description": "An object with two boolean properties indicating if the text contains zero-width spaces or homoglyph attacks.",
            "properties": {
              "zero_width_space": {
                "type": "boolean",
                "description": "Indicates if the text contains zero-width spaces."
              },
              "homoglyph_attack": {
                "type": "boolean",
                "description": "Indicates if the text contains homoglyph attacks."
              }
            }
          },
          "readability_score": {
            "description": "A readability score between 0 and 100 that indicates how easy it is to read and understand the text based on the provided language. A higher score means the text is more readable and easier to understand.",
            "type": "integer"
          },
          "credits_used": {
            "description": "The credits_used field represents the number of credits consumed for processing your request. Each word that is processed by the API consumes one credit.",
            "type": "integer"
          },
          "credits_remaining": {
            "description": "The credits_remaining field shows how many credits you have left in your account after your request has been processed.",
            "type": "integer"
          },

          "version": {
            "description": "The model version used to generate the prediction based on the input you provided.",
            "type": "string"
          },
          "language": {
            "description": "The language of the text detected. It can be `en | fr | es | pt | nl | de | pl | it | ro | id | tl | ru | bg | zh`.",
            "type": "string"
          }
        }
      },
      "Plagiarism": {
        "required": ["text"],
        "type": "object",
        "properties": {
          "text": {
            "description": "The text to be scanned. Each request must contain at least 16 words and no more than 20,000 words.",
            "type": "string"
          }
        }
      },
      "PlagiarismV2": {
        "required": ["text"],
        "type": "object",
        "properties": {
          "text": {
            "description": "The text to be scanned. This is required unless you provide a website or file. Each request must contain at least 100 characters and no more than 120,000 characters.",
            "type": "string"
          },
          "file": {
            "description": "A publicly accessible URL to a file to scan. The file must be publicly available online (not a local file path) so our API can access it. The file must be in plain .pdf, .doc or .docx format. The file has priority over the text, so if you give a text and a file, it's the file that will be scanned.",
            "type": "string"
          },
          "website": {
            "description": "A website URL to scan. If you supply a website, the API will fetch the content of the website and scan it. The website must be publicly accessible. It's important to know that the website has priority over the text and the file, so if you give a text, a file and a website, it's the website that will be scanned.",
            "type": "string"
          },
          "excluded_sources": {
            "description": "An array of sources to exclude from the scan. The excluded sources won't be taken into account for the plagiarism scan score. Sources can either be a domain name like `example.com` or a url like `https://example.com`. If you specify a domain name, the API will exclude all the urls belonging to that domain and all subdomains. Sources are case-sensitive.",
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "language": {
            "description": "2 letter language code. Default: auto. \n\n If you put 'auto', the API will automatically detect the language of the text. \n\n The plagiarism-checking endpoint currently supports 47 languages: \n English (en), French (fr), German (de), Spanish (es), Portuguese (pt), Dutch (nl), Italian (it), Chinese (zh), Norwegian (no), Swedish (sv), Danish (da), Finnish (fi), Icelandic (is), Irish (ga), Polish (pl), Czech (cs), Slovak (sk), Romanian (ro), Hungarian (hu), Bulgarian (bg), Croatian (hr), Greek (el), Turkish (tr), Hebrew (he), Arabic (ar), Vietnamese (vi), Malay (ms), Thai (th), Korean (ko), Japanese (ja), Russian (ru), Kazakh (kk), Georgian (ka), Tagalog (tl), Hindi (hi), Bengali (bn), Persian (fa), Urdu (ur), Indonesian (id), Malayalam (ml), Tamil (ta), Telugu (te), Kannada (kn), Marathi (mr), Gujarati (gu), Ukrainian (uk) and Albanian (sq).",
            "type": "string",
            "default": "auto"
          },
          "country": {
            "description": "The country code of the country where the text was written. We accept all country codes. Default: us.",
            "type": "string",
            "default": "us"
          }
        }
      },
      "Plagiarism-response": {
        "type": "object",
        "properties": {
          "status": {
            "description": "This is a standard HTTP status code. A 200 status means the request was successful.",
            "type": "integer"
          },
          "results": {
            "description": "The results field is an array which contains one or more objects, each corresponding to a different website where matching content has been found. Each object includes the following fields:",
            "type": "object",
            "properties": {
              "title": {
                "description": "The title field provides the title of the webpage where matching content has been found.",
                "type": "string"
              },
              "url": {
                "description": "The url field gives the URL of the webpage where matching content has been found.",
                "type": "string"
              },
              "excerpts": {
                "description": "The excerpts field is an array which contains snippets of text from the webpage that match the input text.",
                "type": "object"
              },
              "date": {
                "description": "The date of publication of the result. The date format may vary from one result to another.",
                "type": "string"
              }
            }
          },
          "results_count": {
            "description": "The results_count field indicates the total number of matching websites found by the Plagiarism API.",
            "type": "integer"
          },
          "credits_used": {
            "description": "The credits_used field represents the number of credits consumed for processing your request. Each word that is processed by the API consumes two credits.",
            "type": "integer"
          },
          "credits_remaining": {
            "description": "The credits_remaining field shows how many credits you have left in your account after your request has been processed.",
            "type": "integer"
          }
        }
      },
      "Plagiarism-response-v2": {
        "type": "object",
        "properties": {
          "status": {
            "type": "number",
            "description": "HTTP status code representing the result of the plagiarism scan request."
          },
          "scanInformation": {
            "type": "object",
            "description": "Some basic scan information about the request.",
            "properties": {
              "service": {
                "type": "string",
                "description": "Name of the service used for the request."
              },
              "scanTime": {
                "type": "string",
                "description": "Timestamp when the scan was conducted."
              },
              "inputType": {
                "description": "The type of input we scan based on the input you provided. It can be `text | file | website` .",
                "type": "string"
              },
              "language": {
                "type": "string",
                "description": "The language of the text detected."
              }
            }
          },
          "result": {
            "type": "object",
            "description": "The result field is the main object that contains the results of the plagiarism scan.",
            "properties": {
              "score": {
                "type": "number",
                "description": "Plagiarism score indicating the percentage of plagiarized content in the scanned text."
              },
              "sourceCounts": {
                "type": "number",
                "description": "Number of sources identified during the scan that contain plagiarized content."
              },
              "textWordCounts": {
                "type": "number",
                "description": "Total number of words in the scanned text."
              },
              "totalPlagiarismWords": {
                "type": "number",
                "description": "Total number of words identified as plagiarized."
              },
              "identicalWordCounts": {
                "type": "number",
                "description": "Number of words identified as plagiarized that are identical to the source content."
              },
              "similarWordCounts": {
                "type": "number",
                "description": "Number of words identified as plagiarized that are similar to the source content."
              }
            }
          },
          "sources": {
            "type": "array",
            "description": "The sources field is an array which contains one or more objects, each corresponding to a different website where matching content has been found.",
            "items": {
              "type": "object",
              "properties": {
                "score": {
                  "type": "number",
                  "description": "The plagiarism percentage score for this specific source."
                },
                "canAccess": {
                  "type": "boolean",
                  "description": "Indicates if we were able to access the source content."
                },
                "url": {
                  "type": "string",
                  "description": "URL of the source where plagiarism was found."
                },
                "title": {
                  "type": "string",
                  "description": "Title of the source document."
                },
                "plagiarismWords": {
                  "type": "number",
                  "description": "Number of words in the input text identified as plagiarized from this source found."
                },
                "identicalWordCounts": {
                  "type": "number",
                  "description": "Number of words identified as plagiarized that are identical to the source content."
                },
                "similarWordCounts": {
                  "type": "number",
                  "description": "Number of words identified as plagiarized that are similar to the source content."
                },
                "totalNumberOfWords": {
                  "type": "number",
                  "description": "Total number of words in the input text."
                },
                "author": {
                  "type": "string",
                  "description": "Author of the source document.",
                  "nullable": true
                },
                "description": {
                  "type": "string",
                  "description": "Description or summary of the source content.",
                  "nullable": true
                },
                "publishedDate": {
                  "type": "number",
                  "description": "Timestamp of when the source was published.",
                  "nullable": true
                },
                "source": {
                  "type": "string",
                  "description": "Name of the source or publication.",
                  "nullable": true
                },
                "citation": {
                  "type": "boolean",
                  "description": "Indicates if the source is cited in the input text."
                },
                "plagiarismFound": {
                  "type": "array",
                  "description": "List of plagiarism sequence found in the input text from this source.",
                  "items": {
                    "type": "object",
                    "properties": {
                      "startIndex": {
                        "type": "number",
                        "description": "Starting index of the plagiarized sequence in the text."
                      },
                      "endIndex": {
                        "type": "number",
                        "description": "Ending index of the plagiarized sequence in the text."
                      },
                      "sequence": {
                        "type": "string",
                        "description": "The plagiarized text sequence.",
                        "nullable": true
                      }
                    }
                  }
                },
                "is_excluded": {
                  "type": "boolean",
                  "description": "Indicates if this source should be excluded from the final results."
                }
              }
            }
          },
          "attackDetected": {
            "type": "object",
            "description": "An object with two boolean properties indicating if the text contains zero-width spaces or homoglyph attacks.",
            "properties": {
              "zero_width_space": {
                "type": "boolean",
                "description": "Indicates if the text contains zero-width spaces."
              },
              "homoglyph_attack": {
                "type": "boolean",
                "description": "Indicates if the text contains homoglyph attacks."
              }
            }
          },
          "text": {
            "type": "string",
            "description": "The input text that was used for the plagiarism scan."
          },
          "similarWords": {
            "type": "array",
            "description": "List of similar words found in the input text.",
            "items": {
              "type": "object",
              "properties": {
                "index": {
                  "type": "number",
                  "description": "Starting index of the similar word in the document."
                },
                "word": {
                  "type": "string",
                  "description": "The similar word."
                }
              }
            }
          },
          "citations": {
            "type": "array",
            "description": "The citations is an array which contains one or more objects, each corresponding to a different website where the website was cited in the provided text.",
            "items": {
              "type": "string"
            }
          },
          "indexes": {
            "type": "array",
            "description": "List of plagiarism sequences found in the input text.",
            "items": {
              "type": "object",
              "properties": {
                "startIndex": {
                  "type": "number",
                  "description": "Starting index of the plagiarized sequence in the document."
                },
                "endIndex": {
                  "type": "number",
                  "description": "Ending index of the plagiarized sequence in the document."
                },
                "sequence": {
                  "type": "string",
                  "description": "The plagiarized text sequence.",
                  "nullable": true
                }
              }
            }
          },
          "credits_used": {
            "description": "The credits_used field represents the number of credits consumed for processing your request. Each word that is processed by the API consumes two credits.",
            "type": "integer"
          },
          "credits_remaining": {
            "description": "The credits_remaining field shows how many credits you have left in your account after your request has been processed.",
            "type": "integer"
          }
        }
      },
      "ImageDetection": {
        "required": ["url"],
        "type": "object",
        "properties": {
          "url": {
            "description": "Specifies the URL of the image to scan. The URL must be valid, publicly accessible, and point to an image in one of the following formats: JPG, JPEG, PNG, or WEBP. The image must have a minimum resolution of 256x256 pixels.",
            "type": "string"
          },
          "version": {
            "description": "The model version to use. Our latest and most accurate version is \"3\". Using \"latest\" will make sure you are always using the latest version. Options: 3, 2, 1, latest. Default: 3",
            "type": "string"
          }
        }
      },
      "ImageDetection-Response": {
        "type": "object",
        "properties": {
          "score": {
            "description": "The human score that the image is likely to be generated by a human. A low score means our system believes that the image is generated by AI, and a higher score means that the system believes that the image is generated by a Human. The score is between 0 and 100. 0 for AI and 100 for Human.",
            "type": "integer"
          },
          "human_probability": {
            "description": "The human probability that the image is likely to be generated by a human. The probability is between 0 and 1.",
            "type": "integer"
          },
          "ai_probability": {
            "description": "The AI probability that the image is likely to be generated by an AI. The probability is between 0 and 1.",
            "type": "integer"
          },
          "version": {
            "description": "The model version used to generate the prediction.",
            "type": "string"
          },
          "mime_type": {
            "description": "The mime type of the image.",
            "type": "string"
          },
          "c2pa": {
            "description": "The Content Provenance and Authenticity (C2PA) metadata of the image. For more information about what is C2PA, please visit `https://c2pa.org/`",
            "type": "object",
            "properties": {
              "active_manifest": {
                "description": "The last manifest in the list of manifests which is the one with the set of content bindings that are able to be validated.",
                "type": "object",
                "properties": {
                  "vendor": {
                    "type": "string",
                    "description": "Typically an Internet domain name (without the TLD) for the vendor (i.e. `adobe`, `nytimes`). If provided this will be used as a prefix on generated manifest labels."
                  },
                  "claim_generator": {
                    "type": "string",
                    "description": "A UserAgent string that will let a user know what software/hardware/system produced this Manifest - names should not contain spaces (defaults to c2patool)."
                  },
                  "title": {
                    "type": "string",
                    "description": "A human-readable string to be displayed as the title for this Manifest (defaults to the name of the file this manifest was embedded in)."
                  },
                  "credentials": {
                    "type": "object",
                    "description": "An array of W3C verifiable credentials objects defined in the c2pa assertion specification. Section 7."
                  },
                  "thumbnail": {
                    "type": "object",
                    "format": "JSON resource definition",
                    "description": "An object with an identifier field with a file path, and a format with the mime type of that file."
                  },
                  "ingredients": {
                    "type": "array",
                    "format": "Array of JSON ingredients, such as those produced with the --ingredient option",
                    "description": "Ingredients that were used to modify the asset referenced by this Manifest (if any)."
                  },
                  "ingredient_paths": {
                    "type": "array",
                    "format": "Array of local file system paths",
                    "description": "File paths to assets that were used to modify the asset referenced by this Manifest (if any). This may be a JSON Ingredient definition file."
                  },
                  "assertions": {
                    "type": "object",
                    "description": "Objects with label, and data - standard c2pa labels must match values as defined in the c2pa assertion specification."
                  },
                  "alg": {
                    "type": "string",
                    "format": "Local file system path",
                    "description": "Signing algorithm: one of [ ps256 | ps384 | ps512 | es256 | es384 | es512 | ed25519]. Defaults to es256."
                  },
                  "ta_url": {
                    "type": "string",
                    "format": "http URL",
                    "description": "A URL to an RFC3161 compliant Time Stamp Authority. If missing there will no secure timestamp."
                  },
                  "private_key": {
                    "type": "string",
                    "format": "Local file system path",
                    "description": "File path to a private key file."
                  },
                  "sign_cert": {
                    "type": "string",
                    "format": "Local file system path",
                    "description": "File path to signing cert file."
                  }
                }
              },
              "manifests": {
                "type": "object",
                "description": "A collection of manifests attached to an asset. Each manifest contains information about the provenance of the asset. Creating or editing an asset using a C2PA-compliant device or tool (for example Adobe Photoshop) adds a new manifest to the manifest store. See more information at the C2PA website (https://c2pa.org/). ",
                "properties": {
                  "<manifest_key>": {
                    "type": "object",
                    "properties": {
                      "vendor": {
                        "type": "string",
                        "description": "Typically an Internet domain name (without the TLD) for the vendor (i.e. `adobe`, `nytimes`). If provided this will be used as a prefix on generated manifest labels."
                      },
                      "claim_generator": {
                        "type": "string",
                        "description": "A UserAgent string that will let a user know what software/hardware/system produced this Manifest - names should not contain spaces (defaults to c2patool)."
                      },
                      "title": {
                        "type": "string",
                        "description": "A human-readable string to be displayed as the title for this Manifest (defaults to the name of the file this manifest was embedded in)."
                      },
                      "credentials": {
                        "type": "object",
                        "description": "An array of W3C verifiable credentials objects defined in the c2pa assertion specification. Section 7."
                      },
                      "thumbnail": {
                        "type": "object",
                        "format": "JSON resource definition",
                        "description": "An object with an identifier field with a file path, and a format with the mime type of that file."
                      },
                      "ingredients": {
                        "type": "array",
                        "format": "Array of JSON ingredients, such as those produced with the --ingredient option",
                        "description": "Ingredients that were used to modify the asset referenced by this Manifest (if any)."
                      },
                      "ingredient_paths": {
                        "type": "array",
                        "format": "Array of local file system paths",
                        "description": "File paths to assets that were used to modify the asset referenced by this Manifest (if any). This may be a JSON Ingredient definition file."
                      },
                      "assertions": {
                        "type": "object",
                        "description": "Objects with label, and data - standard c2pa labels must match values as defined in the c2pa assertion specification."
                      },
                      "alg": {
                        "type": "string",
                        "format": "Local file system path",
                        "description": "Signing algorithm: one of [ ps256 | ps384 | ps512 | es256 | es384 | es512 | ed25519]. Defaults to es256."
                      },
                      "ta_url": {
                        "type": "string",
                        "format": "http URL",
                        "description": "A URL to an RFC3161 compliant Time Stamp Authority. If missing there will no secure timestamp."
                      },
                      "private_key": {
                        "type": "string",
                        "format": "Local file system path",
                        "description": "File path to a private key file."
                      },
                      "sign_cert": {
                        "type": "string",
                        "format": "Local file system path",
                        "description": "File path to signing cert file."
                      }
                    }
                  }
                }
              }
            }
          },
          "exif": {
            "description": "The exif metadata of the image. We currently retrieve the XMP, EXIF, and IPTC metadata of the image to help us determine if the image was AI generated. For more information about the IPTC metadata, please visit `https://iptc.org/`",
            "type": "object",
            "properties": {
              "DateCreated": {
                "type": "string",
                "description": "Designates the date and optionally the time the content of the image was created rather than the date of the creation of the digital representation."
              },
              "Description": {
                "description": "A textual description, including captions, of the image.",
                "type": "string"
              },
              "Headline": {
                "description": "A brief synopsis of the caption. Headline is not the same as Title.",
                "type": "string"
              },
              "MaxAvailWidth": {
                "type": "string",
                "description": "The maximum available width in pixels of the original photo from which this photo has been derived by downsizing."
              },
              "MaxAvailHeight": {
                "type": "string",
                "description": "The maximum available height in pixels of the original photo from which this photo has been derived by downsizing."
              },
              "ImageRating": {
                "type": "string",
                "description": "Rating of the image by its user or supplier"
              },
              "DescriptionWriter": {
                "type": "string",
                "description": "Identifier or the name of the person(s) involved in writing, editing or correcting the Description, Alt Text (Accessibility), or Extended Description (Accessibility) of the image."
              },
              "Genre": {
                "type": "string",
                "description": "Artistic, style, journalistic, product or other genre(s) of the image (expressed by a term from any Controlled Vocabulary)"
              },
              "RightsUsageTerms": {
                "type": "string",
                "description": "The licensing parameters of the image expressed in free-text."
              },
              "SceneCode": {
                "type": "string",
                "description": "Describes the scene of a photo content. Specifies one ore more terms from the IPTC Scene-NewsCodes. Each Scene is represented as a string of 6 digits in an unordered list."
              },
              "AdditionalModelInformation": {
                "type": "string",
                "description": "Information about the ethnicity and other facets of the model(s) in a model-released image."
              },
              "Creator": {
                "type": "string",
                "description": "Contains the name of the photographer, but in cases where the photographer should not be identified the name of a company or organisation may be appropriate."
              },
              "CreditLine": {
                "type": "string",
                "description": "The credit to person(s) and/or organisation(s) required by the supplier of the image to be used when published. This is a free-text field."
              },
              "CopyrightNotice": {
                "type": "string",
                "description": "Contains any necessary copyright notice for claiming the intellectual property for this photograph and should identify the current owner of the copyright for the photograph. Other entities like the creator of the photograph may be added in the corresponding field. Notes on usage rights should be provided in Rights usage terms."
              },
              "ImageSupplier": {
                "type": "string",
                "description": "Identifies the most recent supplier of the image, who is not necessarily its owner or creator."
              },
              "Locationcreated": {
                "type": "string",
                "description": "The location the photo was taken."
              },
              "MinorModelAgeDisclosure": {
                "type": "string",
                "description": "Age of the youngest model pictured in the image, at the time that the image was made."
              },
              "WebStatementofRights": {
                "type": "string",
                "description": "URL referencing a web resource providing a statement of the copyright ownership and usage rights of the image."
              },
              "ModelAge": {
                "type": "string",
                "description": "Age of the human model(s) at the time this image was taken in a model released image."
              },
              "ImageSupplierImageID": {
                "type": "string",
                "description": "Optional identifier assigned by the Image Supplier to the image."
              },
              "LinkedEncodedRightsExpression": {
                "type": "string",
                "description": "A linked rights expression using any rights expression language."
              },
              "DataMining": {
                "type": "string",
                "description": "Data mining prohibition or permission, optionally with constraints."
              },
              "Artwork": {
                "type": "string",
                "description": "A set of metadata about artwork or an object in the image"
              },
              "ImageRegistryEntry": {
                "type": "string",
                "description": "Both a Registry Item Id and a Registry Organisation Id to record any registration of this digital image with a registry."
              },
              "City": {
                "type": "string",
                "description": "Name of the city of the location shown in the image. This element is at the third level of a top-down geographical hierarchy."
              },
              "CodeofOrganisationFeaturedintheImage": {
                "type": "string",
                "description": "Code from a controlled vocabulary for identifying the organisation or company which is featured in the image."
              },
              "EventIdentifier": {
                "type": "string",
                "description": "Identifier(s) of the specific event at which the photo was taken"
              },
              "EventName": {
                "type": "string",
                "description": "Names or describes the specific event at which the photo was taken."
              },
              "Contributor": {
                "type": "string",
                "description": "Party or parties (person or organisation) which contributed to the image, refinement by the role attribute."
              },
              "CopyrightOwner": {
                "type": "string",
                "description": "Owner or owners of the copyright in the licensed image."
              },
              "Country": {
                "type": "string",
                "description": "Full name of the country of the location shown in the image. This element is at the top/first level of a top-down geographical hierarchy. The full name should be expressed as a verbal name and not as a code, a code should go to the element CountryCode"
              },
              "DigitalSourceType": {
                "type": "string",
                "description": "Name of the organisation or company which is featured in the image."
              },
              "PropertyReleaseId": {
                "type": "string",
                "description": "Identifier(s) of a Property Release document."
              },
              "PropertyReleaseStatus": {
                "type": "string",
                "description": "Summarises the availability and scope of property releases authorising usage of the properties appearing in the photograph."
              },
              "NameofOrganisationFeaturedintheImage": {
                "type": "string",
                "description": "Name of the organisation or company which is featured in the image."
              },
              "Source": {
                "type": "string",
                "description": "The name of a person or party who has a role in the content supply chain. This could be an agency, a member of an agency, an individual or a combination. Source could be different from Creator and from the entities in the Copyright Notice."
              },
              "DigitalImageGUID": {
                "type": "string",
                "description": "Globally unique identifier for this digital image. It is created and applied by the creator of the digital image at the time of its creation . This value shall not be changed after that time."
              },
              "Licensor": {
                "type": "string",
                "description": "A person or company that should be contacted to obtain a licence for using the item or who has licensed the item."
              },
              "keywords": {
                "type": "array",
                "description": "Keywords to express the subject of the image. Keywords may be free text and don't have to be taken from a controlled vocabulary. Codes from the controlled vocabulary IPTC Subject NewsCodes must go to the Subject Code field."
              },
              "ImageCreator": {
                "type": "object",
                "description": "Creator or creators of the image"
              },
              "Instructions": {
                "type": "string",
                "description": "Any number of instructions from the provider or creator to the receiver of the image"
              },
              "Title": {
                "type": "string",
                "description": "A shorthand reference for the digital image. Title provides a short human readable name which can be a text and/or numeric reference. It is not the same as Headline."
              }
            }
          },
          "metadata": {
            "type": "object",
            "description": "Image metadata including dimensions, format, color space, and other technical details",
            "properties": {
              "orientation": {
                "type": "integer",
                "description": "Number value of the EXIF Orientation header, if present"
              },
              "format": {
                "type": "string",
                "description": "Name of decoder used to decompress image data e.g. jpeg, png, webp, gif, svg"
              },
              "size": {
                "type": "integer",
                "description": "Total size of image in bytes, for Stream and Buffer input only"
              },
              "width": {
                "type": "integer",
                "description": "Number of pixels wide (EXIF orientation is not taken into consideration)"
              },
              "height": {
                "type": "integer",
                "description": "Number of pixels high (EXIF orientation is not taken into consideration)"
              },
              "autoOrient": {
                "type": "object",
                "description": "Any changed metadata after the image orientation is applied",
                "properties": {
                  "width": {
                    "type": "integer",
                    "description": "Number of pixels wide (EXIF orientation is taken into consideration)"
                  },
                  "height": {
                    "type": "integer",
                    "description": "Number of pixels high (EXIF orientation is taken into consideration)"
                  }
                },
                "required": ["width", "height"]
              },
              "space": {
                "type": "string",
                "description": "Name of colour space interpretation"
              },
              "channels": {
                "type": "integer",
                "description": "Number of bands e.g. 3 for sRGB, 4 for CMYK"
              },
              "depth": {
                "type": "string",
                "description": "Name of pixel depth format e.g. uchar, char, ushort, float"
              },
              "density": {
                "type": "number",
                "description": "Number of pixels per inch (DPI), if present"
              },
              "chromaSubsampling": {
                "type": "string",
                "description": "String containing JPEG chroma subsampling, 4:2:0 or 4:4:4 for RGB, 4:2:0:4 or 4:4:4:4 for CMYK"
              },
              "isProgressive": {
                "type": "boolean",
                "description": "Boolean indicating whether the image is interlaced using a progressive scan"
              },
              "isPalette": {
                "type": "boolean",
                "description": "Boolean indicating whether the image is palette-based (GIF, PNG)"
              },
              "bitsPerSample": {
                "type": "integer",
                "description": "Number of bits per sample for each channel (GIF, PNG)"
              },
              "pages": {
                "type": "integer",
                "description": "Number of pages/frames contained within the image, with support for TIFF, HEIF, PDF, animated GIF and animated WebP"
              },
              "pageHeight": {
                "type": "integer",
                "description": "Number of pixels high each page in a multi-page image will be"
              },
              "loop": {
                "type": "integer",
                "description": "Number of times to loop an animated image, zero refers to a continuous loop"
              },
              "delay": {
                "type": "array",
                "description": "Delay in ms between each page in an animated image, provided as an array of integers",
                "items": {
                  "type": "integer"
                }
              },
              "pagePrimary": {
                "type": "integer",
                "description": "Number of the primary page in a HEIF image"
              },
              "hasProfile": {
                "type": "boolean",
                "description": "Boolean indicating the presence of an embedded ICC profile"
              },
              "hasAlpha": {
                "type": "boolean",
                "description": "Boolean indicating the presence of an alpha transparency channel"
              },
              "background": {
                "oneOf": [
                  {
                    "type": "object",
                    "properties": {
                      "r": {
                        "type": "integer"
                      },
                      "g": {
                        "type": "integer"
                      },
                      "b": {
                        "type": "integer"
                      }
                    },
                    "required": ["r", "g", "b"]
                  },
                  {
                    "type": "object",
                    "properties": {
                      "gray": {
                        "type": "number"
                      }
                    },
                    "required": ["gray"]
                  }
                ],
                "description": "Default background colour, if present, for PNG (bKGD) and GIF images"
              },
              "levels": {
                "type": "array",
                "description": "Details of each level in a multi-level image provided as an array of objects, requires libvips compiled with support for OpenSlide",
                "items": {
                  "type": "object"
                }
              },
              "subifds": {
                "type": "integer",
                "description": "Number of Sub Image File Directories in an OME-TIFF image"
              },
              "resolutionUnit": {
                "type": "string",
                "description": "The unit of resolution (density)"
              },
              "formatMagick": {
                "type": "string",
                "description": "String containing format for images loaded via *magick"
              },
              "comments": {
                "type": "array",
                "description": "Array of keyword/text pairs representing PNG text blocks, if present",
                "items": {
                  "type": "object"
                }
              }
            },
            "required": ["format", "width", "height", "autoOrient", "space", "channels", "depth", "isProgressive", "isPalette", "hasProfile", "hasAlpha"]
          },
          "ai_watermark_detected": {
            "description": "Whether an AI watermark was detected in the image.",
            "type": "boolean"
          },
          "ai_watermark_issuers": {
            "description": "The list of AI watermark issuers detected in the image.",
            "type": "object"
          },
          "credits_used": {
            "description": "The credits_used field represents the number of credits consumed for processing your request. Each image that is processed by the API consumes 300 credits.",
            "type": "integer"
          },
          "credits_remaining": {
            "description": "The credits_remaining field shows how many credits you have left in your account after your request has been processed.",
            "type": "integer"
          }
        }
      },
      "Error": {
        "required": ["error"],
        "type": "object",
        "properties": {
          "error": {
            "type": "string"
          },
          "description": {
            "type": "string"
          }
        }
      },
      "TextCompare": {
        "required": ["first_text", "second_text"],
        "type": "object",
        "properties": {
          "first_text": {
            "description": "The first text to compare. Maximum 120,000 characters.",
            "type": "string",
            "maxLength": 120000
          },
          "second_text": {
            "description": "The second text to compare against the first text. Maximum 120,000 characters.",
            "type": "string",
            "maxLength": 120000
          }
        }
      },
      "TextCompare-response": {
        "type": "object",
        "properties": {
          "status": {
            "type": "integer",
            "description": "HTTP status code representing the result of the text comparison request"
          },
          "similarity_score": {
            "type": "number",
            "description": "Overall similarity score between the two texts (0-100). \n\n 0 means no similarity, 100 means identical."
          },
          "first_text": {
            "type": "object",
            "properties": {
              "total_word_count": {
                "type": "integer",
                "description": "Total number of words in the first text"
              },
              "matching_word_count": {
                "type": "integer",
                "description": "Number of words that match with the second text"
              },
              "similarity_percentage": {
                "type": "number",
                "description": "Percentage of matching content in the first text"
              },
              "items": {
                "type": "array",
                "description": "List of matching segments in the first text",
                "items": {
                  "type": "object",
                  "properties": {
                    "type": {
                      "type": "string",
                      "description": "Type of match (identical, similar, etc.)"
                    },
                    "word_count": {
                      "type": "integer",
                      "description": "Number of words in this segment"
                    },
                    "index_start": {
                      "type": "integer",
                      "description": "Starting index of the segment in the text"
                    },
                    "length": {
                      "type": "integer",
                      "description": "Length of the segment in characters"
                    }
                  }
                }
              }
            }
          },
          "second_text": {
            "type": "object",
            "properties": {
              "total_word_count": {
                "type": "integer",
                "description": "Total number of words in the second text"
              },
              "matching_word_count": {
                "type": "integer",
                "description": "Number of words that match with the first text"
              },
              "similarity_percentage": {
                "type": "number",
                "description": "Percentage of matching content in the second text"
              },
              "items": {
                "type": "array",
                "description": "List of matching segments in the second text",
                "items": {
                  "type": "object",
                  "properties": {
                    "type": {
                      "type": "string",
                      "description": "Type of match (identical, similar, etc.)"
                    },
                    "word_count": {
                      "type": "integer",
                      "description": "Number of words in this segment"
                    },
                    "index_start": {
                      "type": "integer",
                      "description": "Starting index of the segment in the text"
                    },
                    "length": {
                      "type": "integer",
                      "description": "Length of the segment in characters"
                    }
                  }
                }
              }
            }
          },
          "credits_used": {
            "description": "The credits_used field represents the number of credits consumed for processing your request. Each text comparison request consumes the total number of words in both texts divided by 2.",
            "type": "integer"
          },
          "credits_remaining": {
            "description": "The credits_remaining field shows how many credits you have left in your account after your request has been processed.",
            "type": "integer"
          }
        }
      }
    },
    "securitySchemes": {
      "bearerAuth": {
        "type": "http",
        "scheme": "bearer"
      }
    }
  }
}
