Everypixel Labs

https://labs.everypixel.com/docs
Admin
Everypixel Labs is an AI-powered API platform offering advanced services for image and video...
Tokens:29,212
Snippets:156
Trust Score:10
Update:7 months ago
Show doc for...
Tokens:
Raw
### POST /v1/keywords Example

Source: https://labs.everypixel.com/docs/index

Example of using Basic HTTP authentication with the Image Keywording endpoint.

```APIDOC
## POST /v1/keywords

### Description
This endpoint analyzes an image and returns a list of keywords describing its content, along with confidence scores. Authentication is required.

### Method
GET

### Endpoint
`/v1/keywords`

### Query Parameters
- **url** (string) - Required - The URL of the image to analyze.

### Request Example
```bash
curl --user "YOUR_CLIENT_ID:YOUR_CLIENT_SECRET" "https://api.everypixel.com/v1/keywords?url=https://example.com/your_image.jpg"
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the request (e.g., "ok").
- **keywords** (array) - A list of keyword objects.
  - **keyword** (string) - The identified keyword.
  - **score** (number) - The confidence score for the keyword.

#### Response Example
```json
{
  "status": "ok",
  "keywords": [
    { "keyword": "tree", "score": 0.987 },
    { "keyword": "sky", "score": 0.932 }
  ]
}
```

#### Error Responses
- **401 Unauthorized**: Invalid or missing credentials.
- **429 Too Many Requests**: Exceeded rate limits or quota.
```

--------------------------------

### Image Captioning Request Examples (Curl, Python, PHP)

Source: https://labs.everypixel.com/docs/index

Demonstrates how to send an image to the image captioning API using cURL, Python, and PHP. These examples show how to upload an image file via POST request and authenticate using client ID and secret.

```curl
curl -X POST -u <your-client-id>:<your-client-secret> \
 -F "data=@/path/to/image.jpg" \
 https://api.everypixel.com/v1/image_captioning
```

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

import requests

with open('image.jpg','rb') as image:
    data = {'data': image}
    title = requests.post('https://api.everypixel.com/v1/image_captioning', files=data, auth=(client_id, client_secret)).json()
```

```php
$authorization = "<your-client-id>":"<your-client-secret>";
$url = "https://api.everypixel.com/v1/image_captioning";

$curl = curl_init();
curl_setopt($curl, CURLOPT_USERPWD, $authorization);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_POST, true);
curl_setopt($curl, CURLOPT_POSTFIELDS, ['data' => new CURLFile('/path/to/image.jpg')]);

$data = curl_exec($curl);
curl_close($curl);

$json = json_decode($data);
```

--------------------------------

### Lipsync API - Input Methods (GET and POST)

Source: https://labs.everypixel.com/docs/index

This documentation describes how to use the Everypixel Lipsync API. It explains the input requirements for audio and video, supporting both URL-based access (GET requests with query parameters) and direct file uploads (POST requests with multipart form fields).

```markdown
## Input
You need to provide two inputs:
  * **Audio** – The new speech audio you want the person to appear to say. This should be a spoken word audio (preferably with **no background music** and minimal noise). The audio should ideally be a clean voice recording.
  * **Supported audio formats:** MP3, WAV, M4A, OGG, FLAC, OPUS, AIFF, WMA, WEBM, WEBA, OGA, MID, AU.
  * **Video** – The original video of the person (with a clear view of the person’s face and mouth for best results).
  * **Supported video formats:** MP4, MOV, AVI, WEBM, MPEG, MPG, M4V, WMV, OGV, OGM, ASX.

Both audio and video can be provided as URLs or uploaded as files:
  * **GET:** Use query parameter `audio_url` and `video_url` to point to the audio and video files accessible online. Make sure all values are URL-encoded if they contain special characters (such as `?` or `&`).
  * **POST:** Upload the input files directly. Use multipart form fields named `audio` (for the voice audio file) and `video` (for the original video file).

```

--------------------------------

### Create Lip Sync Task via GET Request (Python)

Source: https://labs.everypixel.com/docs/index

This snippet shows how to initiate a lip sync task using a GET request, providing audio and video URLs directly in the parameters. It also illustrates the use of optional 'title' and 'callback' parameters. The response includes the task ID.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

