Image

Exploring the Try it on's API Capabilities¶

In this tutorial, we'll guide you through using the Try it on API to train models and generate headshots.

The steps for getting this going are:

  1. Test your API Key
  2. Purchase a model.
  3. Fetch the model
  4. Choose the image styles
  5. Upload close-ups of the subject
  6. Train the model
  7. Use any AI edits

At the end of the tutorial, we'll show you how to use the image edits as well on your own images.

In [12]:
import io
import os
import json
import requests
from PIL import Image

from dotenv import load_dotenv

load_dotenv("../")
API_ROOT = "https://studio.tryitonai.com"

1. Test your API Key¶

In [13]:
headers = {"x-tryiton-key": os.environ["TRYITON_API_KEY"]}
url = f"{API_ROOT}/api/key/user-data"
response = requests.get(url, headers=headers)
user = json.loads(response.text)
user
Out[13]:
{'userId': '6688ffad-f6ab-4bd4-9e69-2870b5bf78ea',
 'name': 'Nate',
 'lastName': None,
 'email': 'nlandmanc@gmail.com',
 'credits': 13147,
 'createdAt': '2023-06-21T11:46:02.423961+00:00',
 'creativeStudioSubscriptionStatus': 'active'}

2. Purchase a model¶

The next step is to purchase a model! You can purchase it on our website: studio.tryitonai.com. You can purchase either individual models or bulk models using the Team Package.

Please contact us if you have any questions: team@tryitonai.com.

3. Fetch the model to train¶

In [14]:
url = f"{API_ROOT}/api/key/get-models"
response = requests.get(url, headers=headers)
models = json.loads(response.text)

models[-1]
Out[14]:
{'id': 24,
 'createdAt': '2023-10-04T18:26:24.081745+00:00',
 'gender': 'man',
 'productName': 'AI Headshots',
 'isTrained': False,
 'email': 'nlandmanc@gmail.com',
 'isUsed': True,
 'modelName': 'Hollywood Casting Pics',
 'deletedAt': '2023-12-23T20:33:24',
 'customizations': 'brown hair',
 'projectId': None,
 'images_to_gen': 20}

4. Choose the image styles¶

Or email us if you'd like some added: team@tryitonai.com.

In [15]:
import requests

url = f"{API_ROOT}/api/key/get-styles"

payload = {"gender": "man"}  # or "woman"
json_headers = headers.copy()
json_headers["Content-Type"] = "application/json"


response = requests.get(url, payload, headers=headers)
styles = json.loads(response.text)
In [27]:
keys = list(styles.keys())
print(f"Available styles for {payload['gender']}:\n")
for i in range(0, len(keys), 10):  # Print 4 keys per line
    print(", ".join(keys[i : i + 10]))

Available styles for man:

sporty, casual outdoors, casual studio, business studio, business outdoors, color pop, timeless, dating, business office, hollywood
neon lights, semi casual studio, streetstyle, real estate
In [35]:
styles.get("casual studio")[0]
Out[35]:
{'url': 'https://pics.tryitonai.com/styles%2Fman%2Fcasual%20studio%2Feb02d28a-7638-4ec7-b0b2-98a66907b76d.png?Expires=1743068103&Key-Pair-Id=K1CVI41MJ72Z7W&Signature=GM8mp1Jj1gjuZoH-NGoJQ5O5hN8FIxvmDW-oqenIIssBeN2spwD4UJUzIW8Hqe4Gk~8H65mzL-VHcT9T2ZpM8~bdQthNnOgZEYWTEx3ssGJbC455Pnya7V5yGAu-nd6VEOGAzgMSApmY8HRmyWx6lcrS8qP-o3fThziRyS-Z9bhAHJ8oColhZRnzqYXfiKSmjKJDN7nH43oifnXTO~8hgzSLhZG6bcKlDvIAZ~e~zhFIuYwv9Udw093dbVtYt-ZCY2Hxb~7ivFgD8DMrJazbtmDvYaqi7qk2D--IbhTH-FLObnHHBRuD~bq9LnGJHe93RpoomdEkMD7XQ3H3h2opdQ__',
 'id': '9e253238-4143-41e5-936b-0203182ab081',
 'category': 'casual studio',
 'lastModified': '2025-03-18T11:24:42.778151+00:00',
 'type': 'active',
 'name': 'a man, captivating gaze, leaning forward, professional actor headshot style. Direct eye contact with camera, subtle confident smile. Clean studio lighting highlighting defined jawline. Wearing classic dark button-up shirt. Professional, approachable yet alluring expression.'}
