elog | API Documentation
Standard API using REST and JSON

Overview

This API is essentially a suite of methods that can be called from your Server.
A method is called over HTTP.
  • The URL is:  https://api.elog.com/MethodNameHere
  • The HTTP header contains the necessary authentication.
  • The HTTP method is "POST" and the body contains JSON.
  • The HTTP result contains JSON.
  • The HTTP status code is always 200.

Methods

Subtitles.Translate
**Description**  
Given data in SRT or WebVTT format, translate it to some other language.  
  
**URL**  
https://api.elog.com/Subtitles.Translate  
  
**Argument**  
subtitles: (required unless "url-subtitles" is passed)  
  the complete content of an SRT or WebVTT file  
url-subtitles:  
  URL that contains the subtitles (instead of passing "subtitles" above)  
source-language: (required)  
  language to translate from.  
  The format is ISO 639-1, e.g. 'en' 'es' 'ko' 'pt-BR'.  
  For a full list of "source-language" and "target-language" values,  
  see ... (coming soon).  
target-language: (required)  
  language to translate to.  
  See "source-language" above for the format and the list of languages.  
url-completion: (optional)  
  This URL will be called right when the translation of subtitles is complete.  
  
**Result**  
url-translation:  
  Translating subtitles can take several minutes. For this reason, the result  
  of the current method does not actually contain the translation. Instead,  
  it contains a URL in "url-translation" that will eventually contain the  
  resulting translation. You can call this URL every 10 seconds or so, until  
  it returns a result (it returns HTTP status of 403 or 404 until then) or you  
  can pass a URL in "url-completion" (see above) to be notified of when the  
  translation is ready. "url-completion" is called as an HTTP POST and the  
  body is the exact JSON that was returned in the result of the original  
  API call (so it contains "url-translation" which you can then call to get  
  the translated subtitles, finally).  
  
**Example**  
*REQUEST:*  
{  
  "subtitles": "00:00:00,000 --> 00:00:01,503\r\nHello there...",  
  "source-language": "en",  
  "target-language": "es"  
}  
  
*RESPONSE:*  
{  
  "url-translation": "http://temp.elog.com/592aa3b6f176e1cd50ba8acee129834d"  
}  
Movies.Titles
**Description**  
For some search text, find movie titles.  
  
**URL**  
https://api.elog.com/Movies.Titles  
  
**Argument**  
text:  
  This is the text to use as the search criteria. It doesn't have to be an  
  exact match and it can be something like a current/main title, original  
  title, or an alternative title.  
top:  
  maximum number of movies to return. Default: 100  
  
**Result**  
movies:  
  An array where each element is a movie that is composed of a dictionary  
  with these properties:  
  id:           unique id of the movie (good for passing to other methods)  
  title:        current/main title of the movie  
  release-date: date of release. Format is: YYYY-MM-DD  
  genres:       array of genres  
  keywords:     array of keywords  
  image-url:    URL of an image that represents the movie.  
                Note: If you are going to host such images yourself, don't  
                use this image URL to download the content to your servers.  
                Instead, use the URL below (notice "http" below).  
                Fill in the "..." withe "id" from above.  
                http://s3.amazonaws.com/s3.elog.com/Poster/id=...  
  id-imdb:      unique id of the movie in IMDb  
  Notes:  
   - To get more properties of a given movie, use method Movies.Meta.  
   - Your organization may have its own library of movies. See method  
     Settings.Save to limit which movies can be in the result.  
  
**Example**  
*REQUEST:*  
{  
  "text": "raiders lost ark"  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "movies": [  
         {  
            "id": "85",  
            "title": "Raiders of the Lost Ark",  
            "release-date": "1981-06-12",  
            "genres": [  
               "Adventure",  
               "Action"  
            ],  
            "keywords": [  
               "saving the world",  
               "riddle",  
               "nepal",  
               ...  
            ],  
            "image-url": "...",  
            "id-imdb": "tt0082971"  
         },  
         {  
            "id": "764496",  
            "title": "On Set with 'Raiders of the Lost Ark'",  
            "release-date": "2012-06-05",  
            "genres": [],  
            "keywords": [],  
            "image-url": "...",  
            "id-imdb": null  
         },  
         ...  
      ]  
   }  
}  
Movies.Search
**Description**  
For some search text, search for similar movies.  
  
**URL**  
https://api.elog.com/Movies.Search  
  
