Sso Properties

The datacloud method is intended to people who need to retrieve all the dynamical and physical properties available for a given Solar system object. These properties are composed of peer-reviewed measurements and estimates, publicly available in the litterature and third party data sets. They are aggregated in the SsODNet database into data collections, and some properties are computed on the fly.

rocks API

The best friendly way to retrieve data from SsODNet.datacloud is to use the “rocks” API. This is a command-line Python software allowing to request SsODNet with simple and natural commands. Read the documentation for more information and tutorials.

SsODNet.datacloud collections

The collections of data sets aggregated in SsODNet.datacloud are listed into the following table, providing the number of data ('Nb rows'), the number of distinct SSO ('Nb SSOs'), the number of collected bibliographic references ('Nb BibRef'), and a link to retrieve the list of bibliographic references.

The complete list of bibliographic references used to populate SsODNet.datacloud are also available in a single document in bibTeX, JSON, or PDF format.


HTTP Request

If you are a software/solutions developer, you might want to include the SsODNet datacloud service in your application. This can be done by using the Web service method, or by using the following HTTP request:[parameters]
where [parameters] is a list of parameters separated by the ampersand character (&):
ParameterDefinitionLimits or value
-name=<string> The designation of the target Ex.: Mars, 5, a:Pallas, 1999 TC36, p/halley
-resource=<string> Requested resource from SsODNet datacloud collection | bibref | list | all | <collection name>
(default is all)
-mime=<string> Mime type of the results json | votable | html | text
(default is json)
-maxrec=<int> Maximum number of Sso to retrieve n ≥ 1, default is 10
-from=<string> Word which definite the name of the caller application,
or which describes the request
any short string (no space character)

The output parameters are described below. The output formats are VOTable (default), HTML, plain text format, and JSON. Only argument -name is mandatory, except if argument -resource equal collection. In that case argument -name can be omitted.

Web service

The SsODNet Web service provides methods based on SOAP and HTTP POST verb which allow one to interact between its own application and the SsODNet service. Information to invoke the SsODNet resolver method:
Web Service URI:
SOAP header:
name of the SOAP header element: clientID
SOAP header's content: array('from' => 'YourName', 'hostip'=>'')
datacloud (inputArray)
The input parameter of the method is an array which must contained the following parameters:
VariableTypeUnitsLimits or valuesDefaultComment
name string designation - none Name or number of the target
resource string - collection | bibref | list | all | <collection name> all Requested resource
mime string - json | votable | html | text json Mime type of the results
maxrec int - n ≥ 1 10 Maximum number of Sso to retrieve

The output of the datacloud method is an object containing the following attributes:

Status of the response: flag=1 means ok; flag=0 or flag=-1 mean that an error occured
HTTP status-code of the response (e.g. 400: bad request, 422: Unprocessable Entity, 500: internal error)
Unix timestamp of the response which can be useful to stamp the request
String containing the ephemeris of the requested solar system body with parameters depending on user's options (cf. Output parameters section).
Depending on the selected mime type, the output is formatted as:
Data are written in a JSON object.
Data are written in the IVOA standard VOTable format
Data are transformed from VOTable to HTML by XSLT processing (SsODNet XSL style sheet)
Data are returned in plain text where each block of data is separated by the semi-colon character ';' and each value in a block is separated by the pipe '|' character

Query examples

Click on the following links (output in JSON format):

↳ to get info about the collections which compose the datacloud
all collections: -resource=collection
a given collection (colors): -resource=collection:colors
↳ to get the bibliographic references of the collections
all bibref: -resource=bibref
bibref of a given collection (colors): -resource=bibref:colors
↳ to get the list of collections containing data of one of more SSOs
for the asteroid named 'Io': -resource=list&-name=a:io
for all asteroids with name starting by 'Io': -resource=list&-name=a:expr:io*
for all SSO with name or alias including 'ceres' or 'pallas' or 'vesta' or 'io': -resource=list&-name=like:(ceres pallas vesta io)
↳ to get the properties of a given SSO
all resources available for dwarf planet 'Ceres': -name=dp:ceres&-resource=all
all diameter and albedo values known for dwarf planet 'Ceres': -name=dp:ceres&-resource=diamalbedo

Output parameters

The output parameters of the datacloud method depend on the nature of the resource: collection, bibref, list or data. Depending on the mime type, the output can be retrieved in three formats:


This is the preferred format to quickly handle the outputs. The data can be easily traversed and loaded in memory into associative arrays. The data structures are detailed in the JSON format section.


This is the most complete and interoperable format. The data are well described with generous metadata. They can be easily loaded in memory into a XML tree, and displayed with IVOA applications.


This is the worst option to handle the outputs. Just made for human reading.

Structure of the output JSON objects

When the output mime type is the JSON data-interchange format, the data are encapsulated into a structure defined as follows:

{ "flag": int, "ticket": int, "version": string, "data": {} }

where data contains an object which depends on the requested resource:


Test Example

"data": { collection }

where collection is a list of one or more objects describing resources:

"<resource_name>": { 
  "idcollection": datacloud id of the collection (string),
  "description": Description of the collection (string),
  "nbrows": Total number of data (i.e. rows) of the collection (int),
  "nbsso": Total number of distinct SSO in the collection (int),
  "nbbibref": Total number of bibliographic references used to populate the collection (int),
  "bibref": Array of bibliographic references of the collection:
    [ {"shortbib": string, "year": int, "title": string, "bibcode": string, "ads_url": string} ],
  "self": URL to access the metadata of this collection (string) 

Test Example

"data": { collection }

where collection is a list of one or more objects providing the bibliographic references used to populate the collection:

"<resource_name>": [ {
  "shortbib": Short bibref (string),
  "year": Year of publication (int),
  "title": Title of the article (string), 
  "bibcode": Bibcode of the article (string), 
  "ads_url": Direct link to the article in ADS (string)
} ]

Test Example

"data": { 
   "<sso_id>": { 
      "identity": { identity },
      "datacloud": [ {
         "idcollection": Collection id (int),
         "collection": Name of the collection (string),
         "description": Description of the collection (string),
         "self": Self link to access the metadata of this collection (string),
         "datalink": Direct link to get the data of this SSO for this collection (string) 
      } ],
      "self": Self link to get this list (string)

where <sso_id> is the name of the Sso, and where identity is an object describing the Sso:

"identity": { 
    "name": Name of the SSO (string),
    "number": Number of the SSO (string),
    "type": Type of SSO (string),
    "class": Dynamical class of the SSO (string),
    "parent": Name of the SSO parent (string),
    "system": Name of the planetary system to which the SSO belongs (string),
    "aliases": [ Array of aliases of the SSO (string) ],
    "ephemeris": True if Miriade.ephemcc can compute positional ephemeris (boolean) ,
    "physical-ephemeris": True if Miriade.ephemph can compute physical ephemeris (boolean),
    "physical-models": [ Array of spin solution Id (boolean) ],

Test Example

"data": { 
   "<sso_id>": { 
      "identity": { identity },
      "datacloud": { 
         "<resource_name>": [ { table_data } ]
      "self": Self link to get the data of this SSO (string)

where table_data is an object containing the data of the corresponding resource.

How to consume

You have two ways to use the SsODNet web service: by writting a client to send requests to the SsODNet server and to receive and analyze the response, or by using a command line interface and a data transfert program such as curl or wget. For that, just execute one of the following commands in a console:
$> curl "<URL>"
$> wget "<URL>"
where <URL> is described in section HTTP request.

In order to help you to invoke the SsODNet Web service, we provide some clients written in differents languages. Here are some detailed explanations to write a client with PHP and SOAP which invokes the datacloud method:

1/ Provide the input parameters which are mandatory for the service:

// Client's ID: provide the name of your project or organisation or yourself
$from = 'MyName';
// Input parameters
$param = array('name' => 'a:io',
               'resource' => 'all',
               'mime' => 'json',
               'maxrec' => 10

2/ Define the SOAP options, the namespace and the WSDL URI of SsODNet web service:

// Enables or disables the WSDL caching feature
ini_set('soap.wsdl_cache_enabled', 1);
// SkyBoT namespace
$namespace = '';
// SkyBoT WSDL
$uriwsdl = $namespace.'/ssodnet.wsdl';

3/ Create a SoapClient object in WSDL mode, set the SOAP header, then call the method and catch exceptions:

try {
   // Constructs the client
   $client = new SoapClient($uriwsdl, array('exceptions'=>1));
   // SOAP header
   $header = array('from'=>$from, 'hostip'=>'', 'lang'=>'en');
   $client->__setSoapHeaders(array(new SOAPHeader($namespace, 'clientID', $header)));  
   // Call the datacloud method
   $response = $client->__soapCall('datacloud',array($param));
   // Display the results
   if ($param['mime'] == 'text') {
      $res = explode(';', $response->result);
      $nbr = count($res);
      $newkey = array_keys($res);
      header("HTTP/1.0 ".$response->status);
      header("Content-Type: text/plain");
      echo "# Flag: ".$response->flag.PHP_EOL;
      echo "# Ticket: ".$response->ticket.PHP_EOL;
      for ($i=0; $i<$nbr; $i++) { echo $res[$newkey[$i]],PHP_EOL; }
   } else if ($param['mime'] == 'json') {
      header("HTTP/1.0 ".$response->status);
      header("Content-Type: application/json");
      echo $response->result;
   } else {
      header("HTTP/1.0 ".$response->status);
      header("Content-Type: text/xml;content=x-votable");
      echo $response->result;
} catch (SoapFault $fault) {
   trigger_error("SOAP Fault: {$fault->getTraceAsString()} (faultcode: {$fault->faultcode}, 
                               faultstring: {$fault->faultstring})", E_USER_ERROR);