Find file
Fetching contributors…
Cannot retrieve contributors at this time
440 lines (299 sloc) 14.4 KB

API guide

This section documents CKAN's API, for developers who want to write code that interacts with CKAN sites and their data.

CKAN's Action API is a powerful, RPC-style API that exposes all of CKAN's core features to API clients. All of a CKAN website's core functionality (everything you can do with the web interface and more) can be used by external code that calls the CKAN API. For example, using the CKAN API your app can:


CKAN's FileStore and DataStore have their own APIs, see:


For documentation of CKAN's legacy API's, see :doc:`legacy-api`.


On early CKAN versions, datasets were called "packages" and this name has stuck in some places, specially internally and on API calls. Package has exactly the same meaning as "dataset".

Making an API request

To call the CKAN API, post a JSON dictionary in an HTTP POST request to one of CKAN's API URLs. The parameters for the API function should be given in the JSON dictionary. CKAN will also return its response in a JSON dictionary.

One way to post a JSON dictionary to a URL is using the command-line HTTP client HTTPie. For example, to get a list of the names of all the datasets in the data-explorer group on, install HTTPie and then call the group_list API function by running this command in a terminal:


The response from CKAN will look like this:

    "help": "...",
    "result": [
    "success": true

The response is a JSON dictionary with three keys:

  1. "success": true or false.

    The API aims to always return 200 OK as the status code of its HTTP response, whether there were errors with the request or not, so it's important to always check the value of the "success" key in the response dictionary and (if success is false) check the value of the "error" key.


If there are major formatting problems with a request to the API, CKAN may still return an HTTP response with a 409, 400 or 500 status code (in increasing order of severity). In future CKAN versions we intend to remove these responses, and instead send a 200 OK response and use the "success" and "error" items.

  1. "result": the returned result from the function you called. The type and value of the result depend on which function you called. In the case of the group_list function it's a list of strings, the names of all the datasets that belong to the group.

    If there was an error responding to your request, the dictionary will contain an "error" key with details of the error instead of the "result" key. A response dictionary containing an error will look like this:

        "help": "Creates a package",
        "success": false,
        "error": {
            "message": "Access denied",
            "__type": "Authorization Error"
  2. "help": the documentation string for the function you called.

The same HTTP request can be made using Python's standard urllib2 module, with this Python code:

#!/usr/bin/env python
import urllib2
import urllib
import json
import pprint

# Make the HTTP request.
response = urllib2.urlopen('',
assert response.code == 200

# Use the json module to load CKAN's response into a dictionary.
response_dict = json.loads(

# Check the contents of the response.
assert response_dict['success'] is True
result = response_dict['result']

Example: Importing datasets with the CKAN API

You can add datasets using CKAN's web interface, but when importing many datasets it's usually more efficient to automate the process in some way. In this example, we'll show you how to use the CKAN API to write a Python script to import datasets into CKAN.

#!/usr/bin/env python
import urllib2
import urllib
import json
import pprint

# Put the details of the dataset we're going to create into a dict.
dataset_dict = {
    'name': 'my_dataset_name',
    'notes': 'A long description of my dataset',

# Use the json module to dump the dictionary to a string for posting.
data_string = urllib.quote(json.dumps(dataset_dict))

# We'll use the package_create function to create a new dataset.
request = urllib2.Request(

# Creating a dataset requires an authorization header.
# Replace *** with your API key, from your user account on the CKAN site
# that you're creating the dataset on.
request.add_header('Authorization', '***')

# Make the HTTP request.
response = urllib2.urlopen(request, data_string)
assert response.code == 200

# Use the json module to load CKAN's response into a dictionary.
response_dict = json.loads(
assert response_dict['success'] is True

# package_create returns the created package as its result.
created_package = response_dict['result']

For more examples, see :ref:`api-examples`.

API versions

The CKAN APIs are versioned. If you make a request to an API URL without a version number, CKAN will choose the latest version of the API:

Alternatively, you can specify the desired API version number in the URL that you request:

Version 3 is currently the only version of the Action API.

We recommend that you specify the API number in your requests, because this ensures that your API client will work across different sites running different version of CKAN (and will keep working on the same sites, when those sites upgrade to new versions of CKAN). Because the latest version of the API may change when a site is upgraded to a new version of CKAN, or may differ on different sites running different versions of CKAN, the result of an API request that doesn't specify the API version number cannot be relied on.

Authentication and API keys

Some API functions require authorization. The API uses the same authorization functions and configuration as the web interface, so if a user is authorized to do something in the web interface they'll be authorized to do it via the API as well.

When calling an API function that requires authorization, you must authenticate yourself by providing your API key with your HTTP request. To find your API key, login to the CKAN site using its web interface and visit your user profile page.

To provide your API key in an HTTP request, include it in either an Authorization or X-CKAN-API-Key header. (The name of the HTTP header can be configured with the apikey_header_name option in your CKAN configuration file.)

For example, to ask whether or not you're currently following the user markw on using HTTPie, run this command:

http id=markw Authorization:XXX

(Replacing XXX with your API key.)

Or, to get the list of activities from your user dashboard on, run this Python code:

request = urllib2.Request('')
request.add_header('Authorization', 'XXX')
response_dict = json.loads(urllib2.urlopen(request, '{}').read())

GET-able API functions

Functions defined in ckan.logic.action.get can also be called with an HTTP GET request. For example, to get the list of datasets (packages) from, open this URL in your browser:

Or, to search for datasets (packages) matching the search query spending, on, open this URL in your browser:


Browser plugins like JSONView for Firefox or Chrome will format and color CKAN's JSON response nicely in your browser.

The search query is given as a URL parameter ?q=spending. Multiple URL parameters can be appended, separated by & characters, for example to get only the first 10 matching datasets open this URL:

When an action requires a list of strings as the value of a parameter, the value can be sent by giving the parameter multiple times in the URL:

JSONP support

To cater for scripts from other sites that wish to access the API, the data can be returned in JSONP format, where the JSON data is 'padded' with a function call. The function is named in the 'callback' parameter. For example:


This only works for GET requests

API Examples

Tags (not in a vocabulary)

A list of all tags:

Top 10 tags used by datasets:

All datasets that have tag 'economy':

Tag Vocabularies

Top 10 tags and vocabulary tags used by datasets:

e.g. Facet: vocab_Topics means there is a vocabulary called Topics, and its top tags are listed under it.

A list of datasets using tag 'education' from vocabulary 'Topics':

Uploading a new version of a resource file

You can use the upload parameter of the :py:func:`~ckan.logic.action.update.resource_update` function to upload a new version of a resource file. This requires a multipart/form-data request, with httpie you can do this using the @file.csv:

http --json POST id=<resource id> upload=@updated_file.csv Authorization:<api key>

Action API reference


If you call one of the action functions listed below and the function raises an exception, the API will return a JSON dictionary with keys "success": false and and an "error" key indicating the exception that was raised.

For example :py:func:`~ckan.logic.action.get.member_list` (which returns a list of the members of a group) raises :py:class:`~ckan.logic.NotFound` if the group doesn't exist. If you called it over the API, you'd get back a JSON dict like this:

    "success": false
    "error": {
        "__type": "Not Found Error",
        "message": "Not found"
    "help": "...",