**Argument**  
text:  
  This is the text to use as the search criteria. This is not a traditional  
  boolean search of the text; it is a fuzzy/AI search. The text can be of  
  any length.  
top:  
  maximum number of movies to return. Default: 100  
  
**Result**  
movies:  
  An array where each element is a movie that is composed of a dictionary  
  with these properties:  
  id:           unique id of the movie (good for passing to other methods)  
  title:        current/main title of the movie  
  release-date: date of release. Format is: YYYY-MM-DD  
  genres:       array of genres  
  keywords:     array of keywords  
  image-url:    URL of an image that represents the movie.  
                Note: If you are going to host such images yourself, don't  
                use this image URL to download the content to your servers.  
                Instead, use the URL below (notice "http" below).  
                Fill in the "..." withe "id" from above.  
                http://s3.amazonaws.com/s3.elog.com/Poster/id=...  
  id-imdb:      unique id of the movie in IMDb  
  Notes:  
   - To get more properties of a given movie, use method Movies.Meta.  
   - Your organization may have its own library of movies. See method  
     Settings.Save to limit which movies can be in the result.  
  
**Example**  
*REQUEST:*  
{  
  "text": "A lonely writer buys a newly developed artificial intelligence  
           operating system and he is able to have a romantic relationship  
           with it."  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "movies": [  
         {  
            "id": "152601",  
            "title": "Her",  
            "release-date": "2013-12-18",  
            "genres": [  
               "Romance",  
               "Science Fiction",  
               "Drama"  
            ],  
            "keywords": [  
               "artificial intelligence",  
               "future",  
               "computer",  
               "love",  
               "loneliness",  
               "transhumanism",  
               "heartbreak",  
               "singularity"  
            ],  
            "image-url": "...",  
            "id-imdb": "tt1798709"  
         },  
         ...  
      ]  
   }  
}  
Movies.MLT
**Description**  
Given a movie id, run MLT (More Like This) on it.  
  
**URL**  
https://api.elog.com/Movies.MLT  
  
**Argument**  
id: (required)  
  unique id of the movie to run MLT on  
top:  
  maximum number of movies to return. Default: 100  
  
**Result**  
movies:  
  An array where each element is a movie that is composed of a dictionary  
  with these properties:  
  id:           unique id of the movie (good for passing to other methods)  
  title:        current/main title of the movie  
  release-date: date of release. Format is: YYYY-MM-DD  
  genres:       array of genres  
  keywords:     array of keywords  
  image-url:    URL of an image that represents the movie.  
                Note: If you are going to host such images yourself, don't  
                use this image URL to download the content to your servers.  
                Instead, use the URL below (notice "http" below).  
                Fill in the "..." withe "id" from above.  
                http://s3.amazonaws.com/s3.elog.com/Poster/id=...  
  id-imdb:      unique id of the movie in IMDb  
  Notes:  
   - To get more properties of a given movie, use method Movies.Meta.  
   - Your organization may have its own library of movies. See method  
     Settings.Save to limit which movies can be in the result.  
  
**Example**  
*REQUEST:*  
{  
  "id": "85"  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "movies": [  
         {  
            "id": "89",  
            "title": "Indiana Jones and the Last Crusade",  
            "release-date": "1989-05-24",  
            "genres": [  
               "Adventure",  
               "Action"  
            ],  
            "keywords": [  
               "germany",  
               "saving the world",  
               "venice, italy",  
               "holy grail",  
               ...  
            ],  
            "image-url": "...",  
            "id-imdb": "tt0097576"  
         },  
         ...  
      ]  
   }  
}  
Movies.Meta
**Description**  
Given a movie id, return meta data for it.  
  
**URL**  
https://api.elog.com/Movies.Meta  
  
**Argument**  
id: unique id of the movie to get information for  
  
**Result**  
movies:  
  An array where each element is a movie that is composed of a dictionary  
  with several properties. This has ongoing additions. See an example below  
  and run it yourself to get the idea. Let us know if you need more.  
  id:           unique id of the movie (good for passing to other methods)  
  title:        current/main title of the movie  
  release-date: date of release. Format is: YYYY-MM-DD  
  genres:       array of genres  
  keywords:     array of keywords  
  image-url:    URL of an image that represents the movie.  
                Note: If you are going to host such images yourself, don't  
                use this image URL to download the content to your servers.  
                Instead, use the URL below (notice "http" below).  
                Fill in the "..." withe "id" from above.  
                http://s3.amazonaws.com/s3.elog.com/Poster/id=...  
  id-imdb:      unique id of the movie in IMDb  
  ... (more here)  
  
