API documentation

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.default("adorable pig")
result.save("adorable-pig.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/",
    headers={"Api-Key": "your-api-key"},
    json={"prompt": "adorable pig"},
)

if r.ok:
    with Path("adorable-pig.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.default('adorable pig')
    await result.save('adorable-pig.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"prompt": "adorable pig"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'adorable-pig.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->default('adorable pig');
$result->save('adorable-pig.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'prompt' => 'adorable pig',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('adorable-pig.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.default("adorable pig", None, None).await.unwrap();
    result.save("adorable-pig.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"prompt": "adorable pig"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("adorable-pig.jpeg", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.xl("sunbathing pig")
result.save("sunbathing-pig.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/xl",
    headers={"Api-Key": "your-api-key"},
    json={"prompt": "happy sunbathing pig, resting"},
)

if r.ok:
    with Path("sunbathing-pig.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.xl('sunbathing pig')
    await result.save('sunbathing-pig.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/xl', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"prompt": "happy sunbathing pig, resting"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'sunbathing-pig.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->xl('sunbathing pig');
$result->save('sunbathing-pig.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/xl');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'prompt' => 'happy sunbathing pig, resting',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('sunbathing-pig.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.xl("sunbathing pig", None, None).await.unwrap();
    result.save("sunbathing-pig.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/xl")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"prompt": "happy sunbathing pig, resting"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("sunbathing-pig.jpeg", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.flux("space captain pig")
result.save("space-captain-pig.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/flux",
    headers={"Api-Key": "your-api-key"},
    json={"prompt": "a pig as a pilot of a cosmic ship, floating in a space"},
)

if r.ok:
    with Path("space-captain-pig.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.flux('space captain pig')
    await result.save('space-captain-pig.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/flux', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"prompt": "a pig as a pilot of a cosmic ship, floating in a space"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'space-captain-pig.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->flux('space captain pig');
$result->save('space-captain-pig.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/flux');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'prompt' => 'a pig as a pilot of a cosmic ship, floating in a space',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('space-captain-pig.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.flux("space captain pig", None, None).await.unwrap();
    result.save("space-captain-pig.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/flux")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"prompt": "a pig as a pilot of a cosmic ship, floating in a space"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("space-captain-pig.jpeg", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.faceswap("https://imagepig.com/static/jane.jpeg", "https://imagepig.com/static/mona-lisa.jpeg")
result.save("jane-lisa.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/faceswap",
    headers={"Api-Key": "your-api-key"},
    json={"source_image_url": "https://imagepig.com/static/jane.jpeg", "target_image_url": "https://imagepig.com/static/mona-lisa.jpeg"},
)

if r.ok:
    with Path("jane-lisa.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.faceswap('https://imagepig.com/static/jane.jpeg', 'https://imagepig.com/static/mona-lisa.jpeg')
    await result.save('jane-lisa.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/faceswap', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"source_image_url": "https://imagepig.com/static/jane.jpeg", "target_image_url": "https://imagepig.com/static/mona-lisa.jpeg"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'jane-lisa.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->faceswap('https://imagepig.com/static/jane.jpeg', 'https://imagepig.com/static/mona-lisa.jpeg');
$result->save('jane-lisa.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/faceswap');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'source_image_url' => 'https://imagepig.com/static/jane.jpeg',
    'target_image_url' => 'https://imagepig.com/static/mona-lisa.jpeg',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('jane-lisa.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.faceswap("https://imagepig.com/static/jane.jpeg", "https://imagepig.com/static/mona-lisa.jpeg", None).await.unwrap();
    result.save("jane-lisa.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/faceswap")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"source_image_url": "https://imagepig.com/static/jane.jpeg", "target_image_url": "https://imagepig.com/static/mona-lisa.jpeg"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("jane-lisa.jpeg", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.cutout("https://imagepig.com/static/street.jpeg")
result.save("cutout.png")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/cutout",
    headers={"Api-Key": "your-api-key"},
    json={"image_url": "https://imagepig.com/static/street.jpeg"},
)

if r.ok:
    with Path("cutout.png").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.cutout('https://imagepig.com/static/street.jpeg')
    await result.save('cutout.png');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/cutout', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"image_url": "https://imagepig.com/static/street.jpeg"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'cutout.png',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->cutout('https://imagepig.com/static/street.jpeg');
$result->save('cutout.png');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/cutout');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'image_url' => 'https://imagepig.com/static/street.jpeg',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('cutout.png', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.cutout("https://imagepig.com/static/street.jpeg", None).await.unwrap();
    result.save("cutout.png").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/cutout")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"image_url": "https://imagepig.com/static/street.jpeg"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("cutout.png", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.upscale("https://imagepig.com/static/jane-lowres.jpeg")
result.save("jane-upscaled.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/upscale",
    headers={"Api-Key": "your-api-key"},
    json={"image_url": "https://imagepig.com/static/jane-lowres.jpeg"},
)

if r.ok:
    with Path("jane-upscaled.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.upscale('https://imagepig.com/static/jane-lowres.jpeg')
    await result.save('jane-upscaled.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/upscale', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"image_url": "https://imagepig.com/static/jane-lowres.jpeg"})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'jane-upscaled.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->upscale('https://imagepig.com/static/jane-lowres.jpeg');
$result->save('jane-upscaled.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/upscale');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'image_url' => 'https://imagepig.com/static/jane-lowres.jpeg',
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('jane-upscaled.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.upscale("https://imagepig.com/static/jane-lowres.jpeg", None, None).await.unwrap();
    result.save("jane-upscaled.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/upscale")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"image_url": "https://imagepig.com/static/jane-lowres.jpeg"}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("jane-upscaled.jpeg", content).unwrap();

    Ok(())
}

For Python, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the pip package manager:

pip install imagepig

Then, use this package to call the API:

from imagepig import ImagePig

imagepig = ImagePig("your-api-key")
result = imagepig.outpaint("https://imagepig.com/static/jane.jpeg", 0, 0, 500)
result.save("jane-in-a-dress.jpeg")

And that is all you need to do. Only one import and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the requests library to get our generated image from Image Pig:

from base64 import b64decode
from pathlib import Path

import requests

r = requests.post(
    "https://api.imagepig.com/outpaint",
    headers={"Api-Key": "your-api-key"},
    json={"image_url": "https://imagepig.com/static/jane.jpeg", "prompt": "dress", "bottom": 500},
)

if r.ok:
    with Path("jane-in-a-dress.jpeg").open("wb") as f:
        f.write(b64decode(r.json()["image_data"]))
else:
    r.raise_for_status()

For JavaScript (or TypeScript, if your project allows JavaScript modules) based on Node.js, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the npm package manager:

npm i imagepig

Then, use this package to call the API:

const ImagePig = require('imagepig');

void async function() {
    const imagepig = ImagePig('your-api-key');
    const result = await imagepig.outpaint('https://imagepig.com/static/jane.jpeg', 0, 0, 500)
    await result.save('jane-in-a-dress.jpeg');
}();

And that is all you need to do.

Alternatively, if you prefer to write the code for accessing the API by yourself, you can retrieve the generated image using the Fetch API and create a file with Node.js's fs and Buffer modules.

const fs = require('node:fs');
const { Buffer } = require('node:buffer');

void async function() {
    try {
        response = await fetch('https://api.imagepig.com/outpaint', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Api-Key': 'your-api-key'
            },
            body: JSON.stringify({"image_url": "https://imagepig.com/static/jane.jpeg", "prompt": "dress", "bottom": 500})
        });

        if (!response.ok) {
            throw new Error(`Response status: ${response.status}`);
        }

        json = await response.json();
        const buffer = Buffer.from(json.image_data, 'base64');

        fs.writeFile(
            'jane-in-a-dress.jpeg',
            buffer,
            (error) => {
                if (error) {
                    throw error;
                }
            }
        );
    } catch (error) {
        console.error(error);
    }
}();

For PHP, we provide a convenient imagepig package that you can use to easily access the API.

First, install it using the composer dependency manager:

composer require doubleplus/imagepig

Then, use this package to call the API:

<?php

$imagepig = ImagePig\ImagePig('your-api-key');
$result = $imagepig->outpaint('https://imagepig.com/static/jane.jpeg', 0, 0, 500);
$result->save('jane-in-a-dress.jpeg');

And that is all you need to do. Only the opening tag and three lines of code!

Alternatively, if you prefer to write the code for accessing the API by yourself, you can use the cURL library to get the generated image from Image Pig.

<?php

$ch = curl_init('https://api.imagepig.com/outpaint');

curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'Api-Key: your-api-key',
]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'image_url' => 'https://imagepig.com/static/jane.jpeg',
    'prompt' => 'dress',
    'bottom' => 500,
]));

$response = curl_exec($ch);

if (curl_errno($ch)) {
    exit('Error: ' . curl_error($ch));
}

$handle = fopen('jane-in-a-dress.jpeg', 'wb');
fwrite($handle, base64_decode(json_decode($response, true)['image_data']));
fclose($handle);

For Rust, we provide a convenient imagepig crate that you can use to easily access the API.

First, install it using the cargo package manager:

cargo add imagepig

For this particular example, you will also need to install tokio be able to run asynchronous code inside the main function:

cargo add tokio -F rt-multi-thread -F macros

Then, use the installed imagepig crate to call the API:

use imagepig::ImagePig;

#[tokio::main]
async fn main() -> Result<(), imagepig::ImagePigError> {
    let imagepig = ImagePig::new("your-api-key".to_string(), None);
    let result = imagepig.outpaint("https://imagepig.com/static/jane.jpeg", None, None, Some(500), None, None, None).await.unwrap();
    result.save("jane-in-a-dress.jpeg").await?;

    Ok(())
}

And that is all you need to do.

To implement the API access by yourself, you need to install some dependencies using cargo first:

cargo add base64
cargo add reqwest -F json
cargo add serde -F derive
cargo add tokio -F rt-multi-thread -F macros

Then, you are able to run it using the cargo run command.

use base64::Engine;

#[derive(serde::Deserialize)]
struct ImagePigResponse {
    image_data: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
    let response = client.post("https://api.imagepig.com/outpaint")
        .header("Content-Type", "application/json")
        .header("Api-Key", "your-api-key")
        .body(r#"{"image_url": "https://imagepig.com/static/jane.jpeg", "prompt": "dress", "bottom": 500}"#)
        .send()
        .await?;

    response.error_for_status_ref()?;

    let json = response.json::<ImagePigResponse>().await?;
    let content = base64::prelude::BASE64_STANDARD.decode(json.image_data)?;

    std::fs::write("jane-in-a-dress.jpeg", content).unwrap();

    Ok(())
}