# or GET request
response = requests.get(
    url="https://api.everypixel.com/v1/lipsync/create",
    params={
        "audio_url": "https://labs.everypixel.com/media/tts/audio_samples_demo/ascend.mp3",
        "video_url": "https://labs.everypixel.com/static/v/lipsync.mp4",
        "title": "<my_video: str>"   # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"       # OPTIONAL, default=None
    },
    auth=(client_id, client_secret)
)

# Save task_id to check the status
task_id = response.json().get("task_id")
```

--------------------------------

### Get Image Keywords using Python

Source: https://labs.everypixel.com/docs/index

This Python code demonstrates how to interact with the Everypixel Image Keywording API using the requests library. It shows two methods: one for sending a GET request with an image URL and parameters, and another for sending a POST request with an image file. Both methods use basic authentication and return a JSON response.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
params = {'url': 'http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg', 'num_keywords': 10, 'colors': True, 'num_colors': 5, 'lang': 'en'}
keywords = requests.get('https://api.everypixel.com/v1/keywords', params=params, auth=(client_id, client_secret)).json()

with open('image.jpg','rb') as image:
  data = {'data': image}
  keywords = requests.post('https://api.everypixel.com/v1/keywords', files=data, auth=(client_id, client_secret)).json()
  print(keywords)
```

--------------------------------

### Request Methods (GET vs POST)

Source: https://labs.everypixel.com/docs/index

Endpoints allow submitting input data (images or videos) either by URL (GET) or by uploading the file (POST).

```APIDOC
## Request Methods (GET vs POST)

### Description
Many endpoints allow you to submit input data (images or videos) either by URL or by uploading the file. There are two ways to send data:

### GET Requests
If you have a publicly accessible URL for the image or video, you can use a GET request and pass the URL as a query parameter (e.g. `?url=<IMAGE_URL>`). Note: If the media URL contains special characters (such as `&` or `?`), you **must URL-encode** the URL so that it is safely included as a parameter. For example, `&` becomes `%26` and `?` becomes `%3F`. Failing to encode may result in an error or the URL being cut off.

### POST Requests
To upload a file directly, use a POST request with multipart form data. Each endpoint has a specific field name for the file (commonly this field is named `data` for image uploads, but some endpoints use a different name as noted below). When using POST to upload files, you do not need to URL-encode anything. Simply ensure you use the correct field name and include the binary file in the request.
```

--------------------------------

### Get Image Keywords using PHP

Source: https://labs.everypixel.com/docs/index

This PHP script utilizes cURL to make a GET request to the Everypixel Image Keywording API. It sets up client credentials, image URL, and API parameters. The script handles authentication, sends the request, checks for cURL errors, and decodes the JSON response, printing it for review.

```php
<?php
// Your client credentials
$client_id = '<your-client-id>';
$client_secret = '<your-client-secret>';

// The image URL and parameters
$params = [
    'url' => 'http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg',
    'num_keywords' => 10,
    'colors' => true,
    'num_colors' => 5,
    'lang' => 'en'
];

// Build the query string from parameters
$query = http_build_query($params);


// The API endpoint
$url = "https://api.everypixel.com/v1/keywords?$query";

// Initialize a cURL session
$ch = curl_init($url);

// Set the basic authentication
curl_setopt($ch, CURLOPT_USERPWD, "$client_id:$client_secret");

// Set options to return the response as a string
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Execute the request and fetch the response
$response = curl_exec($ch);

// Check for cURL errors
if (curl_errno($ch)) {
    echo 'cURL error: ' . curl_error($ch);
    exit;
}

// Close the cURL session
curl_close($ch);

// Decode the JSON response
$keywords = json_decode($response, true);

// Print the response (for debugging)
print_r($keywords);

?>
```

--------------------------------

### GET /v1/lipsync/create

Source: https://labs.everypixel.com/docs/index

Creates a lip sync task using URLs for audio and video. The API fetches the provided URLs and processes them to generate a lip-synced video.

```APIDOC
## GET /v1/lipsync/create

### Description
Creates a lip sync task using URLs for audio and video. The API fetches the provided URLs and processes them to generate a lip-synced video.

### Method
GET

### Endpoint
https://api.everypixel.com/v1/lipsync/create

### Parameters
#### Query Parameters
- **audio_url** (URL) - Required - The URL of the audio file.
- **video_url** (URL) - Required - The URL of the video file.
- **title** (string, optional) - Sets the name for the output file; if omitted, a default name will be used.
- **callback** (URL, optional) - If set, the API will POST the result to this URL when processing is complete — use instead of manual status polling.

### Request Example
```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