**Example**  
*REQUEST:*  
{  
  "id": "85"  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "movie": {  
         "id": "85",  
         "title": "Raiders of the Lost Ark",  
         "release-date": "1981-06-12",  
         "genres": [  
            "Adventure",  
            "Action"  
         ],  
         "keywords": [  
            "saving the world",  
            "riddle",  
            "nepal",  
            ...  
         ],  
         "image-url": "...",  
         "id-imdb": "tt0082971",  
         "original-language": "en",  
         "spoken-languages": [  
            "en", "es", "de", "he", "ar", "ne"  
         ],  
         "original-title": "Raiders of the Lost Ark",  
         "alternative-titles": [  
            "Indiana Jones - Les aventuriers de l'arche perdue",  
            "Poszukiwacze zaginionej Arki",  
            ...  
         ],  
         "overview": "When Dr. Indiana Jones the tweed-suited professor who  
                      just happens to be a celebrated archaeologist..."  
      }  
   }  
}  
Movies.Keywords
**Description**  
For some text, generate keywords that are relevant to movie content and themes.  
The keywords aren't necessarily even found in the text.  
  
**URL**  
https://api.elog.com/Movies.Keywords  
  
**Argument**  
text: text, of any length, to find keywords for  
top: maximum number of keywords to return. Default: 100  
  
**Result**  
keywords: array of keywords  
  
**Example**  
*REQUEST:*  
{  
  "text": "A rat named Remy dreams of becoming a great French chef despite his  
           family's wishes and the obvious problem of being a rat in a  
           decidedly rodent-phobic profession. When fate places Remy in the  
           sewers of Paris, he finds himself ideally situated beneath a  
           restaurant made famous by his culinary hero, Auguste Gusteau.  
           Despite the apparent dangers of being an unlikely - and certainly  
           unwanted - visitor in the kitchen of a fine French restaurant,  
           Remy's passion for cooking soon sets into motion a hilarious and  
           exciting rat race that turns the culinary world of Paris upside down.",  
  "top": 10  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "keywords":  
    [  
      "mouse","evacuation","leaving one's family","work","restaurant critic",  
      "spice","cookbook","sewer","chef","rat"  
    ]  
  }  
}  
Collections.List
**Description**  
Return the entire list of collections for some owner or organization.  
  
**URL**  
https://api.elog.com/Collections.List  
  
**Argument**  
owner: (required)  
  Unique id of the owner/organization that owns the collection. This is likely  
  to just be your own organization but it could be different when sharing of  
  collections is implemented.  
  
**Result**  
list: an array of collection ids  
  
**Example**  
*REQUEST:*  
{  
  "owner": "my-organization"  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "list": ["Sci-fi Comedy", "Big Events", "..."]  
   }  
}  
Collections.Collection
**Description**  
Given some collection id, return the collection's definition/properties.  
  
**URL**  
https://api.elog.com/Collections.Collection  
  
**Argument**  
id: (required)  
  Unique id of the collection  
  
**Result**  
  id: unique id of the collection  
  title: title of the collection  
  description: description of the collection  
  owner: unique id of the owner/organization that owns the collection  
  image-url: URL of an image for the collection  
  creation-timestamp: timestamp of creation. Format: W3C  
  modification-timestamp: timestamp of the last modification. Format: W3C  
  list: array of "movie" and "tv" elements in the order that was specified  
        in the elog Collection Builder. See the example below.  
  
**Example**  
*REQUEST:*  
{  
  "id": "t5GWunxj87W"  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "id": t5GWunxj87W",  
      "name": "Sci-Fi Comedy Here",  
      "description": "My description of this collection...",  
      "owner": "my-organization",  
      "image-url": "https://...",  
      "creation-timestamp": "2021-02-10T10:45:03.000Z",  
      "modification-timestamp": "2021-02-12T12:15:28.000Z",  
      "list": [  
         "movie": {see an element under "movies" in Movies.Search},  
         "movie": {...},  
         "movie": {...},  
         ...  
      ]  
   }  
}  
Settings.Save
**Description**  
Save some global settings for your organization.  
  
**URL**  
https://api.elog.com/Settings.Save  
  
**Argument**  
organization: (required)  
  unique id of your organization  
universe:  
  An array of ids (IMDb ids only, for now; EIDR ids in the future).  
  This list of ids are the only ones that would ever show in any result from  
  any other API method.  
  