In [66]:
def load_image_from_url(url, max_size=300):
    response = requests.get(url)
    response.raise_for_status()
    image = Image.open(io.BytesIO(response.content))
    if not max_size:
        return image
    if image.width > image.height:
        ratio = max_size / image.width
        new_size = (max_size, int(image.height * ratio))
    else:
        ratio = max_size / image.height
        new_size = (int(image.width * ratio), max_size)
    return image.resize(new_size)
In [9]:
# Do note that this url corresponds to the thumbnail, so the size is smaller than the 640x640 you'll get when using the image as reference.

real_estate_style = styles["business studio"][0]["url"]
load_image_from_url(real_estate_style)
Out[9]:
No description has been provided for this image
In [10]:
sporty_style = styles["sporty"][1]["url"]
load_image_from_url(sporty_style)
Out[10]:
No description has been provided for this image

You can also upload your own image if you'd like to use it to generate headshots¶

Note that you should make sure to crop the image to a max size of 1024!

5. Get the subject's close-ups in order and upload them to Try it on's servers.¶

To start with, have your users gather 7-20 images for training.

In [16]:
import io
import base64


def image_to_base64(image, format="PNG"):
    buffered = io.BytesIO()
    image.save(buffered, format=format)
    img_str = base64.b64encode(buffered.getvalue()).decode()
    return img_str


def base64_to_image(data, format="PNG"):
    image_bytes = base64.b64decode(data)
    return Image.open(io.BytesIO(image_bytes))

You can use our validate-fine-tuning-image endpoint to validate the image before uploading it. If the image is good, it will return a "success" status. Otherwise, it will return an error message.

Note that the input images will be padded to be squares, so make sure your users upload square images only.

In [17]:
def validate_image(image):
    url = f"{API_ROOT}/api/key/validate-fine-tuning-image"
    payload = {"base64": image_to_base64(image), "height": image.height, "width": image.width}
    response = requests.post(url, json=payload, headers=headers)
    return json.loads(response.text)
In [11]:
# Thank you, Unsplash! Find this image here: https://unsplash.com/photos/man-standing-beside-wall-pAtA8xe_iVM
image = load_image_from_url(
    "https://images.unsplash.com/photo-1560250097-0b93528c311a?q=80&w=987&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D"
)
image
Out[11]:
No description has been provided for this image
In [63]:
validate_image(image)
Out[63]:
{'status': 'success', 'message': 'good_headshot'}

Conversely, if the image is not good, it will return the coordinates you should use to crop the image.

If the image is not good, the status will be "warning" and the message will be the issue we find with the image - it'll be something like "many people in the image" or "image is too dark".

In [64]:
image = load_image_from_url(
    "https://t4.ftcdn.net/jpg/06/26/95/63/360_F_626956301_XbKQ0erohdI9NnrDXmBrN4xW27zLdtyU.jpg"
)
image
Out[64]:
No description has been provided for this image
In [66]:
validate_image(image)
Out[66]:
{'status': 'success',
 'message': 'good_headshot',
 'crop': {'x': 119, 'y': 0, 'height': 400, 'width': 400}}

Finally, after you've checked the images and they all pass our validator, upload them to our servers.

Make sure uploaded images are larger than 400x400 pixels and smaller than 1024x1024 pixels. Otherwise, we will reject them.¶

In the back-end, we will pad the images to be squares and resize them to 1024x1024 pixels anyways, so you can upload non-square images.

In [18]:
def upload(url, payload):
    try:
        response = requests.put(url, json=payload, headers=json_headers)
        return json.loads(response.text)
    except Exception as e:
        print(e)
        print(response.text)
        if "Body exceeded 1mb limit" == response.text:
            print("Reducing the size and trying again....")
            return upload_image(base64_to_image(payload["base64"]).resize((500, 500)).resize((640, 640)))
        raise


def upload_image(pil_image, model_id):
    url = f"{API_ROOT}/api/key/upload-fine-tuning-image"
    payload = {
        "base64": image_to_base64(pil_image),
        "type": "png",
        "modelId": model_id,
    }
    return upload(url, payload)
In [19]:
image = load_image_from_url(
    "https://images.unsplash.com/photo-1560250097-0b93528c311a?q=80&w=987&auto=format&fit=crop&ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D",
    max_size=1024,
)
In [ ]:
# It returns an imageUrl. While you won't need it, you can use it to show it to your users.
uploaded = upload_image(image, model_id=models[-1]["id"])
Out[ ]:
{'imageUrl': 'https://pics.tryitonai.com/nlandmanc%40gmail.com%2F24%2Fuploaded_pics%2Ffce0bd50-3b4c-48b9-abb6-6cc8a8b6d0db.png?Expires=1743344329&Key-Pair-Id=K1CVI41MJ72Z7W&Signature=Pk1-YnzBwGmQhH6XKmAWxciJZvYUOjQeBfSFfleO8YPah0Th0T2LTN6BVauhZWSveL-5TKkX5-AbBgtv5YrnqJ9b8Q7i-uPoEKzK1tE-kJPvS83ojMBfCnbP6z47um8H5ElNidhIj~aAnijIm8emhkNJa9-z~S~NKf0abD0XQj4zyKJL8dzuOkMAjeXLoKcSY74moatnx6g~SVX6ZUDAOn8WYHNw8-CLqdcpunaqoMQWjrDLBx2KvsbB6kpSt5RoIkrlxyvcHq~hgnhFcjUWZLfK19Ezy9wxt48sXeW-BkeAVMT~xam7aqc811mZk9is7kN-DA1P0LgWFlCJl6H45g__'}
In [ ]:
load_image_from_url(uploaded["imageUrl"])
Out[ ]:
No description has been provided for this image