response = requests.get(
    url="https://api.everypixel.com/v1/lipsync/create",
    params={
        "audio_url": "https://labs.everypixel.com/media/tts/audio_samples_demo/ascend.mp3",
        "video_url": "https://labs.everypixel.com/static/v/lipsync.mp4",
        "title": "<my_video: str>",   # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"       # OPTIONAL, default=None
    },
    auth=(client_id, client_secret)
)

task_id = response.json().get("task_id")
```

### Response
#### Success Response (201)
- **task_id** (string) - ID of the created lip sync task.
- **status** (string) - Initial status (`PENDING` or `STARTED`).
- **queue** (integer) - Position in queue (if any).
- **result** (string) - Will contain the output video URL once the task is finished (initially empty or placeholder).

#### Response Example
```json
{
  "task_id": "uuid",
  "status": "PENDING",
  "queue": 1,
  "result": ""
}
```
```

--------------------------------

### Image Captioning API Response Example

Source: https://labs.everypixel.com/docs/index

An example of the JSON response received from the image captioning API. It includes a 'result' object containing the generated 'caption' and a 'status' field indicating success.

```json
{
  "result": {
    "caption": "<caption>"
  },
  "status": True
}
```

--------------------------------

### Get Image Keywords using Curl

Source: https://labs.everypixel.com/docs/index

This snippet shows how to use Curl to send a GET request to the Everypixel Image Keywording API. It includes authentication with client ID and secret, and specifies parameters like image URL, number of keywords, and color information. The output is a JSON object containing keywords and dominant colors.

```curl
curl --user "<your-client-id>:<your-client-secret>" "https://api.everypixel.com/v1/keywords?url=http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg&num_keywords=10&colors=True&num_colors=5&lang=en"
```

--------------------------------

### Example API Response for Quality Score

Source: https://labs.everypixel.com/docs/index

This is an example of the JSON response received from the quality scoring endpoint. It includes the quality score and a status indicator.

```json
{
  "quality": {
    "score": 0.9729430521699124
  },
  "status": "ok"
}
```

--------------------------------

### Get Video Keywords via URL (PHP)

Source: https://labs.everypixel.com/docs/index

This PHP code uses cURL to fetch video keywords from a URL. It sets up the authorization header with client credentials and makes a GET request to the API. The response is then decoded from JSON.

```php
$authorization = "<your-client-id>":"<your-client-secret>";
$url = "https://api.everypixel.com/v1/video_keywords?url=https://media.gettyimages.com/videos/man-talking-with-colleague-in-the-office-video-id843434746&num_keywords=10";

$curl = curl_init();
curl_setopt($curl, CURLOPT_USERPWD, $authorization);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$data = curl_exec($curl);
curl_close($curl);

$json = json_decode($data);
```

--------------------------------

### Get Video Keywords via URL (Python)

Source: https://labs.everypixel.com/docs/index

This Python code uses the `requests` library to get video keywords from a specified URL. It handles authentication using client ID and secret and allows for optional parameters like `num_keywords`. The response is returned as a JSON object.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
params = {'url': 'https://media.gettyimages.com/videos/man-talking-with-colleague-in-the-office-video-id843434746', 'num_keywords': 10}
keywords = requests.get('https://api.everypixel.com/v1/video_keywords', params=params, auth=(client_id, client_secret)).json()
```

--------------------------------

### Detect Faces using URL or File Upload (Python)

Source: https://labs.everypixel.com/docs/index

This Python code shows how to use the Everypixel API for face detection. It supports both providing an image URL via GET request parameters and uploading an image file via POST request. Authentication is handled using client ID and secret.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
params = {'url': 'https://labs.everypixel.com/static/i/estest_sample3.jpg'}
quality = requests.get('https://api.everypixel.com/v1/faces', params=params, auth=(client_id, client_secret)).json()

with open('image.jpg','rb') as image:
    data = {'data': image}
    quality = requests.post('https://api.everypixel.com/v1/faces', files=data, auth=(client_id, client_secret)).json()
```

--------------------------------

### Get Video Keywords via URL (cURL)

Source: https://labs.everypixel.com/docs/index

This snippet demonstrates how to fetch video keywords by providing a video URL directly in the request using cURL. It requires authentication credentials and specifies the number of keywords to retrieve.

```bash
curl --user "<your-client-id>:<your-client-secret>" "https://api.everypixel.com/v1/video_keywords?url=https://media.gettyimages.com/videos/man-talking-with-colleague-in-the-office-video-id843434746&num_keywords=10"
```

