Examples

import axios from 'axios';
import FormData from 'form-data';
import fs from 'fs';
import path from 'path';

const API_ENDPOINT = 'https://api.autocaption.io/v1'
const API_KEY = 'YOUR_API_KEY'

const videoName = 'video.mp4'
const videoLang = 'fr'
const videoPath = path.join('./', videoName);

const axiosInstance = axios.create({
baseURL: API_ENDPOINT
});

axiosInstance.defaults.headers.common['x-api-key'] = API_KEY;

const video = fs.createReadStream(videoPath);

// Get signed url to upload video
const getSignedUrlData = async () => {
return axiosInstance.get(`/signedUrl?file=${videoName}`).then(res => res.data);
}

// Upload video to signed url
const uploadVideo = async (url, fields) => {
const formData = new FormData();
for (const [key, value] of Object.entries(fields)) {
    formData.append(key, value);
}
formData.append('file', video);
await axios.post(url, formData, {
    headers: {
        'Content-Type': `multipart/form-data; boundary=${formData._boundary}`
    }
}).catch(err => console.log(err));
}

// Transcript video
const transcriptVideo = async (fileKey, lang) => {
return axiosInstance.post('/transcript', {
    input: fileKey,
    language: lang
}).then(res => res.data);
}

// Get transcript status
const getTranscriptStatus = async (jobId) => {
return axiosInstance.get(`/transcript/${jobId}`).then(res => res.data).catch(err => err.response.data);
}

// Get template by id
const getTemplateById = async (id) => {
return axiosInstance.get(`/templates/${id}`).then(res => res.data);
}

// Generate video
const generateVideo = async (file, config, words) => {
return axiosInstance.post('/generate', {
    input: file,
    config,
    words
}).then(res => res.data);
}

// Get fonts list
const getFontsList = async () => {
return axiosInstance.get(`/fonts?lang=${videoLang}`).then(res => res.data);
}

const main = async () => {
try {
    const { file, url, fields } = await getSignedUrlData();
    await uploadVideo(url, fields);
    console.log('file uploaded')
    const { job_id } = await transcriptVideo(file, videoLang);

    // Initial check without delay
    let transcriptResponse = await getTranscriptStatus(job_id);

    // Loop until the transcript is ready or an error occurs
    while (transcriptResponse.status !== 'COMPLETED') {
        if (transcriptResponse.status == 'FAILED') {
            throw new Error('Transcription failed'); // Throws an error to exit the loop and catch block
        }

        await new Promise(resolve => setTimeout(resolve, 5000)); // Wait for 5 seconds
        transcriptResponse = await getTranscriptStatus(job_id); // Update the response
    }

    console.log('Transcript ready');

    // Get the template DEFAULT
    const { config } = await getTemplateById('0');

    /* 
        - If the template doesn't have a font, get the list of fonts and use the first one
        /!\ Set a value to the config.font otherwise it will throw an error during the video generation
    */
    if (config.font == undefined) {
        const fonts = await getFontsList();
        config.font = fonts[0];
    }

    /* 
        - Instead of a custom template, the default templates don't have the sizes defined, so we need to define them.
        /!\ Set a value to the config.sizes.fontSize otherwise it will throw an error during the video generation
    */
    config.sizes = {
        fontSize: 56,
        strokeSize: 15,
        //...
    };

    // Generate the video and wait the download url - Can take a few minutes
    console.log('Generating video...');
    const { download_url } = await generateVideo(file, config, transcriptResponse.words);
    console.log(download_url);
} catch (error) {
    console.error("An error occurred:", error);
}
};

main();

import requests
from requests_toolbelt.multipart.encoder import MultipartEncoder
import os
import time

API_ENDPOINT = 'https://api.autocaption.io/v1'
API_KEY = 'YOUR_API_KEY'

video_name = 'video.mp4'
video_lang = 'fr'
video_path = os.path.join('./', video_name)

session = requests.Session()
session.headers.update({'x-api-key': API_KEY})

# Get signed url to upload video
def get_signed_url_data():
    return session.get(f'{API_ENDPOINT}/signedUrl?file={video_name}').json()

# Upload video to signed url
def upload_video(url, fields):
    with open(video_path, 'rb') as f:
        fields['file'] = (video_name, f, 'video/mp4')
        m = MultipartEncoder(fields=fields)
        response = requests.post(url, data=m, headers={'Content-Type': m.content_type})
        print(response.text)
        response.raise_for_status()

# Transcript video
def transcript_video(file_key, lang):
    return session.post(f'{API_ENDPOINT}/transcript', json={
        'input': file_key,
        'language': lang
    }).json()

# Get transcript status
def get_transcript_status(job_id):
    try:
        return session.get(f'{API_ENDPOINT}/transcript/{job_id}').json()
    except requests.exceptions.RequestException as e:
        return e.response.json()

# Get template by id
def get_template_by_id(id):
    return session.get(f'{API_ENDPOINT}/templates/{id}').json()

# Generate video
def generate_video(file, config, words):
    return session.post(f'{API_ENDPOINT}/generate', json={
        'input': file,
        'config': config,
        'words': words
    }).json()

# Get fonts list
def get_fonts_list():
    return session.get(f'{API_ENDPOINT}/fonts?lang={video_lang}').json()

def main():
    try:
        signed_url_data = get_signed_url_data()
        file = signed_url_data['file']
        url = signed_url_data['url']
        fields = signed_url_data['fields']
        upload_video(url, fields)
        print('file uploaded ' + file)
        transcript_response = transcript_video(file, video_lang)
        job_id = transcript_response['job_id']

        # Initial check without delay
        transcript_status = get_transcript_status(job_id)

        # Loop until the transcript is ready or an error occurs
        while 'status' not in transcript_status or transcript_status['status'] != 'COMPLETED':
            if 'status' in transcript_status and transcript_status['status'] == 'FAILED':
                raise Exception('Transcription failed')  # Throws an error to exit the loop and catch block
            time.sleep(5)  # Wait for 5 seconds
            transcript_status = get_transcript_status(job_id)  # Update the response

        print('Transcript ready')

        # Get the template DEFAULT
        template_response = get_template_by_id('0')
        config = template_response['config']

        # If the template doesn't have a font, get the list of fonts and use the first one
        if 'font' not in config:
            fonts = get_fonts_list()
            config['font'] = fonts[0]

        # Set values for config.sizes
        config['sizes'] = {
            'fontSize': 56,
            'strokeSize': 15,
            #...
        }

        # Generate the video and wait the download url - Can take a few minutes
        print('Generating video...')
        video_generation_response = generate_video(file, config, transcript_status['words'])
        download_url = video_generation_response['download_url']
        print(download_url)
    except Exception as error:
        print("An error occurred:", error)

if __name__ == '__main__':
    main()