If you forget, you can always get a list of uploaded pics

In [108]:
url = f"{API_ROOT}/api/key/get-fine-tuning-images"
payload = {"modelId": models[-1]["id"]}
response = requests.get(url, params=payload, headers=json_headers)
images_uploaded = json.loads(response.text)
images_uploaded
Out[108]:
[{'id': 'fc2eeef8-d0da-45dc-9831-ec8c365c9a47',
  'imageUrl': 'https://pics.tryitonai.com/nlandmanc%40gmail.com%2F24%2Fuploaded_pics%2Ffc2eeef8-d0da-45dc-9831-ec8c365c9a47.png?Expires=1743073473&Key-Pair-Id=K1CVI41MJ72Z7W&Signature=no5ZUJR1baRHpJMdChqL8gIixfZaldQfjNT60~IAEhFghF53PmFpLoxSDNcdj4GFXz3jPdkw2ILnpS0KBNAgST6L3e29TIo0~JG-MbgsgxT3sLbV-p7Jms7EzrSi92pqF~6jYqHKC-a44Bhx7teNNFuFm6N7c~JvaN7B3YCvDU3oqPlpao5fI-VwTnYnA5tggAqyOL0IaF6AYKMeN~O21cbIWRTms9miCNZps~--UfdJZ9n1gNU9onIeNiAEvPVnLAkWijgShjLa3E8X0FVTyxLhPayBIK7wvxaB2aLgMWNRoXZLFORWzpAIjzOBm~Gn1Fbd70GtbGUmlg9y6D9L7A__'}]

Then, if you want to delete an image, you can use the delete-fine-tuning-image endpoint.

In [105]:
images_uploaded[0]["id"], models[-1]["id"]
Out[105]:
('fc2eeef8-d0da-45dc-9831-ec8c365c9a47', 24)
In [116]:
url = f"{API_ROOT}/api/key/delete-fine-tuning-image"
payload = {"imageId": images_uploaded[0]["id"], "modelId": models[-1]["id"]}
response = requests.delete(url, params=payload, headers=json_headers)
json.loads(response.text)
Out[116]:
{}
In [117]:
url = f"{API_ROOT}/api/key/get-fine-tuning-images"
payload = {"modelId": models[-1]["id"]}
response = requests.get(url, params=payload, headers=json_headers)
images_uploaded = json.loads(response.text)
images_uploaded
Out[117]:
[]
In [76]:
import matplotlib.pyplot as plt


def plot_side_by_side(imgs_and_titles, title=None, max_per_row=3, notebook_width=18):
    # Calculate number of rows and the figure size
    num_imgs = len(imgs_and_titles)
    max_per_row = min(num_imgs, max_per_row)
    num_rows = (num_imgs + max_per_row - 1) // max_per_row

    # Assuming images are square, adjust height relative to width
    img_aspect_ratio = 1  # Set to the aspect ratio of your images (height / width)
    row_height = notebook_width / max_per_row * img_aspect_ratio
    fig_size = (notebook_width, row_height * num_rows)

    fig, axs = plt.subplots(num_rows, max_per_row, figsize=fig_size, squeeze=False)
    if title:
        plt.suptitle(title)

    # Set padding between images in one row
    pad = 5  # 5 pixels
    fig.subplots_adjust(wspace=pad / fig.dpi)

    # Iterate through images and plot them
    for i, img_assets in enumerate(imgs_and_titles):
        row = i // max_per_row
        col = i % max_per_row

        if type(img_assets) == list or type(img_assets) == tuple:
            img = img_assets[0]
            img_title = img_assets[1][:25]
            axs[row, col].set_title(img_title)
        else:
            img = img_assets

        axs[row, col].imshow(img, cmap="gray")
        axs[row, col].axis("off")  # Hide axes

    # Hide any unused axes
    for i in range(num_imgs, num_rows * max_per_row):
        row = i // max_per_row
        col = i % max_per_row
        axs[row, col].axis("off")

    # Show the plot
    plt.show()
In [80]:
import os