**Result**  
saved:  
  a dictionary of property/boolean pairs indicating which settings were  
  sucessfully saved  
  
**Example**  
*REQUEST:*  
{  
  "organization": "my-organization",  
  "universe": ["tt0082971","tt0087469","..."]  
}  
  
*RESPONSE:*  
{  
   "success": true,  
   "result": {  
      "saved": {  
         "universe": true  
      }  
   }  
}  
RMT.CreateAssociations
**Description**  
Create a new association(s) between a seller, a buyer, and a resource (movie).  
  
**URL**  
https://api.elog.com/RMT.CreateAssociations  
  
**Argument**  
associations: (required)  
Array of dictionaries, where each dictionary represents a single association  
and has all of the required properties listed below. Each of the ids below  
comes from your own database.  
seller-id, buyer-id, resource-id  
  
**Result**  
existed: array of booleans for whether each association already existed  
  
**Example**  
*REQUEST:*  
{  
  "associations":  
  [  
    {  
      "seller-id":   "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
      "buyer-id":    "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
      "resource-id": "Z5RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ"  
    },  
    {  
      "seller-id":   "sbudCAdE-A4jv-XARb-ODr6-KAkFdkXUGcgQ",  
      "buyer-id":    "Bk8ncJUmO-ypAh-o5z7-4wls-OTN8DlM0BUE",  
      "resource-id": "rSEzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7"  
    }  
  ]  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "existed": [false,false]  
  }  
}  
RMT.ListAssociations
**Description**  
List the association(s) for a seller/buyer/resource; any combination of one  
or more of those can be passed. With this method, you can get useful  
information such as:  
 1) All buyers and resources for a given seller  
 2) All sellers for a given buyer  
 3) All buyers using some resource  
 4) The playback URL for some specific resource  
 etc.  
  
**URL**  
https://api.elog.com/RMT.ListAssociations  
  
**Argument**  
seller-id:   id of a seller  
buyer-id:    id of a buyer  
resource-id: id of a resource  
  
**Result**  
associations:  
 Array of dictionaries, where each dictionary has all of the following  
 properties: seller-id, buyer-id, resource-id, playback-url  
  
**Example**  
*REQUEST:*  
{  
  "seller-id": "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
  "buyer-id":  "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0"  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "associations":  
    [  
      {  
        "seller-id":    "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":     "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id":  "Z1RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ",  
        "playback-url": "https://onvid.io/wgl0Y9wj-iLsv-Gvw1-VGjL-QNNweOvdYWLF.m3u8'  
      },  
      {  
        "seller-id":    "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":     "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id":  "r2EzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7",  
        "playback-url": "https://onvid.io/XOoUoBdP-reu3-ZR9d-DRdp-1g1RqPuU7c2k.m3u8'  
      }  
    ]  
  }  
}  
RMT.DeleteAssociations
**Description**  
Delete the association(s) for a seller/buyer/resource; any combination of one  
or more of those can be passed. With this method, you can perform actions  
like:  
 1) Delete specific resources for some seller/buyer assocation  
 2) Delete a resource entirely  
 3) Delete a buyer entirely  
 4) Delete specific resources for some seller (from all of its buyers)  
 etc.  
  
**URL**  
https://api.elog.com/RMT.DeleteAssociations  
  
**Argument**  
seller-id:   id of a seller  
buyer-id:    id of a buyer  
resource-id: id of a resource  
  
**Result**  
associations:  
 This is a listing of all the associations that were deleted, as an array  
 of dictionaries, where each dictionary has all of the following properties:  
 seller-id, buyer-id, resource-id  
  
**Example**  
*REQUEST:*  
{  
  "seller-id": "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
  "buyer-id":  "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0"  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "associations":  
    [  
      {  
        "seller-id":   "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":    "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id": "Z1RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ"  
      },  
      {  
        "seller-id":   "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":    "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id": "r2EzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7"  
      }  
    ]  
  }  
}  
RMT.AssimilateResources
**Description**  
Assimilate resources into the system so that they can be streamed and tracked.  
All of the necessary transcoding takes place at this time.  
  
**URL**  
https://api.elog.com/RMT.AssimilateResources  
  
