Uploading With Accessible URL

const ORGID = "org_XXX";
const ENVID = "ENV_XXX";
const APIKEY = "key_XXX";

async function uploadVideoFromURL(
  videoURL: string,
  fileName: string,
  videoQuality: "standard" | "high" | "ultra" = "high",
  allowPublicAccess: boolean = true
): Promise<string> {
  // Step 1: Submit the video config with accessible URL
  const uploadResponse = await fetch(
    `https://api.hesedvid.com/v1/api/${ORGID}/environments/${ENVID}/videos/upload`,
    {
      method: "POST",
      headers: {
        "X-Api-Key": APIKEY,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        fileName: fileName,
        videoQuality: videoQuality,
        allowPublicAccess: allowPublicAccess,
        videoURL: videoURL
      })
    }
  );

  const { body: uploadData } = await uploadResponse.json();

  return uploadData.videoID;
}

// Example usage
const videoID = await uploadVideoFromURL(
  "https://example.com/my-video.mp4",
  "my-video.mp4",
  "high",
  true
);
console.log("Video ID:", videoID);

import requests

ORGID = "org_XXX"
ENVID = "ENV_XXX"
APIKEY = "key_XXX"

def upload_video_from_url(
    video_url: str,
    file_name: str,
    video_quality: str = "high",
    allow_public_access: bool = True
) -> str:
    # Step 1: Submit the video config with accessible URL
    upload_response = requests.post(
        f'https://api.hesedvid.com/v1/api/{ORGID}/environments/{ENVID}/videos/upload',
        headers={
            'X-Api-Key': APIKEY,
            'Content-Type': 'application/json'
        },
        json={
            'fileName': file_name,
            'videoQuality': video_quality,
            'allowPublicAccess': allow_public_access,
            'videoURL': video_url
        }
    )

    upload_data = upload_response.json()['body']

    return upload_data['videoID']

# Example usage
video_id = upload_video_from_url(
    video_url="https://example.com/my-video.mp4",
    file_name="my-video.mp4",
    video_quality="high",
    allow_public_access=True
)
print(f"Video ID: {video_id}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

const (
    ORGID  = "org_XXX"
    ENVID  = "ENV_XXX"
    APIKEY = "key_XXX"
)

type UploadVideoRequest struct {
    FileName          string `json:"fileName"`
    VideoQuality      string `json:"videoQuality"`
    AllowPublicAccess bool   `json:"allowPublicAccess"`
    VideoURL          string `json:"videoURL"`
}

type UploadVideoResponse struct {
    Body struct {
        VideoID string `json:"videoID"`
    } `json:"body"`
}

func uploadVideoFromURL(videoURL, fileName, videoQuality string, allowPublicAccess bool) (string, error) {
    // Step 1: Submit the video config with accessible URL
    reqBody, _ := json.Marshal(UploadVideoRequest{
        FileName:          fileName,
        VideoQuality:      videoQuality,
        AllowPublicAccess: allowPublicAccess,
        VideoURL:          videoURL,
    })

    req, _ := http.NewRequest("POST",
        fmt.Sprintf("https://api.hesedvid.com/v1/api/%s/environments/%s/videos/upload", ORGID, ENVID),
        bytes.NewBuffer(reqBody))
    req.Header.Set("X-Api-Key", APIKEY)
    req.Header.Set("Content-Type", "application/json")

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

    var uploadResp UploadVideoResponse
    json.NewDecoder(resp.Body).Decode(&uploadResp)

    return uploadResp.Body.VideoID, nil
}

// Example usage
func main() {
    videoID, _ := uploadVideoFromURL(
        "https://example.com/my-video.mp4",
        "my-video.mp4",
        "high",
        true,
    )

    fmt.Println("Video ID:", videoID)
}