--------------------------------

### GET /v1/imageswap/create

Source: https://labs.everypixel.com/docs/index

Initiates a face swap task by providing URLs for the source and target images. This method is suitable for passing image locations directly in the request.

```APIDOC
## GET /v1/imageswap/create

### Description
Initiates a face swap task by providing URLs for the source and target images. This method is suitable for passing image locations directly in the request.

### Method
GET

### Endpoint
/v1/imageswap/create

### Parameters
#### Query Parameters
- **source_url** (URL) - Required - The URL of the source image (the “donor” face).
- **target_url** (URL) - Required - The URL of the target image (the “double” to receive the face).
- **use_gfpgan** (boolean) - Optional, default `false` - If `true`, enable an extra face enhancement step (using GFPGAN) after the swap. This can sometimes improve the visual quality of the result (sharpening or restoring facial details) at the cost of slightly longer processing.
- **title** (string) - Optional - Sets the name for the output file; if omitted, a default name will be used.
- **callback** (URL) - Optional - If set, the API will POST the result to this URL when processing is complete — use instead of manual status polling.

### Request Example
```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
source_image_url = "https://example.com/source.jpg"
target_image_url = "https://example.com/target.jpg"

params = {
    "source_url": source_image_url,
    "target_url": target_image_url,
    "use_gfpgan": True,
    "title": "my_url_swap",  # OPTIONAL
    "callback": "https://example.com/callback" # OPTIONAL
}

response = requests.get(
    url="https://api.everypixel.com/v1/imageswap/create",
    params=params,
    auth=(client_id, client_secret)
)

task_id = response.json().get("task_id")
```

### Response
#### Success Response (201)
- **task_id** (string) - ID of the created face swap task.
- **status** (string) - Initial status (`PENDING` or `STARTED`).
- **queue** (integer) - Position in queue (if any).
- **result** (string) - Will be available as an image file (typically a URL to a JPG/PNG).

#### Response Example
```json
{
  "task_id": "uuid",
  "status": "PENDING",
  "eta": 120.5,
  "queue": 5,
  "result": null
}
```
```

--------------------------------

### Upload Stock Photo for Quality Score (Python)

Source: https://labs.everypixel.com/docs/index

This Python snippet illustrates how to upload an image file to get its quality score. It uses the `requests` library to send a POST request with the image data in multipart/form-data format.

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
with open('image.jpg','rb') as image:
    data = {'data': image}
    quality = requests.post('https://api.everypixel.com/v1/quality', files=data, auth=(client_id, client_secret)).json()
```

--------------------------------

### Lip Sync Task Creation Response (JSON)

Source: https://labs.everypixel.com/docs/index

This is an example of the JSON payload returned upon a successful lip sync task creation request. It includes the 'task_id', initial 'status', 'progress', 'queue' position, and a placeholder for the 'result' URL.

```json
{
  "task_id": "uuid",
  "status": "str",
  "progress": "float",
  "queue": "int",
  "result": "str"
}
```

--------------------------------

### JSON Error Response Example

Source: https://labs.everypixel.com/docs/index

This snippet demonstrates the typical JSON structure returned by the Everypixel API when an error occurs. It includes a 'status' field set to 'error' and a 'message' field providing a human-readable explanation of the issue. This format is consistent across various error conditions.

```json
{
  "status": "error",
  "message": "Threshold must be float."
}
```

--------------------------------

### Get Stock Photo Quality Score via URL (Python)

Source: https://labs.everypixel.com/docs/index

This Python code snippet shows how to get the quality score of a stock photo using its URL. It utilizes the `requests` library for making the HTTP GET request and basic authentication.

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
params = {'url': 'http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg'}
quality = requests.get('https://api.everypixel.com/v1/quality', params=params, auth=(client_id, client_secret)).json()
```

--------------------------------

### Create Video Swap Task via POST Request (Python)

Source: https://labs.everypixel.com/docs/index

This Python snippet demonstrates how to create a video swap task by uploading a source face image and a target video file using a POST request. It includes authentication, file handling, and parameter configuration. The response contains a task ID for status checking.

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
source_path = Path('folder/source.png')
target_path = Path('folder/target.mp4')
source_file = open(source_path, 'rb')
target_file = open(target_path, 'rb')

