Language
Manage Contract
When you sign up for a OneAtlas account, your user will be assigned to a contract. This contract will contain a private and dedicated workspace for yourself and any other users within the same contract.
There are currently two types of contact:
Premium: standard access based on a pre-paid service
TechEval: this contract will contain a “trial-plan” subscription which allows you to try our systems for a temporary period. A small load of money is already available when this account is created to let you try the paying options in real conditions.
This guide will walk you through managing your subscription, revoking your subscription and checking your payments.
Retrieve your Account Information
| API Endpoint | /api/v1/me |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
The endpoint /me will retrieve all information related to your profile:
curl -X GET https://data.api.oneatlas.airbus.com/api/v1/me \
-H 'Authorization: Bearer <access_token>'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/me");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/me"
headers = {
'Authorization': "Bearer <access_token>",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
You will receive the following:
This endpoint gives you access to the licence, information about your account such as ID and creation date, your contracts, orders, payments and subscriptions. Lets take a look at some of the above links example in more detail.
Get User Roles
You can quickly list your user roles by using the endpoint /me/services.
curl -X GET https://data.api.oneatlas.airbus.com/api/v1/me/services \
-H 'Authorization: Bearer <access_token>'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/me/services");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/me/services"
headers = {
'Authorization': "Bearer <access_token>",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
Example return:
{
"oneatlas-data": true,
"change-detection": false,
"geostore-premier": true,
"verde": false,
"ocean-finder": false,
"earth-monitor": true,
"analytics-toolbox": true,
"pfneo-3d": false,
"tasking": false
}
Get Contract Information
This API is used to retrieve details of a contract.
| API Endpoint | /api/v1/contracts/{contractId} |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| Tag | Description |
|---|---|
| id | unique contract identification object relating to the contract. |
| _links | provides a direct link to the contract itself. |
| balance | your remaining balance in your account. |
| workspaceId | id of the workspace. |
Example to retrieve information regarding a contract:
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id} \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id}");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id}"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
As a return we get all the details relating to the contract:
The status of the contract can either be pending, created, error or active.
Get All Subscriptions for a Given Contract
This API is used to retrieve all subscriptions within a contract.
| API Endpoint | /api/v1/contracts/{contractId}/subscriptions |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Path parameters | Required | Description |
|---|---|---|
| contractId | yes | String ; contractId |
| Query parameters | Required | Description |
|---|---|---|
| page | no | number >= 1 ; Page number, defaults to ‘1’ |
| itemsPerPage | no | number >= 1 |
| type | no | string ; view change-detection |
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id}/subscriptions \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id}/subscriptions");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contract_id}/subscriptions"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
Here you can see an example of the data returned:
Let’s look at some of the parameters above in more detail:
| Tag | Description |
|---|---|
| id | Unique subscription identification object relating to the subscription. |
| status | Status of the subscription. |
| startedAt | Start date of the subscription. |
| endedAt | End date of the subscription. |
| service | Corresponds to the OneAtlas related service. |
| isAmountEstimated | Indicates whether amount is estimated or not. |
| title | Custom title of the subscription. |
| kind | Kind of the subscription, can be subscription.data.premium, subscription.oneatlas… |
| offers | Offers, can be order.data.gb.product for example. |
Premium users will also have a OneAtlas subscription alongside their subscription plan. You can see this in the example above. This is a generic subscription given to all OneAtlas Data premium users. This gives you access to OneAtlas Data services, without this you will not have permission to use the full services.
Get Information for a Specific Subscription
This API is used to retrieve a subscription related to a contract.
| API Endpoint | /api/v1/contracts/{contractId}/subscriptions/{subscriptionId} |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Path parameters | Required | Description |
|---|---|---|
| contractId | yes | String ; contract Id |
| subscriptionId | yes | String ; subscription Id |
Here is an example to retrieve information on a subscription within a contract:
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/subscriptions/{subscriptionId} \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/subscriptions/{subscriptionId}");
xhr.setRequestHeader("Authorization", "Bearer");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/subscriptions/{subscriptionId}"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
For information related to your streaming plans please see the table below:
| Streaming plan name | Description |
|---|---|
| discover | Includes the right to stream 1 GB |
| starter | Includes the right to stream 4 GB |
| standard | Includes the right to stream 10 GB |
| advanced | Includes the right to stream 30 GB |
Revoke a Subscription
| API Endpoint | /api/v1/subscriptions/{subscription_id}/revoke |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
Revoking is based on how many “runs” there are within your subscription. A quarterly subscription contains a max/min of 2 runs (2 runs * 3 months = 6 months). A monthly subscription can contain between a minimum of 2 runs (2 months) and a maximum of 6 runs (6 months). It is possible to revoke during a run, but the subscription will only stop at the end of the period.
You can revoke a subscription by passing the subscriptionId into the endpoint /revoke:
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/{subscriptionId}/revoke \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/{subscriptionId}/revoke");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/{subscriptionId}/revoke"
headers = {
'Authorization': "Bearer",
'Cache-Control': "no-cache",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
Once you have revoked your subscription, you will receive your newly updated subscription information with a new end date.
Refunding Your Account
If you revoke a monthly change detection subscription, you will be refunded for the months you have not used. For example, if you have a 4 month subscription starting in August and you decide to revoke on August 20th, you will be refunded the period September till November.
A quarterly subscription has a min/max of 2 runs (6 months). Therefore if you revoke during a quarterly subscription, you will be refunded for the 3 month quarter which you have not used. For example, if you have a quarterly subscription from January until June (6 months) and you revoke in March, you will be refunded the period April till June.
If your subscription has not started it will be instantly revoked and a full refund will be received.
Get Subscription consumption
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/subscriptions?service=data |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
You can use this endpoint to track accurately your remaining credit and how much have been spent on streaming and imagery ordering.
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/subscriptions?service=data \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/subscriptions?service=data");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/subscriptions?service=data"
headers = {
'Authorization': "Bearer",
'Cache-Control': "no-cache",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
The response you get is the following:
Get Payments for a Contract
| API Endpoint | /api/v1/contracts/{contractId}/payments |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Parameters | Required | Description |
|---|---|---|
| contractId | yes | String ; contract id |
| paymentId | yes | String ; payment id |
| Query parameters | Required | Description |
|---|---|---|
| page | no | number >= 1 ; Page number, defaults to ‘1’ |
| itemsPerPage | no | number >= 1 |
You can use the following request to check your payments relating to your contract:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments' \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
This will return:
Get Payments for a Subscription
| API Endpoint | /api/v1/subscriptions/{subscriptionId}/payments |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Parameters | Required | Description |
|---|---|---|
| contractId | yes | String ; contract id |
| subscriptionId | yes | String ; payment id |
| Query parameters | Required | Description |
|---|---|---|
| page | no | number >= 1 ; Page number, defaults to ‘1’ |
| itemsPerPage | no | number >= 1 |
You can use the following request to retrieve your payment information relating to a subscription:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/subscriptions/{subscriptionId}/payments' \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/subscriptions/{subscriptionId}/payments");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/subscriptions/{subscriptionId}/payments"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
This will return:
Get Payment for a Contract and Payment ID
| API Endpoint | /api/v1/contracts/{contractId}/payments/{paymentId} |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Parameters | Required | Description |
|---|---|---|
| contractId | yes | String ; contract id |
| paymentId | yes | String ; payment id |
Here is an example to get payment information for a contract:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments/{paymentId}' \
-H 'Authorization: Bearer ' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments/{paymentId}");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/{contractId}/payments/{paymentId}"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
This will return:
Get Payment for an Order
| API Endpoint | /api/v1/orders/{orderId} |
| REST verb | GET |
| Authentication | Bearer Token |
| API Reference | https://data.api.oneatlas.airbus.com/ |
| API Get request | (Use the access token retrieved during authentication step). |
| Parameters | Required | Description |
|---|---|---|
| orderId | yes | String ; order id |
Here is an example to get payment and deliveries information for an order:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/orders/{orderId}' \
-H 'Authorization: Bearer ' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/orders/{orderId}");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/orders/{orderId}"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
This will return:
Search
Our OneAtlas Data Living Library includes:
- nearly all daily acquisitions of Pléiades (50cm) imagery since the end of 2017. An extensive archive over North America, Europe, Asia and Middle East is also included going back 2 years.
- a selection of the best Pléiades Neo acquisitions since its launch over selected areas of interest
The search APIs allows users to express complex searches by filtering different parameters and specifying geographic criteria.
Prerequisites
If you haven’t already, see our Authentication Guide for information on how to acquire and use an API key and generate tokens to access to our endpoints.
Endpoint
The OneAtlas Data search API is compliant with the OpenSearch specification. The official specification documentation can be used as a reference: http://www.opensearch.org/.
| API Endpoint | https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch |
| REST verb | GET / POST |
| Authentication | Bearer access token |
| API Reference | Ordering API |
Here are some example of searches with the Search API, more details can be found here.
Search Scope
A search scope defines the resources included in your search. The public workspace in which images are searched is unrestricted and accessible to any OneAtlas user.
In addition to this public workspace, any OneAtlas user has a private workspace which contains product that belongs to the user.
By default, a search is performed within all the workspaces you can reach, so the public scope and your personal workspace.
For example, here below is an example of a default images search in the public workspace and your personal workspace:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch' \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json'
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
headers = {
'authorization': "Bearer <access_token>",
'content-type': "application/json",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, verify=False)
print(response.text)
In addition, to proceed to a search in a private workspace, a user must retrieve first its workspaceId. To do so, the /me endpoint should be used:
curl --silent -k -X GET -H " Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache" \
"https://data.api.oneatlas.airbus.com/api/v1/me" | python -m json.tool |grep workspace | cut -d "\"" -f4
Example of id returned:
a20d890b-901c-4028-b7c3-f4efca2720e3
Finally, searching for products in your private workspace simply consists of adding a search criteria of your workspaceId. You can also decide to search images only within the Pléiades Neo products or within the SPOT and Pléiades products. For this, you can use the parameter workspace in your request with the value public for the Pléiades & SPOT catalog and public-pneo for the Pléiades Neo catalog.
Below is an example of a call for an image search within your personal workspace:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?workspaceid=a20d890b-901c-4028-b7c3-f4efca2720e3' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
vvar data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?workspaceid=a20d890b-901c-4028-b7c3-f4efca2720e3");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.send(data);
import requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"workspaceid":"a20d890b-901c-4028-b7c3-f4efca2720e3"}
headers = {
'Cache-Control': "no-cache",
'Authorization': "Bearer <access_token>"
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)
Note: When searching, you will receive results from the full catalog as well as the Living Library. If you want to search only Living Library results, you will need to filter using
processingLevel. This value could be equal to SENSOR (images which meet Living Library criteria) and ALBUM (images that do not meeting Living Library criteria in terms of incidence angle and cloud cover. They can not be streamed on-the-fly but you will be able to order them soon, for delivery in your private workspace). Below is an example of a call:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?processingLevel=SENSOR' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
Note: Unfortunately, our stereo and tri-stereo products are not available via Living Library APIs or on OneAtlas portal. If you order such a product, the delivery will never be completed. We strongly advise to filter
productTypewith the value mono to avoid any confusion in your research.
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?productType=mono' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
Geographic Filters
The search API returns all images that intersect with a requested extent. The extent could be a circle, a bounding box or a polygon described using the WKT (Well Know Text) standard.
Search with a Circle
Below is an example to search for images within a circular area measuring 1000 meters in diameter centered over Toulouse:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?lat=43.60426&lon=1.44367&radius=1000' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?lat=43.60426&lon=1.44367&radius=1000");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.send(data);
import requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"lat":"43.60426","lon":"1.44367","radius":"1000"}
headers = {
'Cache-Control': "no-cache",
'Authorization': "Bearer <access_token>",
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)
The center of the circle is expressed as a longitude and latitude coordinates, in decimal degrees in EPSG:4326 (typical WGS84 coordinates as returned by a GPS receiver). The request also includes a “radius” parameter that specifies the search radius.
Search Within a Bounding Box
The search could be performed within a bounding box. The box is defined by “west, south, east, north” coordinates of longitude, latitude, in a EPSG:4326 decimal degrees. This is also commonly referred to by minX, minY, maxX, maxY (where longitude is the X-axis, and latitude is the Y-axis), or also SouthWest corner and NorthEast corner.
Here below is an example to search for images within a bounding box over San Francisco (-122.537,37.595,122.303,37.807).
curl -X GET -H "Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache" \
"https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?bbox=-122.537,37.595,-122.303,37.807"
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?bbox=-122.537,37.595,-122.303,37.807");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.send(data);
import requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"bbox":"-122.537,37.595,-122.303,37.807"}
headers = {
'Cache-Control': "no-cache",
'Authorization': "Bearer <access_token>",
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)
Search Within a Polygon
The search could be performed within a polygon. This polygon must be defined according the WKT (Well Known Text) norm. This norm is design to define geographic areas using a simple textual formalism. The norm specification could be found on Wikipedia or directly on the OGC web site.
Here below is an example to search for images over Gibraltar:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?relation=intersects&geometry=POLYGON%28%28-5.350972006554837%2036.10903284026139,-5.368052313561666%2036.15274102495853,-5.330715964074367%2036.153122194644425,-5.343590567345846%20036.1086861277239,-5.350972006554837%2036.10903284026139%29%29' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?relation=intersects&geometry=POLYGON%28%28-5.350972006554837%2036.10903284026139,-5.368052313561666%2036.15274102495853,-5.330715964074367%2036.153122194644425,-5.343590567345846%20036.1086861277239,-5.350972006554837%2036.10903284026139%29%29");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.send(data);
uimport requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"relation":"intersects","geometry":"POLYGON%28%28-5.350972006554837%2036.10903284026139,-5.368052313561666%2036.15274102495853,-5.330715964074367%2036.153122194644425,-5.343590567345846%20036.1086861277239,-5.350972006554837%2036.10903284026139%29%29"}
headers = {
'Cache-Control': "no-cache",
'Authorization': "Bearer <access_token>"
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)
Field Filters
By utilizing multiple fields, complex criteria can be expressed across, with a variety of conditions. All field filters require a field name and a filter-specific value.
Filter per Image Resolution
You can use the constellation field value to filter by image resolution:
| Field name | Value | Resolution |
|---|---|---|
| constellation | PNEO | 0.3m |
| SPOT | 1.5m | |
| PHR | 0.5m |
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?constellation=PHR' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "http://https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?constellation=PHR");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"constellation":"PHR"}
headers = {
'authorization': "Bearer <access_token>",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, params=querystring, verify=False)
print(response.text)
Filter per Acquisition Date
In addition to a filter per image resolution, you may want to filter per acquisition date. To do so, an interval defined by a starting date and an ending date should be specified. For example, the following request searches for images which have an acquisition date between the 20 April 2018 and 04 June 2018:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?acquisitionDate=[2018-04-20T00:00:00.000Z,2018-06-04T00:00:00.000Z]' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?acquisitionDate=[2018-04-20T00:00:00.000Z,2018-06-04T00:00:00.000Z]");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"acquisitionDate" :"[2018-04-20T00:00:00.000Z,2018-06-04T00:00:00.000Z]" }
headers = {
'authorization': "Bearer <access_token>",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, params=querystring, verify=False)
print(response.text)
Filter per Cloud Coverage
The images added to the OneAtlas living library do not contain more than 30% of clouds. If you need to filter images to select only images having less that 10% of cloud you can use the field cloudCover and provide the expected interval. For example, the following request filters images having a cloud coverage lower that 10%:
curl -X GET -H 'Authorization: Bearer <access_token>' \
-H "Cache-Control: no-cache" \
"https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?cloudCover=[0,10]"
Not available.
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"cloudCover":"[0,10]"}
headers = {
'authorization': "Bearer <access_token>",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, params=querystring, verify=False)
print(response.text)
Sort Results
By default, the search results are sorted per acquisition date (newest data is displayed first) and per cloud coverage (less cloudy images are displayed first). For specific needs, you can specify your own sort criteria. For example, the following request sorts the search results per incidenceAngle:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?sortBy=incidenceAngle' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "http://https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?sortBy=incidenceAngle");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"sortBy":"incidenceAngle"}
headers = {
'authorization': "Bearer <access_token>",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, params=querystring, verify=False)
print(response.text)
In the above example, the incidenceAngle value request for a ranking from the lowest value to the highest, while the -incidenceAngle would provide the reverse result.
The processingLevel property enables you to filter images according to Living Library criteria (Cloud cover under 30% and Incidence angle under 40°). Without filter, you will have full access to the Pléiades and SPOT archive imagery. The value SENSOR for this property filters images which meet Living Library criteria. The value ALBUM filters images which do not meet Living Library criteria, these images can not be streamed on the fly but you will soon be able to order them for delivery in your private workspace.
Paginate Results
The Living Library is updated on a daily basis and the number of images it contains is huge. To access to your complete set of results, to a max of 10,000 per search request, the results are paginated. By default, a page contains up to 50 results, with a max of 500.
For example, the following request displays the results for page 3, 100 results being contained in each page:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?itemsPerPage=100&startPage=3' \
-H 'authorization: Bearer <access_token>' \
-H 'cache-control: no-cache' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?itemsPerPage=100&startPage=3");
xhr.setRequestHeader("authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
url = "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch"
querystring = {"itemsPerPage":"100","startPage":"3"}
headers = {
'authorization': "Bearer <access_token>",
'cache-control': "no-cache",
}
response = requests.request("GET", url, headers=headers, params=querystring, verify=False)
print(response.text)
Results
Each matching image is returned as a GeoJSON feature under the features[] property. The response should look like:
A search response body contains the following components for each feature:
_links: Contains all the endpoints to access to the imagery in full resolution (using OGC protocols) or to access to the quicklooks.geometry: Represents the footprint of the image. It’s a GeoJSON Polygon in WGS84 coordinates that represents the geographic area that was acquired by the satellite.rights: Contains information regarding your authorization rights.properties: Contains detailed metadata of the image. The most meaningful data is displayed in the table below.
| Field name | Description |
|---|---|
| id | Unique identifier of the image in the catalog |
| parentIdentifier | Corresponds to the Datastrip identifier, a datastrip being a portion of image downlinked during a pass of the satellite to a given ground station |
| acquisitionDate | Corresponds to he acquisition date of the image |
| cloudCover | Correspond to the average cloud coverage of an image, 0 meaning that the image is cloud free and 100 that the image is totally cloudy |
| snowCover | Corresponds to the average snow coverage of an image, 0 meaning that the image is snow free and 100 that the image is totally snowy |
| constellation | Name of the constellation, in the case of OneAtlas Data this value could be equal to SPOT of PHR |
| platform | Name of the satellite, in the case of OneAtlas Data, this value could be equal to SPOT6, SPOT7, PHR1A or PHR1B |
| incidenceAngle | The incidence angle is the angle from the target point of view. It represents the angle between the ground normal and look direction from the satellite, combining the pitch and roll angles. |
| resolution | This corresponds to the satellite used. 0.5 for Pléiades and 1.5 for SPOT. |
| processingLevel | This value could be equal to SENSOR (images which meet Living Library criteria) and ALBUM (images that do not meet Living Library criteria in terms of Incidence angle and Cloud cover. They can not be streamed on the fly but you will soon be able to order them for delivery in your private workspace) |
Order from Analytics Toolbox
Ordering from Analytics Toolbox allows you to run an analytic on selected Living Library image(s) to generate a geojson report on your AOI that can be directly used in your GIS tool.
Analytics prerequisites
If you haven’t already, see our Authentication Guide for information on how to acquire and use an API key and generate tokens to access to our endpoints.
List available Analytics
To place an order for an Analytics Toolbox report, you will need the code and type of the analytic you want to run. The endpoint to get the list of available analytics in Analytics Toolbox is:
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/analytics |
| REST verb | GET |
| Authentication | JWT Token |
Here below is an example of a call:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/analytics' \
-H 'Authorization: Bearer <access_token>' \
-H 'Content-Type: application/json'
And the associated response :
The sensor indicates which constellation / resolution this analytic supports. Selected images must be in a supported resolution.
The type indicates the number of images this analytic requires objects analytics run on a single image to detect elements changes analytics compare a pair of images
If there are a lot of results, there is a pagination mechanism, you can use the itemsPerPage parameter to set the number of results per page and page parameter to navigate through the pages.
Search Images
To place an order for an Analytics Toolbox report, you will also need the id of the image(s) on which you want to run the analytic.
See our detailed Search Guide for information on how to search images within One Atlas.
Note: Only PRIMARY images are fully supported by all analytics therefore the images you use must have
processingLevel=SENSOR
The endpoint to search images is:
| API Endpoint | https://search.foundation.api.oneatlas.airbus.com/api/v1/opensearch |
| REST verb | GET |
| Authentication | JWT Token |
| API Reference | Search API |
For our example, we will search all PHR images available on our AOI between May 1st and Aug 31st 2019, that have no more that 10% clouds, a maximum incidence angle of 20° and have SENSOR processingLevel.
In this case the JSON structure would be:
We will pick the 2 following images: 37bbfd56-7230-4875-a85f-5d9dc4b6e440 and 95e0b8fc-7bd1-404f-8f9c-a1798a45d57a
Calculate the Price of an Analytic Report
When calculating the price of an Analytic Report, you must provide the following parameters.
| aoi | The AOI must be described as GeoJSON geometry. Only polygons are accepted. |
| analytic | The code of the analytic to run. |
| resolution | The imagery resolution in meters. Accepted values are either 0.5 for Pléiades or 1.5 for SPOT. Some analytics only work on specific resolution, see analytics sensor. |
| imageIds | The code of the image(s). The analytic type indicate the number of images to provide: objects analytics require 1 image while changes analytics require 2 images. |
| title | The name/reference you want to give the report. |
The endpoint to get a price for an Analytic Report is:
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/prices |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
The only and mandatory parameter is a JSON payload following this schema:
Below is an example of the call:
curl -X POST \
'https://data.api.oneatlas.airbus.com/api/v1/prices' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json'
-d '{
"kind": "order.analytics-toolbox.archive",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[-115.257324821538006, 36.135202530042903],
[-115.119528582773995, 36.137064237966598],
[-115.118644547198002, 36.062608357774501],
[-115.256536683516998, 36.062233041334402],
[-115.257324821538006, 36.135202530042903]
]
]
},
"analytic": "analytic.airbus.change-detection",
"resolution": 0.5,
"imageIds": [
"37bbfd56-7230-4875-a85f-5d9dc4b6e440",
"95e0b8fc-7bd1-404f-8f9c-a1798a45d57a"
],
"title": "Change Detection - Las Vegas"
}
The response is shown below:
The results are split into three different sections; payload, deliveries and price. The payload shows the input that you have submitted to the server. The deliveries will contains the link to the report file once generated. The price indicate the amount of credits that the order will cost.
Order of an Analytic Report
Once you calculated the price of a report you can then place the order. To proceed, the following endpoint must be used:
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/orders |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
The payload of the order request is exactly like the one used to calculate the price:
Below is an example of the call:
curl -X POST \
'https://data.api.oneatlas.airbus.com/api/v1/prices' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json'
-d '{
"kind": "order.analytics-toolbox.archive",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[-115.257324821538006, 36.135202530042903],
[-115.119528582773995, 36.137064237966598],
[-115.118644547198002, 36.062608357774501],
[-115.256536683516998, 36.062233041334402],
[-115.257324821538006, 36.135202530042903]
]
]
},
"analytic": "analytic.airbus.change-detection",
"resolution": 0.5,
"imageIds": [
"37bbfd56-7230-4875-a85f-5d9dc4b6e440",
"95e0b8fc-7bd1-404f-8f9c-a1798a45d57a"
],
"title": "Change Detection - Las Vegas"
}
The response is shown below:
The results give you the id of the order.
Order Status
To get the most current order status, you can call the following endpoint using the id obtained above.
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/orders/ |
| REST verb | GET |
| Authentication | JWT Token |
| API Reference | Order API |
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/orders/<order_id>' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json'
Note: You can also just follow the link
_links.self.hrefin the response above to get the most recent result.
The order status will say ordered while it is being processed. Once the report produced, the order will switch to delivered. The order can have the following statuses:
| Status | An error occurred during the production process. |
| error | POST |
| delivered | The report has been produced and available in your private workspace. |
| ordered | The report has just been ordered and will be processed; the production is in progress. |
| rejected | The order has been rejected, insufficient balance. |
List Orders
The /orders endpoint can be used to retrieve your orders:
| API Endpoint | https://data.api.oneatlas.airbus.com/api/v1/orders/ |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
A filter could be associated to this request to display orders that have a specific status.
For example, listing the 10 last delivered orders could be requested by using the following:
curl -X GET \
'https://data.api.oneatlas.airbus.com/api/v1/orders?status=delivered&kind=order.analytics-toolbox.archive&page=1&itemsPerPage=10' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json'
If there are a lot of results, there is a pagination mechanism, you can use the itemsPerPage parameter to set the number of results per page and page parameter to navigate through the pages.
Retrieve the Report
Once your order status is delivered, the deliveries[0]._links.download.href in the order response will contain a link to download your report.
You can then send a GET request to output your file as a geojson file:
curl -X GET \
'https://access.foundation.api.oneatlas.airbus.com/api/v1/items/90ebd420-fab4-49b7-85cd-ced051ea2343/download' \
-H 'Authorization: Bearer <access_token>' \
-o output_file.geojson
Order an Individual Product
Ordering an individual product will provide you a chance to select an OneAtlas data Living Library image, clip it to your AOI, process it using your custom parameters and get delivered in your workspace. Once delivered, you will be able to download or stream the resulting product.
Note: When ordering a product your AOI must be minimum 0.1km² for all products.
Note: Unfortunately, our stereo and tri-stereo products are not available via Living Library APIs or on OneAtlas portal. If you order such a product, the delivery will never be completed.
When retrieving the price or ordering a product there will be parameters that you need to specify for the API to calculate the correct price. The same parameters will need to be specified when you place your order. This section will guide you through the available parameters for our Ordering API.
As Living Library offers several consumption modes, you will have to define the order kind you want to use:
| Order kind | Consumption mode | Description | Sensors |
|---|---|---|---|
| order.data.product | km² | Consumption based on km² | SPOT and Pléiades and Pléiades Neo |
| order.data.product | Tiles - This mode will be abandoned soon | Consumption based on number of tiles viewed | SPOT and Pléiades only |
| order.data.gb.product | GB (GigaBytes) - This mode will be abandoned soon | Consumption based on processed GB | SPOT and Pléiades only |
Available product types are:
| Product type | Description | Sensors |
|---|---|---|
| bundle | one Panchromatic image + the Multispectral bands delivered separately | SPOT and Pléiades |
| pansharpened | merging the Panchromatic with the full set of colour bands | SPOT and Pléiades |
| panchromatic | one Panchromatic image | SPOT and Pléiades |
| multiSpectral | the Multispectral (Blue, Green, Red and Near Infrared) bands | SPOT and Pléiades |
| bundle-fs | one Panchromatic image + the Multispectral bands delivered separately | Pléiades Neo |
| pansharpened-fs | merging the Panchromatic with the full set of colour bands | Pléiades Neo |
Available image format are:
| Image Format | Description |
|---|---|
| image/jp2 | The format of the delivered image will be JPEG 2000 |
| image/geotiff | The format of the delivered image will be Geotiff |
Available EPSG code are:
| Image Projection | Description |
|---|---|
| EPSG:4326 | Geodetic coordinate system for World using Uses simple Equirectangular projection |
| EPSG:326[01-60] | WGS 84 north zones |
| EPSG:327[01-60] | WGS 84 south zones |
Available radiometric processing types are:
| Radiometric Processing | Description | Sensors |
|---|---|---|
| BASIC16 | No radiometric processing applied. | SPOT and Pléiades only |
| REFLECTANCE | Radiometrically corrected images (sensor calibration and systematic atmospheric effects) | SPOT and Pléiades and Pléiades Neo |
| DISPLAY | Optimized for visual rendering. 8-bit pixel only. | SPOT and Pléiades and Pléiades Neo |
Calculate Price for an Individual Product
When calculating the price of an individual product you must specify certain parameters. The JSON structure to provide has the form:
To calculate the price of a product the following endpoint must be used:
| API Endpoint | /api/v1/prices |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
Below is an example of a call:
curl -X POST \
https://data.api.oneatlas.airbus.com/api/v1/prices \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
-d '{
"kind": "order.data.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
}'
var data = JSON.stringify({
"kind": "order.data.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
});
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("POST", "https://data.api.oneatlas.airbus.com/api/v1/prices");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
headers = {
'Authorization': token,
'Content-Type': "application/json",
'Cache-Control': "no-cache",
}
url = "https://data.api.oneatlas.airbus.com/api/v1/prices"
payload = {
"kind": "order.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
}
response = requests.request("POST", url, json=payload,headers=headers)
Note: Your
kindmust beorder.data.productif you have a GB subscription (soon to be deprecated), ororder.data.productif you have either a tiles subscription (soon to be deprecated) or a km² subscription. Pléiades Neo is only accessible through km² subscription.
Here is a snippet of the response showing the price:
The response provides information regarding the number of credits that will be decrease from the customer account when the order will be placed.
Place an Order for an Individual Product
Once you calculated the price of an individual product, you can place the order for true. If you are ready to proceed, then the following endpoint must be used:
| API Endpoint | /api/v1/orders |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
The JSON structure to use is equivalent to the structure used to calculate the price:
{
"kind": "order.data.product",
"products": [
{
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"productType": "pansharpened",
"radiometricProcessing": "DISPLAY",
"aoi": {
"type": "Polygon",
"coordinates": [
...
}
}
]
}
Below is an example of a call:
curl -X POST \
https://data.api.oneatlas.airbus.com/api/v1/orders \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
-d '{
"kind": "order.data.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
}'
var data = JSON.stringify({
"kind": "order.data.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
});
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("POST", "https://data.api.oneatlas.airbus.com/api/v1/orders");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/orders"
payload = {
"kind": "order.data.product",
"products": [
{
"productType": "bundle",
"radiometricProcessing": "REFLECTANCE",
"imageFormat": "image/jp2",
"crsCode": "urn:ogc:def:crs:EPSG::4326",
"id": "d42de348-110b-4ed6-a597-755867b3ee54",
"aoi": {
"type": "Polygon",
"coordinates": [
[
[1.4089965820312502, 43.59829500262717],
[1.4089965820312502, 43.63408731864001],
[1.5078735351562496, 43.63408731864001],
[1.5078735351562496, 43.59829500262717],
[1.4089965820312502, 43.59829500262717]
]
]
}
}
]
}
headers = {
'Authorization': "Bearer <access_token>",
}
response = requests.request("POST", url, json=payload, headers=headers)
print(response.text)
Note: Your
kindmust beorder.data.productif you have a GB subscription (soon to be deprecated), ororder.data.productif you have either a tiles subscription (soon to be deprecated) or a km² subscription. Pléiades Neo is only accessible through km² subscription.
Here you can see the initial response with status ordered.
Within a few minutes your status will change from ordered to delivered.
Place an order for a product list
| API Endpoint | /api/v1/orders |
| REST verb | POST |
| Authentication | JWT Token |
| API Reference | Order API |
Here is an example of Body request
Here you can see the initial response with status ordered.
View Order Status
The /orders endpoint can be used to retrieve the status of your orders:
| API Endpoint | /api/v1/orders |
| REST verb | GET |
| Authentication | JWT Token |
| API Reference | Order API |
Here below is an example of a call:
curl -X GET "https://data.api.oneatlas.airbus.com/api/v1/orders" \
-H "Authorization: Bearer <access_token>" \
-H "Content-Type: application/json" \
-H "Cache-Control: no-cache"
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = false;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/orders");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/orders"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json",
'Cache-Control': "no-cache",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
A filter could be associated to this request to display orders that have a specific status. Available statuses for orders are the following ones:
| Status | Description |
|---|---|
| error | An error occurred during the production process. |
| delivered | The products have been produced and available in your private workspace. |
| ordered | The products have just been ordered and will be processed; the production is in progress. |
| rejected | The order has been rejected, insufficient balance. |
Also, it is possible to filter per product kind, two kinds being available:
| Kind | Description |
|---|---|
| order.data.product | Individual image product |
| order.analytics-toolbox.archive | Individual Analytics Toolbox product |
If there are a lot of results to list, there’s a pagination mechanism to limit the number of results. If you want to activate it, the itemsPerPage parameter can be used.
For example, listing the first order delivered could be requested by using the following:
curl -X GET "https://data.api.oneatlas.airbus.com/api/v1/orders?status=delivered&kind=order.subscription.streaming&page=1&itemsPerPage=1" \
-H "Authorization: Bearer <access_token>" \
-H "Content-Type: application/json" \
-H "Cache-Control: no-cache"
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = false;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/orders??status=delivered&itemsPerPage=1");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
Not available
And the associated response:
View Service
The OneAtlas Data View service allow users to easily access to images without having to download and maintain DIMAP products. This guide will walk you though using WMS and WMTS to stream on the fly.
Prerequisites: If you haven’t already, see our Authentication Guide for information on how to acquire an API key and generate tokens to access to our endpoints. If you would like to try the examples in this guide, ensure that GDAL Geospatial Data Abstraction Library is installed.
Preview Images
A preview is simple way to get a rapid insight of the imagery. The preview images include three bands (Blue, Red and Green), the pixel depth is 8 bits. A preview is neither orthorectified nor geolocalized. There are two kinds available:
| Kind | Description |
|---|---|
| Thumbnails | The thumbnail is a very reduced size version of the image. Its size depends of each image but is approximately 150 × 300 pixels. |
| Quicklook | The quicklook is a reduced size version of the image. Its size depends of each image but is approximately 2500 × 5000 pixels. |
The endpoints follow always the same pattern:
| Preview type | Endpoint |
|---|---|
| thumbnail | https://access.foundation.api.oneatlas.airbus.com/thumbnail/<image_id> |
| quicklook | https://access.foundation.api.oneatlas.airbus.com/quicklook/<image_id> |
To access a thumbnail or a quicklook you first need to perform a search in our Living Library to grab the corresponding id. You can see an example of a quicklook within our Search Guide. Alternatively we can grab the quicklook URL by inputting the sourceIdentifier into this cURL command:
curl -k -L --silent -X GET "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?sourceIdentifier=DS_PHR1B_201805071126173_FR1_PX_W004N43_0309_01462" |python -m json.tool | grep "/quicklook" \
-H "Cache-Control: no-cache" \
-H "Authorization: Bearer <access_token>"
Not available.
Not available.
Here you can see the quicklook URL returned:
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/quicklook",
To download the quicklook image you can use an additional request. You can also specify the width of the quicklook by using parameters at the end of the URL (e.g. ?width=xxx).
curl --silent -X GET "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/quicklook" > quicklook.jpg \
-H "Authorization: Bearer <access_token>"
Not available.
Not available.
Now we can retrieve detailed information such as the size of the image using the gdalinfo utilitary:
> gdalinfo quicklook.jpg
Driver: JPEG/JPEG JFIF
Files: quicklook.jpg
Size is 909, 735
Coordinate System is `'
Image Structure Metadata:
COMPRESSION=JPEG
INTERLEAVE=PIXEL
SOURCE_COLOR_SPACE=YCbCr
Corner Coordinates:
Upper Left ( 0.0, 0.0)
Lower Left ( 0.0, 735.0)
Upper Right ( 909.0, 0.0)
Lower Right ( 909.0, 735.0)
Center ( 454.5, 367.5)
Band 1 Block=909x1 Type=Byte, ColorInterp=Red
Overviews: 455x368, 228x184
Image Structure Metadata:
COMPRESSION=JPEG
Band 2 Block=909x1 Type=Byte, ColorInterp=Green
Overviews: 455x368, 228x184
Image Structure Metadata:
COMPRESSION=JPEG
Band 3 Block=909x1 Type=Byte, ColorInterp=Blue
Overviews: 455x368, 228x184
Image Structure Metadata:
COMPRESSION=JPEG
Full Resolution Images
The OGC (Open Geospatial Consortium) is an international not for profit organization committed to making quality open standards for the global geospatial community. These standards are made through a consensus process and are freely available for anyone to use to improve sharing of the world’s geospatial data.
In the frame of the OneAtlas Data service, the WMTS, WMS and WCS protocols are provided to ease the use and the display of imagery in desktop GIS applications (QGIS, ArcMap) or any web mapping platforms that provide WMTS, WMS or WCS support.
The protocols provide the access to OneAtlas data images referenced in the public catalog, as well as your processed products in your private workspace up to their full resolution.
There are three kinds of images available:
| Multispectral | - Multispectral images include three multispectral (color) bands (Blue, Red and Green), the pixel depth is 8 bits. - The product pixel size is 6m for SPOT images and 2m for Pléiades images. - Images with optimized true color rendering (Display) - adjusted luminosity and contrast and preserved color balance. - The images are orthorectified with a geolocation accuracy of 10m CE 90. |
| Panchromatic | - Panchromatic images include includes only one black and white band. - The pixel depth is 8 bits. - The product pixel size is 1.5m for SPOT images and 0.5m for Pléiades images. - The images are orthorectified with a geolocation accuracy of 10m CE 90. |
| Pan-sharpened - Available on the fly | - Pan-sharpened products combine the visual information of the multispectral data with the spatial information of the panchromatic data, resulting in a higher resolution 0.5-m color product. - The pixel depth is 8 bits. - The product pixel size is 1.5m for SPOT images and 0.5m for Pléiades images. - Images with optimized true color rendering (Display)- adjusted luminosity and contrast and preserved color balance. - The images are orthorectified with a geolocation accuracy of 10m CE 90. |
WMS, WMTS and WCS
WMS
The OpenGIS® Web Map Service Interface Standard (WMS) provides a simple HTTP interface for requesting geo-registered map images from one or more distributed geospatial databases. A WMS request defines the geographic layer(s) and area of interest to be processed. The response to the request is one or more geo-registered map images (returned as JPEG, PNG, etc) that can be displayed in a browser application. The interface also supports the ability to specify whether the returned images should be transparent so that layers from multiple servers can be combined or not.
WMTS
The Web Map Tile Service (WMTS) service conforms to the WMTS Simple profile norm. According the reference, this service provides a pyramid of tiles in two different projections: WebMercator (EPSG:3857) and Geographic (EPSG:4326), these will be discussed in further detail.
WCS
The OpenGIS® Web Coverage Service (WCS) provides an open specification for sharing raster datasets on the web. A WCS service returns data in a format that can be used as input for analysis and modeling. This is in contrast with the OGC Web Map Service (WMS), which only returns a picture of the data.
Streaming On the Fly
Note: This requires a streaming plan. See our Manage Contract Guide if you do not yet have a subscription.
If you have sufficient GB, OneAtlas Data will allow you to stream pansharpened imagery on the fly just by searching through our Living Library. The simple example below using the /opensearch endpoint retrieves everything within the Living Library:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v1/opensearch");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v1/opensearch"
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json"
}
response = requests.request("GET", url, headers=headers)
print(response.text)
Note: Images which can not meet the Living Library criteria can not be streamed on the fly, you may only view thumbnails, quicklooks and order them. They can be filtered thanks to the following property
processingLevelwith the value ALBUM. The value SENSOR enables to filter images which can be streamed and meet Living Library criteria.
To learn how to search by AOI, resolution, id and more, refer to our Search Guide. Once you have ordered your product, you will retrieve your WMTS, WMS and WCS URLs:
"wmts": {
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wmts",
"name": "WMTS",
"type": "WMTS"
},
"wms": {
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wms",
"name": "WMS",
"type": "WMS"
}
"wcs": {
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wcs",
"name": "WCS",
"type": "WCS"
}
We will look at how you can use these URLs in more detail further in the guide.
Streaming from Your Workspace
Your workspace provides your contract with an area of all purchased imagery. All users on the same contract will have access to the same workspace. These images will be in type bundle which will allow you to stream either Panchromatic or Multispectral images. If you wish to stream imagery already within your workspace, you can filter using your workspaceId:
curl -X GET \
'https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?workspaceId=<workspace_id>' \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://search.foundation.api.oneatlas.airbus.com/api/v1/opensearch?workspaceId=<workspace_id>");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(data);
import requests
url = "https://search.foundation.api.oneatlas.airbus.com/api/v1/opensearch"
querystring = {"workspaceId":"<workspace_id>"}
headers = {
'Authorization': "Bearer <access_token>",
'Content-Type': "application/json"
}
response = requests.request("GET", url, headers=headers, params=querystring)
print(response.text)
Alternatively, you can do this in one cURL command bif you know the sourceIdentifier:
curl --silent -k -L -X GET "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?sourceIdentifier=DS_PHR1B_201805071126173_FR1_PX_W004N43_0309_01462" \
-H "Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache" \
| python -m json.tool | egrep "href"
Not available.
Not available.
This will return all URLs related to the sourceIdentifier that you have provided:
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/metadata",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/delete",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/quicklook",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/thumbnail",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wms",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wmts",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wcs"
Panchromatic and Multispectral
By using the WMTS URL above, this will stream Panchromatic imagery by default. If you wish to stream Multispectral you can use the Metadata URLs returned in your workspace:
"imagesMetadata": [
{
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/9c41e689-3069-409a-ace7-af8cc512223e/images/1e2cf2fa-449a-43fe-ae2e-60df4bbbe5f7/metadata",
"name": "panchromatic",
"type": "application/geo+json"
},
{
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/9c41e689-3069-409a-ace7-af8cc512223e/images/6950d957-58af-442d-ab3f-d684b917f423/metadata",
"name": "multispectral",
"type": "application/geo+json"
}
]
You will need to amend your URL to fit the Multispectral metadata URL as follows:
# Example of WMS request for multispectral
https://access.foundation.api.oneatlas.airbus.com/api/v1/items/9c41e689-3069-409a-ace7-af8cc512223e/images/6950d957-58af-442d-ab3f-d684b917f423/wms
# Example of WMTS request for multispectral
https://access.foundation.api.oneatlas.airbus.com/api/v1/items/9c41e689-3069-409a-ace7-af8cc512223e/images/6950d957-58af-442d-ab3f-d684b917f423/wmts
# Example of WCS request for multispectral
https://access.foundation.api.oneatlas.airbus.com/api/v1/items/9c41e689-3069-409a-ace7-af8cc512223e/images/6950d957-58af-442d-ab3f-d684b917f423/wcs
Access Imagery from GIS Tools
The OneAtlas Data streaming services follows rigorously the OGC norm for its WMTS, WMS and WCS implementation. Consequently, the integration of our URLs in these GIS tools is straightforward.
QGIS
You can easily access the OneAtlas Data imagery with OSGeo's QGIS Desktop application. QGIS is an Open Source Geographic Information System (GIS) app licensed under the GNU General Public License. QGIS can act as a WMS, WMTS and WCS client. The procedure to view WMS/WMTS imagery is documented directly on the QGIS website.
In the menu _“Layer” / “Add Layer” / “Add WMS/WMTS Layer…” / “New”, you will need to provide your WMS/WMTS/WCS URL.
To ensure a secure experience, a username and password are mandatory to access to OneAtlas Data images. The credentials to use are listed in the table below:
| Username | APIKEY |
| Password | insert_your_api_key |
The resulting dialog box filled out should look like:
And the result in QGIS is:
Note: if no tiles are returned, please ensure checkboxes : “Invert axis orientation (WMS 1.3/WMTS)” and “Invert axis orientation” are selected.
QGIS - OneAtlas Data plugin
You can display a set of search and selected images by using the OneAtlas plugin for QGIS 3.
Installation
Go to “Plugins” menu and select “Manage and Install Plugins…”. Search for “OneAtlas” and select the “OneAtlas” plugin on the result, and click on the “Install Plugin” button. 
Overview of the plugin
- Display search window
- Display one imagery stream (after selecting the footprint found)
Search Window
- “Configuration” tab
- Set your Basemap credentials for searching OneAtlas Basemap
Set your API key for searching OneAtlas Data (Living Library)
Use an Area Of Interest (AOI)
By clicking on “Draw” button
By loading your own shape, selecting it and clicking on “Use selected” button
“Basemap” tab - For Searching Basemap
Click on “Basemap search” button
“Data” tab - For Searching Living Library
Set your search criterias
Click on “Data search” button
Display imagery stream
- Select the footprint of the imagery expected
- Click on the “Display Imagery” button of the toolbar
For Living Library Imagery (“Data” tab), if you have ordered the image you can select the stream (protocol) expected and select the representation (style). 
ArcGIS Desktop
You can easily access to the OneAtlas Data imagery with ESRI ArcGIS Desktop, a commercial product used by GIS professionals to compile, use, and manage geographic information. The procedure to follow is documented directly on the ESRI website.
You will need to provide:
- The WMTS, WMS or WCS endpoint , e.g. https://access.foundation.api.oneatlas.airbus.com/api/v1/items/image_id/wmts
- Credentials to be authorized to display the image
| Username | APIKEY |
| Password | insert_your_api_key |
The resulting dialog box filled out looks should look like:
The result in ArcGIS Desktop will look like:
ArcGIS Desktop OneAtlas Data AddIn
You can display a set of search and selected images by using the ArcGIS Desktop.
Prerequisites
ArcGIS for Desktop 10.5 or higher.
Installation
Double click on OneAtlas Data AddIn file. 
Launch ArcMap and activate toolbar by clicking on “Customize > Toolbars > OneAtlas Data Plugin”.
Overview of the AddIn
Search for OneAtlas Data Images 
Draw a rectangular Area Of Interest 
Draw a polygon Area Of Interest 
Erase current Area Of Interest 
Change connection settings 
Searching and displaying images
Draw an Area Of Interest by using the rectangular tool
Open search window, define search criterias and launch the search by clicking on “Search By AOI”
Put your OneAtlas Data API Key, and press validation button 
Click on “Search with limitations” buttons, the bounding box of all the images found in catalog is displayed.
Select images to view the metadata. 
Click on “Add Selected Images as Layers” button to display the image in full resolution using WMTS endpoint. 
ArcMap layers available
“AOI & Search Criteria” layer, store Area Of Interest bounding box and the criterias used for your search 
“Search Results” layer, store bounding box and metadata of the images found 
Searching by ID
Put the IDs of the images, and click on button “Search By IDs” 
Select images to view the metadata. 
Click on “Add Selected Images as Layers” button to display the image in full resolution using WMTS endpoint. 
ArcGIS Enterprise
Go to your ArcGIS Enterprise instance and authenticate.
Click on the “Map” menu then on “Modify Map” on the upper right corner of the map, next to the “Sign In” button.
Select “Add Layer from the Web” and “A WMTS OGC Web Service” from the drop down list as type of data to reference. You will need to provide:
- The WMTS endpoint of the Living Library Image (see Search results)
- Credentials (an APIKEY) to be authorized to display the Living Library Image (see Authenticate Guide)
The layer name will be displayed in the ArcGIS Enterprise “Table Of Content” on the left hand side of the map. Meanwhile, the layer will display on the map.
Access Imagery from Your Own Code
As an example, we will use the following area of San Francisco International Airport:
The coordinates of the bounding box to extract are:
| Longitude | Latitude | |
|---|---|---|
| Upper left corner | -122,385946512222 | 37,6203332456312 |
| Bottom right corner | -122,382202148437 | 37,6176733171484 |
The first step is to select the image from which we want to extract a subpart:
curl --silent -k -L -X GET "https://search.foundation.api.oneatlas.airbus.com/api/v2/opensearch?itemsPerPage=1&startPage=1&relation=intersects&geometry=POLYGON((-122.38594651222229%2037.61767331714846%2C-122.3822021484375%2037.61767331714846%2C-122.3822021484375%2037.62033324563128%2C-122.38594651222229%2037.62033324563128%2C-122.38594651222229%2037.61767331714846))" \
-H "Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache" |python -m json.tool |egrep "href"
Not available.
Not available.
This example searches for an image with the specified polygon coordinates and extracts all URLs relating to this image (including WMS, WMTS and WCS):
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/metadata",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/quicklook",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/thumbnail",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wms",
"href": "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wmts",
Using WMS Protocol
You can use the WMS protocol to access to a subpart of an image. In this example we show a number of parameters needed to make a successful GetMap request:
curl -X GET \
'https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<item_id>/images/<Images_Id>/wms?REQUEST=GetMap&VERSION=1.3.0&LAYERS=layer_0&CRS=EPSG:4326&BBOX=<BBOXCoordinates>&WIDTH=600&HEIGHT=400&FORMAT=image/png'\
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
Not available
Not available
| https://access.foundation.api.oneatlas.airbus.com/api/v1/items/image_id/wms | This is the URL corresponding to the image and to the product type from which the request has to be done. |
| VERSION=1.3.0 | This is the most recent WMS request version. |
| REQUEST=GetMap | This is the request name. |
| CRS | This is the spatial reference value. The value could be EPSG:4326 or EPSG:3857 |
| BBOX | This is the ounding box for map extent. The value is 'minX, minY, maxX, maxY' in units of the SRS. |
| WIDTH / HEIGHT | This is the width or height of the requested image in pixels. |
| FORMAT=image/png | This is the requested image format. |
Here we can see the PNG result of the request above for the requested pixel size (600 × 400) satisfying our bounding box:
Using WMTS Protocol
This section details how to use the WMTS protocol from your own code. It’s a bit more complex that using the WMS protocol, but your efforts will be rewarded with better performance. To do so, you will need to convert the from geographic coordinates into tiles coordinates.
GetCapabilities
To retrieve the endpoint to access to a single tile, you should use the GetCapabilities file corresponding to the image from which you want to extract tiles.
The characteristics of the endpoint to access to the GetCapabilities are:
| API Endpoint | <wmts_url>?request=GetCapabilities |
| REST verb | GET |
| Authentication | Bearer access token |
| API Reference | View API |
Here is an example of a GetCapabilities request:
curl -X GET "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<image_id>/wmts?request=GetCapabilities"
-H "Authorization: Bearer <access_token>"
-H "Cache-Control: no-cache"
Not available.
Not available.
This will return an XML file with tiles. Below you can see an extract the XML file:
<TileMatrix>
<ows:Identifier>12</ows:Identifier>
<ScaleDenominator>68247.34668319309</ScaleDenominator>
<TopLeftCorner>90.000000 -180.000000</TopLeftCorner>
<TileWidth>256</TileWidth>
<TileHeight>256</TileHeight>
<MatrixWidth>8192</MatrixWidth>
<MatrixHeight>4096</MatrixHeight>
</TileMatrix>
Get Tiles for a Geographic Tile Matrix Set
If you intend to get the tiles coordinates for the Geographic tile matrix set, you should use the formula below:
- x = [ (longitude + π) / (2 × π) ] × MatrixWidth
- y = [1 - [ (latitude + π/2 ) / π ] ] × MatrixHeight
Note: latitude and longitude should be in radians.
The Geographic tile matrix set is described as follows:
- CRS Name: urn:ogc:def:crs:OGC:1.3:CRS84 CRS84
- Top left corner: [ -180 , 90 ]
- Tile size: 256 × 256 pixels
| Zoom level id | Scale Denominator | Pixel Size (degrees) | Pixel Size (m)* | Matrix Width | Matrix Height |
|---|---|---|---|---|---|
| -1 | 559082264.0287178 | 1.40625 | 1 | 1 | |
| 0 | 279541132.0143589 | 0.703125 | 70312.5 | 2 | 1 |
| 1 | 139770566.0071794 | 0.351562500 | 35156.25 | 4 | 2 |
| 2 | 69885283.00358972 | 0.175781250 | 17578.125 | 8 | 4 |
| 3 | 34942641.50179486 | 8.78906250 × 10-2 | 8789.063 | 16 | 8 |
| 4 | 17471320.75089743 | 4.39453125 × 10-2 | 4394.531 | 32 | 16 |
| 5 | 8735660.375448715 | 2.19726562500 × 10-2 | 2197.266 | 64 | 32 |
| 6 | 4367830.187724357 | 1.09863281250 × 10-2 | 1098.633 | 128 | 64 |
| 7 | 2183915.093862179 | 5.49316406250 × 10-3 | 549.316 | 256 | 128 |
| 8 | 1091957.546931089 | 2.74658203125 × 10-3 | 274.658 | 512 | 256 |
| 9 | 545978.7734655447 | 1.37329101562500 × 10-3 | 137.329 | 1024 | 512 |
| 10 | 272989.3867327723 | 6.86645507812500 × 10-4 | 68.665 | 2048 | 1024 |
| 11 | 136494.6933663862 | 3.43322753906250 × 10-4 | 34.332 | 4096 | 2048 |
| 12 | 68247.34668319309 | 1.71661376953125 × 10-4 | 17.166 | 8192 | 4096 |
| 13 | 34123.67334159654 | 8.58306884765625 × 10-5 | 8.5831 | 16384 | 8192 |
| 14 | 17061.83667079827 | 4.29153442382812 × 10-5 | 4.2915 | 32768 | 16384 |
| 15 | 8530.918335399136 | 2.14576721191406 × 10-5 | 2.1458 | 65536 | 32768 |
| 16 | 4265.459167699568 | 1.07288360595703 × 10-5 | 1.0729 | 131072 | 65536 |
| 17 | 2132.729583849784 | 5.36441802978516 × 10-6 | 0.53644 | 262144 | 131072 |
* Approximation at the equator
The matrix width and height depends on the zoom level. You can pick the correct value using the table provided above. Be aware that the size of the tile matrix differs between the Geographic and the Web Mercator tile matrix set.
The request returns an XML response which is conformed to the OGC specification. By aggregating different elements such as the style, the tile matrix set with the ResourceURL value and integrating the tiles coordinates, you can access a single tile.
The below example contains the following elements which make up the URL to retrieve a tile:
- EPSG - in this example it is “EPSG4326”
- Zoom level - in this example this is “17”
- Upper left tile - in this example it is “41955”
- Bottom right tile - in this example it is “38143”
curl -X GET "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<item_id>/images/<image_id>/wmts/tiles/1.0.0/default/rgb/EPSG4326/17/41955/38143.png"
-H "Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache"
Not available.
Not available.
Here you can see the result displaying one tile:
For this example the result is made up of 9 tiles. The overall size of the composite image is 728 (3 × 256) pixels per 728 pixels (3 × 256 pixels) and the returned BBOX exceeded the initial BBOX requested.
Geographic Converter (EPSG:4326)
Note: The converter uses input type degrees
To retrieve a URL for a single tile, you can use our simple Geographic converter below. You will require the following:
- The longitude and latitude for the top left and bottom right corner. These can be found within your AOI coordinates.
- The zoom level you would like to access. These are shown within the GetCapabilities XML result.
- The id of the image. You should have used this previously for the GetCapabilities result.
Get Tiles for a Web Mercator Tile Matrix Set
If you intend to get the tiles coordinates for the Web Mercator tile matrix set, you will have to first reproject the coordinates to the Mercator projection (from EPSG:4326 to EPSG:3857). Then you will be required to transform the range of latitude and longitude to 0 - 1 and shift origin to top left corner:
- n = 2 ^zoom
- xtile = n × ((longitude + π) / (2 × π))
- ytile = (1 - (log(tan(latitude) + sec(latitude)) / π)) / (2 × n)
Note: latitude and longitude are required in radians.
The Web Mercator tile matrix set is described as follows:
- CRS Name: urn:ogc:def:crs:EPSG:6.18:3:3857
- Top left corner: [ -20037508.3427892 , 20037508.3427892 ]
- Tile size: 256 × 256 pixels
| Zoom level id | Scale Denominator | Pixel Size (m) | Matrix Width | Matrix Height |
|---|---|---|---|---|
| 0 | 559082264.0287178 | 156543.0339280410 | 1 | 1 |
| 1 | 279541132.0143589 | 78271.51696402048 | 2 | 2 |
| 2 | 139770566.0071794 | 39135.75848201023 | 4 | 4 |
| 3 | 69885283.00358972 | 19567.87924100512 | 8 | 8 |
| 4 | 34942641.50179486 | 9783.939620502561 | 16 | 16 |
| 5 | 17471320.75089743 | 4891.969810251280 | 32 | 32 |
| 6 | 8735660.375448715 | 2445.984905125640 | 64 | 64 |
| 7 | 4367830.187724357 | 1222.992452562820 | 128 | 128 |
| 8 | 2183915.093862179 | 611.4962262814100 | 256 | 256 |
| 9 | 1091957.546931089 | 305.7481131407048 | 512 | 512 |
| 10 | 545978.7734655447 | 152.8740565703525 | 1024 | 1024 |
| 11 | 272989.3867327723 | 76.43702828517624 | 2048 | 2048 |
| 12 | 136494.6933663862 | 38.21851414258813 | 4096 | 4096 |
| 13 | 68247.34668319309 | 19.10925707129406 | 8192 | 819zoom_wm2 |
| 14 | 34123.67334159654 | 9.554628535647032 | 16384 | 16384 |
| 15 | 17061.83667079827 | 4.777314267823516 | 32768 | 32768 |
| 16 | 8530.918335399136 | 2.388657133911758 | 65536 | 65536 |
| 17 | 4265.459167699568 | 1.194328566955879 | 131072 | 131072 |
| 18 | 2132.729583849784 | 0.5971642834779395 | 262144 | 262144 |
You can use the same principle explained for the geographic tile grid. You must include the following elements within the URL:
- EPSG - in this example it is “EPSG3857”
- Zoom level - in this example this is “17”
- Upper left tile - in this example it is “41955”
- Bottom right tile - in this example it is “38143”
curl -X GET "https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<item_id>/images/<image_id>/wmts/tiles/1.0.0/default/rgb/EPSG3857/17/41955/38143.png" \
-H "Authorization: Bearer <access_token>" \
-H "Cache-Control: no-cache"
Not available.
Not available.
Web Mercator Converter (EPSG:3857)
Note: The converter uses input type degrees.
To retrieve a URL for a single tile, you can use our simple Web Mercator converter below. You will require the following:
- The longitude and latitude for the top left and bottom right corner. These can be found within your AOI coordinates.
- The zoom level you would like to access. These are shown within the GetCapabilities XML result.
- The id of the image. You should have used this previously for the GetCapabilities result.
Download Service
OneAtlas Data API not only gives you the ability to stream imagery, but also allows you to download your product locally onto your machine. This section presumes you have already purchased the product and that it’s within your workspace. If you have not yet purchased a product you can do this by following our order guide.
Retrieve your Product
We can use the endpoint contracts/<contract_id>/orders to list all your orders within your contract. An example of the data returned is shown below:
curl -X GET \
https://data.api.oneatlas.airbus.com/api/v1/contracts/<contract_id>/orders \
-H 'Authorization: Bearer <access_token>' \
-H 'Cache-Control: no-cache' \
-H 'Content-Type: application/json' \
var data = null;
var xhr = new XMLHttpRequest();
xhr.withCredentials = true;
xhr.addEventListener("readystatechange", function () {
if (this.readyState === 4) {
console.log(this.responseText);
}
});
xhr.open("GET", "https://data.api.oneatlas.airbus.com/api/v1/contracts/<contract_id>/orders");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.setRequestHeader("Authorization", "Bearer <access_token>");
xhr.setRequestHeader("Cache-Control", "no-cache");
xhr.send(data);
import requests
url = "https://data.api.oneatlas.airbus.com/api/v1/contracts/<contract_id>/orders"
headers = {
'Content-Type': "application/json",
'Authorization': "Bearer <access_token>",
'Cache-Control': "no-cache",
}
response = requests.request("GET", url, headers=headers)
print(response.text)
Note: Orders are displayed by date processed. Therefore if you have just purchased a product, your order will be at the top.
This will return deliveries[] which contains your ordered products. Your delivery will start as status ordered and will change to delivered when it is ready to download:
Download your Product
If your product is at status delivered you will see a download URL similar to the following:
https://access.foundation.api.oneatlas.airbus.com/api/v1/items/<contract_id>/download
You send a GET request to output your file as a zip file:
curl -X GET \
https://access.foundation.api.oneatlas.airbus.com/api/v1/items/90ebd420-fab4-49b7-85cd-ced051ea2343/download \
-H 'Authorization: Bearer <access_token>' -o output_file.zip
Here you can see the contents of the zip:
© Airbus Defence and Space 2022. All rights reserved. Privacy Policy | Legal Information