import os, requests


# Set API key ENV variable or replace with your own API key
API_KEY=os.getenv("AIORNOT_API_KEY")
IMAGE_ENDPOINT = "https://api.aiornot.com/v2/image/sync"

# By default, ai_generated, deepfake, nsfw, and quality reports run.
# Use 'only' and 'excluding' parameters to select subsets.
# Note: ai_generated and deepfake have their own costs.

with open("image.jpeg", "rb") as f:
    resp = requests.post(
        IMAGE_ENDPOINT,
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"image": f},
        params={
            "external_id": "my-tracking-id"  # Optional
            # Example: only run reverse_search:
            # "only": ["reverse_search"]
            # Example: run all defaults except deepfake:
            # "excluding": ["deepfake"]
        }
    )
    resp.raise_for_status()
    print(resp.json())

# By default, ai_generated, deepfake, nsfw, and quality reports run.
# Use 'only' and 'excluding' parameters to select subsets.
# Note: ai_generated and deepfake have their own costs.

curl --request POST \
  --url https://api.aiornot.com/v2/image/sync \
  --header 'Authorization: Bearer $AIORNOT_API_KEY' \
  --form 'image=@image.jpeg'

# Example: only run reverse_search
# curl --request POST \
#   --url 'https://api.aiornot.com/v2/image/sync?only=reverse_search' \
#   --header 'Authorization: Bearer $AIORNOT_API_KEY' \
#   --form 'image=@image.jpeg'

# Example: run all defaults except deepfake
# curl --request POST \
#   --url 'https://api.aiornot.com/v2/image/sync?excluding=deepfake' \
#   --header 'Authorization: Bearer $AIORNOT_API_KEY' \
#   --form 'image=@image.jpeg'

// By default, ai_generated, deepfake, nsfw, and quality reports run.
// Use 'only' and 'excluding' parameters to select subsets.
// Note: ai_generated and deepfake have their own costs.

const fs = require('fs');
const FormData = require('form-data');
const fetch = require('node-fetch');

const API_KEY = process.env.AIORNOT_API_KEY;
const IMAGE_ENDPOINT = 'https://api.aiornot.com/v2/image/sync';

const form = new FormData();
form.append('image', fs.createReadStream('image.jpeg'));

const params = new URLSearchParams({
  external_id: 'my-tracking-id'  // Optional
  // Example: only run reverse_search:
  // only: 'reverse_search'
  // Example: run all defaults except deepfake:
  // excluding: 'deepfake'
});

fetch(`${IMAGE_ENDPOINT}?${params}`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    ...form.getHeaders()
  },
  body: form
})
  .then(response => {
    if (!response.ok) {
      throw new Error(`Failed to analyze image: ${response.status} ${response.statusText}`);
    }
    return response.json();
  })
  .then(data => console.log(data))
  .catch(error => console.error('Error:', error));

<?php
// By default, ai_generated, deepfake, nsfw, and quality reports run.
// Use 'only' and 'excluding' parameters to select subsets.
// Note: ai_generated and deepfake have their own costs.

$API_KEY = getenv('AIORNOT_API_KEY');
$IMAGE_ENDPOINT = 'https://api.aiornot.com/v2/image/sync';

$curl = curl_init();

$imageFile = new CURLFile('image.jpeg', 'image/jpeg', 'image');

$query_params = http_build_query([
  'external_id' => 'my-tracking-id'  // Optional
  // Example: only run reverse_search:
  // 'only' => ['reverse_search']
  // Example: run all defaults except deepfake:
  // 'excluding' => ['deepfake']
]);

curl_setopt_array($curl, [
  CURLOPT_URL => $IMAGE_ENDPOINT . '?' . $query_params,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => [
    'image' => $imageFile
  ],
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer $API_KEY"
  ],
]);

$response = curl_exec($curl);
$httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} elseif ($httpCode !== 200) {
  echo "Failed to analyze image: HTTP $httpCode - $response";
} else {
  $data = json_decode($response, true);
  print_r($data);
}

// By default, ai_generated, deepfake, nsfw, and quality reports run.
// Use 'only' and 'excluding' parameters to select subsets.
// Note: ai_generated and deepfake have their own costs.

package main

import (
  "bytes"
  "fmt"
  "io"
  "io/ioutil"
  "mime/multipart"
  "net/http"
  "net/url"
  "os"
)