response = requests.post(
    url= "https://api.everypixel.com/v1/videoswap/create",
    files={'source': (source_path.name, source_file)},
    data={
        "use_gfpgan": <False: bool>,
        "title": "<title: str>",  # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"  # OPTIONAL, default=None, see the callback section
    },
    auth=(client_id, client_secret)
)
source_file.close()
target_file.close()


# Save task_id to check the status
task_id = response.json().get("task_id")

```

--------------------------------

### Create Image Face Swap Task (Python)

Source: https://labs.everypixel.com/docs/index

This Python snippet demonstrates how to initiate an image face swap task using the Everypixel API. It shows how to upload source and target images as files and includes optional parameters for 'use_gfpgan', 'title', and 'callback'. The response contains a 'task_id' for status monitoring.

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
source_path = Path('folder/source.png')
target_path = Path('folder/target.png')
source_file = open(source_path, 'rb')
target_file = open(target_path, 'rb')

response = requests.post(
    url= "https://api.everypixel.com/v1/imageswap/create",
    files={'source': (source_path.name, source_file),
          'target': (target_path.name, target_file)},
    data={
        "use_gfpgan": <False: bool>,
        "title": "<title: str>",  # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"  # OPTIONAL, default=None, see the callback section
    },
    auth=(client_id, client_secret)
)
source_file.close()
target_file.close()


# Save task_id to check the status
task_id = response.json().get("task_id")

```

--------------------------------

### Upload Video for Keywords (Python)

Source: https://labs.everypixel.com/docs/index

This Python snippet shows how to upload a video file for keyword extraction using a POST request. It reads the video file in binary mode and sends it as multipart/form-data, along with authentication credentials.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

with open('video.mp4','rb') as file:
    data = {'data': file}
    keywords = requests.post('https://api.everypixel.com/v1/video_keywords', files=data, auth=(client_id, client_secret)).json()
```

--------------------------------

### GET /v1/tts/voices

Source: https://labs.everypixel.com/docs/index

Retrieves a list of all supported Text-to-Speech voices with their metadata.

```APIDOC
## GET /v1/tts/voices

### Description
Returns a list of all supported TTS voices with metadata, including voice name, language, gender, and age group. This request is free and does not count toward your usage quota.

### Method
GET

### Endpoint
/v1/tts/voices

### Parameters
None

### Response
#### Success Response (200 OK)
- **api_name** (string) - A unique identifier for the voice model.
- **language** (string) - The language this voice is trained for (e.g., `eng`, `spa`, `fra`).
- **gender** (string) - The speaker’s gender (`male` or `female`).
- **age** (string) - The approximate age group of the voice (`child`, `young`, `adult`, `old`).

#### Response Example
```json
{
    "api_name": "jack",
    "age": "adult",
    "language": "eng",
    "gender": "male"
}
```
```

--------------------------------

### Analyze Image Quality using URL and File Upload (Python)

Source: https://labs.everypixel.com/docs/index

This Python code illustrates two methods for analyzing image quality via the Everypixel API: using a URL for the image and uploading the image file directly. Both methods require authentication with client ID and secret.

```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

# Using URL
params = {'url': 'http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg'}
quality_url = requests.get('https://api.everypixel.com/v1/quality_ugc', params=params, auth=(client_id, client_secret)).json()

# Using File Upload
with open('image.jpg','rb') as image:
    data = {'data': image}
    quality_file = requests.post('https://api.everypixel.com/v1/quality_ugc', files=data, auth=(client_id, client_secret)).json()
```

--------------------------------

### GET /v1/tts/voices

Source: https://labs.everypixel.com/docs/index

Retrieves a list of available voices for the text-to-speech service.

```APIDOC
## GET /v1/tts/voices

### Description
Retrieves a list of available voices for the text-to-speech service.

### Method
GET

### Endpoint
https://api.everypixel.com/v1/tts/voices

### Parameters
None

### Request Example
```python
import requests

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'

response = requests.get(
    url="https://api.everypixel.com/v1/tts/voices",
    auth=(client_id, client_secret)
)

voices = response.json()
```

### Response
#### Success Response (200)
- **voices** (array) - A list of available voices, each with details like language, name, and gender.