images = [i for i in os.listdir("uploads") if i.endswith(".png") or i.endswith(".jpeg")]
plot_side_by_side([Image.open("uploads/" + i) for i in images])
No description has been provided for this image
In [ ]:
my_beautiful_images = ["...", ...]
[upload_image(image, model_id=models[-1]["id"]) for image in my_beautiful_images]

6. Train the model¶

In [15]:
# Grab the style image ids and image urls
style_image_ids = [style_image["id"] for style_image in styles["business studio"]]
print(f"Using {len(style_image_ids)} style images for generation.")

Using 11 style images for generation.

The model has a specific number of headshots available for generation. You can upload more than that number in terms of styles, but some won't be generated.

In [13]:
print("Available images for this photoshoot - ", models[-1]["images_to_gen"])

Available images for this photoshoot -  20
In [16]:
payload = {
    "modelId": models[-1]["id"],
    "gender": "man",
    "styleImageIds": style_image_ids,
    "customizations": "brown hair",  # You can leave this as an empty string too.
}
payload
Out[16]:
{'modelId': 24,
 'gender': 'man',
 'styleImageIds': ['d0fce35e-fff1-cbe6-e130-1f2601e029b9',
  '8cc514f4-5ced-6e21-857b-b8e19362d26b',
  '8bc81c2a-d363-ff3d-7a28-f1f7885b5cea',
  'e61380c2-9d82-1419-b69a-371277e902ec',
  '440b2acf-5fc5-9060-96da-cf2c56c8992e',
  '082b4866-f001-81d9-858d-9d0807a49c27',
  'e6db2a30-050c-a68f-d886-1dea1d7d337f',
  '413e2db2-f00f-4874-93b8-d7b8b7d673d8',
  'a59cec27-311b-3818-cb66-cbed9f050fa3',
  '3baae1ab-c5ac-b2b1-9ec4-259e7d9172b7',
  '2cf18f1c-abb5-4cac-ae99-3c7690290398'],
 'customizations': 'brown hair'}
In [37]:
url = f"{API_ROOT}/api/key/train-model"
response = requests.post(url, json=payload, headers=json_headers)
print(response)

<Response [200]>
In [38]:
url = f"{API_ROOT}/api/key/get-models"
response = requests.get(url, headers=headers)
model = json.loads(response.text)
In [39]:
print("Training started: ", model[-1]["isUsed"])
print("Training finished: ", model[-1]["isTrained"])

Training started:  True
Training finished:  False

NOTE:¶

We currently only send you an e-mail when the training is done. Takes about 30 minutes. If you'd like to send us a webhook for us to hit when the training is done, please let us know :)

In [121]:
## 30 minutes later...
print("Training finished: ", models[-1]["isTrained"])

Training finished:  True

Moment of Truth!¶

In [59]:
url = f"{API_ROOT}/api/key/get-model-results"
payload = {"modelId": models[-1]["id"]}
response = requests.get(url, params=payload, headers=headers)
results = json.loads(response.text)
images = results["images"]
In [63]:
load_image_from_url(images[3]["signedUrl"])
Out[63]:
No description has been provided for this image

7. AI Image Edits¶

In [64]:
url = f"{API_ROOT}/api/key/upscale"
payload = {"modelId": models[-1]["id"], "imageUrl": images[3]["signedUrl"]}

response = requests.post(url, payload, headers=headers)

upscaled_image = json.loads(response.text)
In [68]:
## Note that the imageUrl is temporary (1 day), so you should download it as soon as possible.
upscaled_image["imageUrl"]
Out[68]:
'https://pics.tryitonai.com/tmp%2Fc3151f45-e5f5-41cf-b3c6-1fc6ef1895bapng?Expires=1743495480&Key-Pair-Id=K1CVI41MJ72Z7W&Signature=FSbZ9Zl1cKqvdnmhc2G-w3nTLgXxAF1TXNEuMhwGRm5qLbOtws8WAiRHQXPWO7O0UFz26lF0D2RmkbC-yBw5QLHwucHwWR67qdzU4lAfetCvsQdf-M2Doetr4PiQOmOWlce9141laWfhYDarpg9JVPRrwudzE-E0cPA82aiIlfpcqD6zJDsA9HT4HxAFGVWNGjjsSyDbaYCCwK7Gm2ST6jCmu4CFcqDwhn5UoZ2d0Y2fl5sBIGRpFLFYNF7fWxfvVdMW3bG7ICvh4v~Qf8Tl-R4Z~pyVw5NqA7ltWMQDKts-NEFjLVNZQqpuBRPvq8C2RPFTIjmR3mLIDpFqTevbBg__'
In [67]:
load_image_from_url(upscaled_image["imageUrl"], max_size=1024)
Out[67]:
No description has been provided for this image
In [ ]: