Sora-2 - Text To Video

curl --location 'https://gptproto.com/v1/videos' \
--header 'Authorization: GPTPROTO_API_KEY' \
--form 'model="sora-2"' \
--form 'prompt="Put a hat on the cat"'

const axios = require('axios');
const FormData = require('form-data');
let data = new FormData();
data.append('model', 'sora-2');
data.append('prompt', 'Put a hat on the cat');

let config = {
  method: 'post',
  maxBodyLength: Infinity,
  url: 'https://gptproto.com/v1/videos',
  headers: { 
    'Authorization': 'GPTPROTO_API_KEY', 
    ...data.getHeaders()
  },
  data : data
};

axios.request(config)
.then((response) => {
  console.log(JSON.stringify(response.data));
})
.catch((error) => {
  console.log(error);
});

import http.client
import mimetypes
from codecs import encode

conn = http.client.HTTPSConnection("gptproto.com")
dataList = []
boundary = 'wL36Yn8afVp8Ag7AmP8qZ0SA4n1v9T'
dataList.append(encode('--' + boundary))
dataList.append(encode('Content-Disposition: form-data; name=model;'))

dataList.append(encode('Content-Type: {}'.format('text/plain')))
dataList.append(encode(''))

dataList.append(encode("sora-2"))
dataList.append(encode('--' + boundary))
dataList.append(encode('Content-Disposition: form-data; name=prompt;'))

dataList.append(encode('Content-Type: {}'.format('text/plain')))
dataList.append(encode(''))

dataList.append(encode("Put a hat on the cat"))
dataList.append(encode('--'+boundary+'--'))
dataList.append(encode(''))
body = b'\r\n'.join(dataList)
payload = body
headers = {
  'Authorization': 'GPTPROTO_API_KEY',
  'Content-type': 'multipart/form-data; boundary={}'.format(boundary)
}
conn.request("POST", "/v1/videos", payload, headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))

package main

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

func main() {

  url := "https://gptproto.com/v1/videos"
  method := "POST"

  payload := &bytes.Buffer{}
  writer := multipart.NewWriter(payload)
  _ = writer.WriteField("model", "sora-2")
  _ = writer.WriteField("prompt", "Put a hat on the cat")
  err := writer.Close()
  if err != nil {
    fmt.Println(err)
    return
  }


  client := &http.Client {
  }
  req, err := http.NewRequest(method, url, payload)

  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Authorization", "GPTPROTO_API_KEY")

  req.Header.Set("Content-Type", writer.FormDataContentType())
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()

  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}

curl --location --request GET 'https://gptproto.com/v1/videos/{{id}}' \
--header 'Authorization: GPTPROTO_API_KEY'

import requests
import json

url = "https://gptproto.com/v1/videos/{{id}}"
headers = {
    "Authorization": "GPTPROTO_API_KEY"
}

response = requests.get(url, headers=headers)
result = response.json()
print(json.dumps(result, indent=2))

const url = "https://gptproto.com/v1/videos/{{id}}";
const headers = {
  "Authorization": "GPTPROTO_API_KEY"
};

fetch(url, {
  method: "GET",
  headers: headers
})
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error("Error:", error));

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    url := "https://gptproto.com/v1/videos/{{id}}"

    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", "GPTPROTO_API_KEY")

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

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

curl --location --request GET 'https://gptproto.com/v1/videos/{{id}}/content' \
--header 'Authorization: GPTPROTO_API_KEY'

import requests
import os

url = "https://gptproto.com/v1/videos/{{id}}/content"
headers = {
    "Authorization": "GPTPROTO_API_KEY"
}

response = requests.get(url, headers=headers, stream=True)

if response.status_code == 200:
    with open("video_output.mp4", "wb") as f:
        for chunk in response.iter_content(chunk_size=1024):
            if chunk:
                f.write(chunk)
    print("Video downloaded successfully")
else:
    print(f"Failed to download video: {response.status_code}")

const url = "https://gptproto.com/v1/videos/{{id}}/content";
const headers = {
  "Authorization": "GPTPROTO_API_KEY"
};

fetch(url, {
  method: "GET",
  headers: headers
})
  .then(response => response.blob())
  .then(blob => {
    const url = window.URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url;
    a.download = 'video_output.mp4';
    document.body.appendChild(a);
    a.click();
    document.body.removeChild(a);
    window.URL.revokeObjectURL(url);
  })
  .catch(error => console.error("Error:", error));

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

func main() {
    url := "https://gptproto.com/v1/videos/{{id}}/content"
    req, _ := http.NewRequest("GET", url, nil)
    req.Header.Set("Authorization", "GPTPROTO_API_KEY")

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

    if resp.StatusCode == 200 {
        out, err := os.Create("video_output.mp4")
        if err != nil {
            panic(err)
        }
        defer out.Close()

        _, err = io.Copy(out, resp.Body)
        if err != nil {
            panic(err)
        }

        fmt.Println("Video downloaded successfully")
    } else {
        fmt.Printf("Failed to download video: %d\n", resp.StatusCode)
    }
}