#### Response Example
```json
{
  "voices": [
    {
      "language": "en-US",
      "name": "en-US-Wavenet-A",
      "gender": "FEMALE"
    },
    {
      "language": "en-US",
      "name": "en-US-Wavenet-B",
      "gender": "MALE"
    }
  ]
}
```
```

--------------------------------

### Create Lip Sync Task via POST Request (Python)

Source: https://labs.everypixel.com/docs/index

This snippet demonstrates how to create a lip sync task by sending audio and video files via a POST request. It includes setting optional parameters like 'title' and 'callback'. The response contains a task ID for status checking.

```python
import requests
from pathlib import Path

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
audio_path = Path('folder/example.wav')
video_path = Path('folder/example.mp4')
audio_file = open(audio_path, 'rb')
video_file = open(video_path, 'rb')

# POST request
response = requests.post(
    url="https://api.everypixel.com/v1/lipsync/create",
    files={'audio': (audio_path.name, audio_file)},
    data={
        "title": "<my_video: str>",    # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"         # OPTIONAL, default=None, see the callback section
    },
    auth=(client_id, client_secret)
)
audio_file.close()
video_file.close()

# Save task_id to check the status
task_id = response.json().get("task_id")
```

--------------------------------

### POST /v1/lipsync/create

Source: https://labs.everypixel.com/docs/index

Creates a lip sync task by uploading audio and video files. The API processes these files to generate a lip-synced video.

```APIDOC
## POST /v1/lipsync/create

### Description
Creates a lip sync task by uploading audio and video files. The API processes these files to generate a lip-synced video.

### Method
POST

### Endpoint
https://api.everypixel.com/v1/lipsync/create

### Parameters
#### Form Data Parameters
- **audio** (file) - Required - The audio file to use for lip syncing.
- **video** (file) - Required - The video file to use for lip syncing.
- **title** (string, optional) - Sets the name for the output file; if omitted, a default name will be used.
- **callback** (URL, optional) - If set, the API will POST the result to this URL when processing is complete — use instead of manual status polling.

### Request Example
```python
import requests
from pathlib import Path

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
audio_path = Path('folder/example.wav')
video_path = Path('folder/example.mp4')
audio_file = open(audio_path, 'rb')
video_file = open(video_path, 'rb')

response = requests.post(
    url="https://api.everypixel.com/v1/lipsync/create",
    files={'audio': (audio_path.name, audio_file)},
    data={
        "title": "<my_video: str>",    # OPTIONAL, default=task_id, affects the file name
        "callback": "<url: str>"         # OPTIONAL, default=None, see the callback section
    },
    auth=(client_id, client_secret)
)
audio_file.close()
video_file.close()
```

### Response
#### Success Response (201)
- **task_id** (string) - ID of the created lip sync task.
- **status** (string) - Initial status (`PENDING` or `STARTED`).
- **queue** (integer) - Position in queue (if any).
- **result** (string) - Will contain the output video URL once the task is finished (initially empty or placeholder).

#### Response Example
```json
{
  "task_id": "uuid",
  "status": "PENDING",
  "queue": 1,
  "result": ""
}
```
```

--------------------------------

### JSON Error Response Format

Source: https://labs.everypixel.com/docs/index

Describes the structure of JSON error responses and provides an example.

```APIDOC
## JSON Error Response

If an error occurs and the API is able to return a response, it will typically be a JSON object containing:

* `status`: `"error"`
* `message`: A descriptive error message indicating what went wrong.

### Request Example

```json
{
  "status": "error",
  "message": "Threshold must be float."
}
```
```

--------------------------------

### POST /v1/videoswap/create

Source: https://labs.everypixel.com/docs/index

Creates a face swap task by processing a source face image and a target video. This is an asynchronous operation.

```APIDOC
## POST /v1/videoswap/create

### Description
Creates a face swap task by processing a source face image and a target video. This is an asynchronous operation.

### Method
POST

### Endpoint
/v1/videoswap/create

### Parameters
#### Query Parameters
- **source_url** (URL) - Optional - URL of the face image to be inserted.
- **target_url** (URL) - Optional - URL of the target video where the face will appear.
- **title** (string) - Optional - Sets the name for the output file; if omitted, a default name will be used.
- **callback** (URL) - Optional - If set, the API will POST the result to this URL when processing is complete.

#### Request Body
- **source** (file) - Required (if not using `source_url`) - The source image file (the “donor” face).
- **target** (file) - Required (if not using `target_url`) - The target video file (the “double”) that will receive the new face.
- **use_gfpgan** (boolean) - Optional, default `false` - If `true`, enable an extra face enhancement step (using GFPGAN) after the swap.
- **title** (string) - Optional - Sets the name for the output file; if omitted, a default name will be used.
- **callback** (URL) - Optional - If set, the API will POST the result to this URL when processing is complete.