**Argument**  
resources: (required)  
Array of dictionaries, where each dictionary represents a single resource  
and has all of the required properties listed below:  
  resource-id: id of a resource  
  resource-url: URL of the resource. This is where the source movie content  
                is located, as an MP4, MOV, etc.  Note that this is not where  
                the content will ultimately be served from, to the consumer,  
                that is. This content is what is transcoded into many files  
                that are covered by an HLS.  
  buyer-id: id of a buyer. The reason this is needed is because the  
            playback-url (that is created to access is resource) must be  
            unique and private to the buyer, in order to track the usage  
            of the resource on behalf of the specific buyer.  
  
**Result**  
resources:  
Array of dictionaries, one for each element passed in the request, where  
each dictionary has all of the properties listed below.  
  resource-id: id of a resource (same as passed in the request)  
  playback-url: This is the URL of an HLS file is that is created specifically  
                for the passed buyer.  
  
  
**Example**  
*REQUEST:*  
{  
  "resources":  
  [  
    {  
      "resource-id":  "Z5RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ",  
      "resource-url": "https://s3.amazonaws.com/seller-bucket/movie123.mp4",  
      "buyer-id":     "qMg8H3NE-wIo1-oXBn-kzyD-RZVQyX0L05Ke"  
    },  
    {  
      "resource-id": "rSEzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7",  
      "resource-url": "https://s3.amazonaws.com/seller-bucket/movie456.mp4",  
      "buyer-id":     "qMg8H3NE-wIo1-oXBn-kzyD-RZVQyX0L05Ke"  
    }  
  ]  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "resources":  
    [  
      {  
        "resource-id":  "Z5RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ",  
        "playback-url": "https://onvid.io/5aLPwYOZ-FtlN-0HV9-T2CH-y5kudT4GM0uY.m3u8"  
      },  
      {  
        "resource-id": "rSEzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7",  
        "playback-url": "https://onvid.io/A3eHuFCT-bcaK-JAxY-OMhM-M7DDgtRhlsD5.m3u8"  
      }  
    ]  
  }  
}  
RMT.Report
**Description**  
Report on the usage of resources given a seller/buyer/resource; any  
combination of one or more of those can be passed.  
  
**URL**  
https://api.elog.com/RMT.Report  
  
**Argument**  
seller-id:   id of a seller  
buyer-id:    id of a buyer  
resource-id: id of a resource  
begin-date:  begin date of the reporting period. Default: first date available  
end-date:    end date of the reporting period. Default: last date available  
  
**Result**  
report:  
 Array of dictionaries, where each dictionary has all of the following  
 properties: seller-id, buyer-id, resource-id, as well as the following:  
 duration: number of minutes streamed  
  
**Example**  
*REQUEST:*  
{  
  "seller-id":  "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
  "buyer-id":   "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
  "begin-date": "2020-12-01T00:00:00.000Z",  
  "end-date":   "2020-12-31T00:00:00.000Z"  
}  
  
*RESPONSE:*  
{  
  "success": true,  
  "result":  
  {  
    "report":  
    [  
      {  
        "seller-id":    "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":     "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id":  "Z1RmV23U-q7xe-wTcN-JzQm-XP2JmP6OuutZ",  
        "duration":     180000  
      },  
      {  
        "seller-id":    "aCrBr3XM-yq7Z-3Vat-Ptq0-uOe1hUfdNAjI",  
        "buyer-id":     "BWu4acHQ-oeeU-IAwt-dP1i-jNBsBAYS3vq0",  
        "resource-id":  "r2EzQB2f-8HNi-FXzi-E1VB-D0uzwfFVIYh7",  
        "duration":     220000  
      }  
    ]  
  }  
}  

Authentication

"Basic Access Authentication" is used for all API calls. You will be issued a user name and a password, which should be used when forming the required HTTP header.
So, for example, if your user name is "UserA" and your password is "ZbJ058gm", the appropriate HTTP header for authorization is the following:
  Authorization: Basic VXNlckE6WmJKMDU4Z20=

Error Handling

When some type of error occurs with your call, an error result is returned.
In each call that you make, the first thing you should do is check the success bit and behave accordingly.
HTTP status codes are not mixed in at all with the API itself.
You will generally just receive a status code of 200. It is always possible that the communication over HTTP could fail or some very unexpected result could occur, but all of that is outside the scope of the API.
A successful result looks something like this:
{
   "success": true,
   "result": {...}
}
An error result has the same structure and looks something like this:
{
   "success": false,
   "result":
   {
      "code": "property.missing",
      "message": "A required property is missing.",
      "detail": "dataset"
   }
}