func main() {
  APIKey := os.Getenv("AIORNOT_API_KEY")
  imageEndpoint := "https://api.aiornot.com/v2/image/sync"

  file, err := os.Open("image.jpeg")
  if err != nil {
    panic(err)
  }
  defer file.Close()

  var requestBody bytes.Buffer
  writer := multipart.NewWriter(&requestBody)

  part, err := writer.CreateFormFile("image", "image.jpeg")
  if err != nil {
    panic(err)
  }

  _, err = io.Copy(part, file)
  if err != nil {
    panic(err)
  }

  err = writer.Close()
  if err != nil {
    panic(err)
  }

  params := url.Values{}
  params.Set("external_id", "my-tracking-id")  // Optional
  // Example: only run reverse_search:
  // params.Set("only", "reverse_search")
  // Example: run all defaults except deepfake:
  // params.Set("excluding", "deepfake")

  fullURL := imageEndpoint + "?" + params.Encode()

  req, err := http.NewRequest("POST", fullURL, &requestBody)
  if err != nil {
    panic(err)
  }

  req.Header.Set("Authorization", "Bearer "+APIKey)
  req.Header.Set("Content-Type", writer.FormDataContentType())

  client := &http.Client{}
  resp, err := client.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    panic(err)
  }

  if resp.StatusCode != 200 {
    fmt.Printf("Failed to analyze image: %d %s\n", resp.StatusCode, string(body))
    return
  }

  fmt.Println(string(body))
}

// By default, ai_generated, deepfake, nsfw, and quality reports run.
// Use 'only' and 'excluding' parameters to select subsets.
// Note: ai_generated and deepfake have their own costs.

import java.io.File;
import java.io.IOException;
import okhttp3.*;

public class ImageAnalysis {
    public static void main(String[] args) {
        String apiKey = System.getenv("AIORNOT_API_KEY");
        String imageEndpoint = "https://api.aiornot.com/v2/image/sync";

        OkHttpClient client = new OkHttpClient();

        File imageFile = new File("image.jpeg");

        RequestBody requestBody = new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("image", imageFile.getName(),
                RequestBody.create(MediaType.parse("image/jpeg"), imageFile))
            .build();

        HttpUrl url = HttpUrl.parse(imageEndpoint).newBuilder()
            .addQueryParameter("external_id", "my-tracking-id")  // Optional
            // Example: only run reverse_search:
            // .addQueryParameter("only", "reverse_search")
            // Example: run all defaults except deepfake:
            // .addQueryParameter("excluding", "deepfake")
            .build();
        
        Request request = new Request.Builder()
            .url(url)
            .header("Authorization", "Bearer " + apiKey)
            .post(requestBody)
            .build();
        
        try {
            Response response = client.newCall(request).execute();
            if (!response.isSuccessful()) {
                System.err.println("Failed to analyze image: " + response.code() + " " + response.body().string());
            } else {
                System.out.println(response.body().string());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

require 'uri'
require 'net/http'

url = URI("https://api.aiornot.com/v2/image/sync")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"image\"; filename=\"example-file\"\r\nContent-Type: application/octet-stream\r\n\r\n<string>\r\n-----011000010111000001101001--"

response = http.request(request)
puts response.read_body

{
  "id": "3c90c3cc-0d44-4b50-8888-8dd25736052a",
  "report": {
    "meta": {
      "width": 640,
      "height": 480,
      "format": "jpeg",
      "size_bytes": 102400,
      "md5": "a1b2c3d4e5f6789012345678901234567",
      "processing_status": {
        "ai_generated": "processed",
        "deepfake": "processed",
        "nsfw": "processed",
        "quality": "processed"
      }
    },
    "ai_generated": {
      "ai": {
        "is_detected": true,
        "confidence": 0.95
      },
      "human": {
        "is_detected": false,
        "confidence": 0.05
      },
      "generator": {
        "midjourney": 0.95,
        "dall_e": 0.95,
        "stable_diffusion": 0.95,
        "this_person_does_not_exist": 0.95,
        "adobe_firefly": 0.95,
        "flux": 0.95,
        "four_o": 0.95
      }
    },
    "deepfake": {
      "is_detected": true,
      "confidence": 0.95,
      "rois": [
        {
          "is_detected": true,
          "confidence": 0.95,
          "bbox": {
            "x1": 120,
            "y1": 85,
            "x2": 380,
            "y2": 295
          }
        }
      ]
    },
    "nsfw": {
      "is_detected": true,
      "version": "1.0.0"
    },
    "quality": {
      "is_detected": true
    },
    "reverse_search": {
      "was_found": true,
      "matches": [
        {
          "domain": "cnet.com",
          "image_url": "https://img.tineye.com/result/59752e592ddca832cb36bf200135b4f30f6fadca2ea4acc7c63f8dd231463c72-43",
          "width": 196,
          "height": 147,
          "earliest_crawl_date": "2021-03-26",
          "earliest_backlink": "https://www.cnet.com/topics/internet-culture/2/"
        }
      ]
    }
  },
  "created_at": "2023-11-07T05:31:56Z",
  "external_id": "<string>"
}

{
  "detail": [
    {
      "loc": [
        "<string>"
      ],
      "msg": "<string>",
      "type": "<string>"
    }
  ]
}