### Request Example
```python
import requests
from pathlib import Path

client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
source_path = Path('folder/source.png')
target_path = Path('folder/target.mp4')
source_file = open(source_path, 'rb')
target_file = open(target_path, 'rb')

response = requests.post(
    url= "https://api.everypixel.com/v1/videoswap/create",
    files={'source': (source_path.name, source_file)},
    data={
        "target_url": "<url_to_target_video>",
        "use_gfpgan": False,
        "title": "my_video_swap",
        "callback": "<url_for_callback>"
    },
    auth=(client_id, client_secret)
)
source_file.close()
target_file.close()

# Save task_id to check the status
task_id = response.json().get("task_id")
```

### Response
#### Success Response (201)
- **task_id** (string) - ID of the created face swap task.
- **status** (string) - Initial status (`PENDING` or `STARTED`).
- **queue** (integer) - Position in queue (if any).
- **result** (string) - Will be available as a video file (typically a URL to a MP4/MPEG).

#### Response Example
```json
{
  "task_id": "uuid",
  "status": "PENDING",
  "queue": 5,
  "result": null
}
```

### Optimization Tips
- **Head shape**: For best results, the double should have a similar head shape to the donor.
- **Hairstyle**: Hair and hairstyles are not transplanted.
- **Head turning**: If the double turns his or her head too much, the neural network may not be able to recognize the face and the image may not be processed.
- **Close-ups**: In close-up shots (where the face takes up more than 1/6 of the frame), more time is needed to detail features such as wrinkles and facial expressions.
- **Video resolution**: At very high resolutions (such as 4K), the face may appear blurred due to technical limitations.
- **Objects and accessories**: The face should not be obstructed by objects. Glasses, beards, and other accessories can affect the results.
- **Color matching**: The skin tones of the donor and the double should match closely to avoid unnatural color differences in the final result.
```

--------------------------------

### Analyze Image Quality using URL (PHP)

Source: https://labs.everypixel.com/docs/index

This PHP script shows how to perform an image quality analysis using the Everypixel API by providing an image URL. It utilizes cURL for the HTTP request and requires client ID and secret for authentication.

```php
<?php
$authorization = "<your-client-id>":"<your-client-secret>";
$url = "https://api.everypixel.com/v1/quality_ugc?url=http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg";

$curl = curl_init();
curl_setopt($curl, CURLOPT_USERPWD, $authorization);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
$data = curl_exec($curl);
curl_close($curl);

$json = json_decode($data);
print_r($json);
?>

```

--------------------------------

### Authentication Overview

Source: https://labs.everypixel.com/docs/index

All API calls require authentication using Basic HTTP authentication. You need to obtain your Client ID and Client Secret from your Everypixel Labs account dashboard.

```APIDOC
## Authentication

### Description
To use the Everypixel Labs API, you must authenticate your requests using your unique Client ID and Client Secret. These credentials are obtained from your Everypixel Labs account dashboard in the **API Keys** section. All API calls require authentication using **Basic HTTP authentication**.

### Method
Basic HTTP Authentication

### Parameters
- **Client ID**: Your unique identifier for API access.
- **Client Secret**: Your secret key associated with your Client ID.

### Usage
Credentials can be provided via an `Authorization` header or using your HTTP client's basic auth mechanism. For example, in cURL, use `--user "CLIENT_ID:CLIENT_SECRET"`. In code libraries, this is often handled by an `auth` parameter or by setting the `Authorization` header manually.

### Security
Keep your Client ID and Secret safe. Do not expose them in public client-side code or share them, as they grant access to your account’s API usage. Ensure all requests are made over HTTPS.
```

--------------------------------

### GET /v1/quality

Source: https://labs.everypixel.com/docs/index

Evaluates the quality and market potential of professional photographs from a stock photography perspective, focusing on technical aspects like brightness, contrast, and noise.

```APIDOC
## GET /v1/quality

### Description
Evaluates the quality and market potential of professional photographs from a stock photography perspective, focusing on technical aspects like brightness, contrast, and noise. This endpoint is not intended for historical photos, illustrations, or 3D visualizations. It processes images in under 1 second and can handle up to 30 requests per second.

### Method
GET

### Endpoint
https://api.everypixel.com/v1/quality

### Parameters
#### Query Parameters
- **url** (string) - Required - The URL of the image to analyze. The URL must be properly encoded.

### Request Example
```json
{
  "example": "curl --user \"<your-client-id>:<your-client-secret>\" \"https://api.everypixel.com/v1/quality?url=https://example.com/image.jpg\""
}
```

### Response
#### Success Response (200)
- The response structure for this endpoint is not detailed in the provided text, but it is expected to contain a quality score or related metrics.

#### Response Example
```json
{
  "example": "(Response structure not provided in the input text)"
}
```
```

--------------------------------

### Performance Considerations

Source: https://labs.everypixel.com/docs/index

Understand rate limits, concurrent processing, processing speed, and recommendations for image size and video length to optimize API usage.

```APIDOC
## Performance Considerations

### Requests per Second
- Most endpoints: Up to **30 requests per second**.
- Age Recognition endpoint: Up to **10 requests per second**.
- Exceeding limits results in an HTTP **502 Bad Gateway** error.

### Concurrent Processing
- Heavy operations (video processing, audio synthesis) are handled sequentially per account.
- Tasks are queued and executed one at a time for Text-to-Speech and Lipsync.

### Processing Speed
- Image-based analysis (keywording, quality, face detection, captioning): Typically fast (under a few seconds per image).
- Text-to-Speech: Real-time or faster (1 minute of audio processed in under 1 minute).
- Video processing (e.g., Text-to-Speech, Lipsync): Can take approximately 10 minutes per minute of video content.
- Video Face Swap: Computationally heavy, time proportional to video length.

### Image Size
- Algorithms resize images to around **300×300 pixels** internally.
- Providing larger images does not improve accuracy but increases processing time.
- **Recommendation**: Resize or compress images to around **300 pixels on the shortest side** before sending.

### Video Length
- **Video Keywording endpoint**: Recommended duration between **5 and 60 seconds**.
- Videos longer than 60 seconds may yield less relevant keywords.
- Very short videos (under 5 seconds) may lack sufficient content for analysis.
- **Upload size limit**: **100 MB** for video files on the Video Keywording endpoint.
```

--------------------------------

### API Versioning and Base URL

Source: https://labs.everypixel.com/docs/index

The Everypixel Labs API is versioned, and the version number is part of the URL. All examples use version 1. Ensure you include the correct version prefix in your requests.

```APIDOC
## API Versioning

### Description
The Everypixel Labs API is versioned, and the version number (e.g., `v1`) is included as part of the URL path for each endpoint. All examples in this documentation use version 1 of the API. Ensure that you include the correct version prefix in your requests.

### Base URL
`https://api.everypixel.com/v1`

### Example Endpoint
`/v1/keywords`
```

--------------------------------

### Create Text-to-Speech Task (Python)

Source: https://labs.everypixel.com/docs/index

Initiates a text-to-speech conversion task. Requires client ID and secret for authentication. Accepts voice, text, an optional title for the output file, and an optional callback URL for asynchronous notifications. Returns a task ID for status checking.

```python
client_id = '<your-client-id>'
client_secret = '<your-client-secret>'
response = requests.post(
    url="https://api.everypixel.com/v1/tts/create",
    data={"voice": "<voice: str>",
          "text": "<text to read: str>",
          "title": "<my_audio: str>",
          "callback": "url"  # OPTIONAL, default=None, see the callback section
          },
    auth=(client_id, client_secret)
)

# Save task_id to check the status
task_id = response.json().get("task_id")
```

--------------------------------

### Get Stock Photo Quality Score via URL (Curl)

Source: https://labs.everypixel.com/docs/index

This snippet demonstrates how to retrieve the quality score for a stock photo by providing its URL using a cURL command. It requires client ID and secret for authentication.

```curl
curl --user "<your-client-id>:<your-client-secret>" "https://api.everypixel.com/v1/quality?url=http://image.everypixel.com/2014.12/67439828186edc79b9be81a4dedea8b03c09a12825b_b.jpg"
```

--------------------------------

### Detect Faces using URL (cURL)

Source: https://labs.everypixel.com/docs/index

This snippet demonstrates how to detect faces in an image by providing its URL to the Everypixel API using cURL. It requires client credentials for authentication and returns a JSON object with face detection results.

```bash
curl --user "<your-client-id>:<your-client-secret>" "https://api.everypixel.com/v1/faces?url=https://labs.everypixel.com/static/i/estest_sample3.jpg"
```
Tokens:
Raw