Sindice Search API

Sindice API
Sindice API:

The Sindice API provides programmatic access to its search capabilities. Please refer for support questions.

Search API (v3)

The third version of the search API supports the following parameters:

  • The q parameter specifies the keyword query.
  • The nq parameter specifies the ntriple query.
  • The fq parameter specifies the filter query. The fq parameter can be specified multiple times. An intersection between the fq parameters will be performed. In the example below, only documents which have a format RDFa and a foaf:Person class will be part of the result set.;=class:foaf:person&format;=json
  • the page parameter (optional) specifies the result page. Pages are 1-indexed, so the first page is 1, the second is 2 and so on. (default value is 1)
  • the sortbydate (optional) parameter is a boolean flag that specifies whether the results have to be sorted by date (they are sorted by relevance, otherwise).
  • The field parameter specifies the fields of the record to retrieve. Various fields can be retrieved at query time, which can be helpful to get more insight of the information contained in the document. Below is the list fo currently supported fields:
    • link: the url of the document. This field is always returned with the result.
    • title: the labels of the document. This field is always returned with the result.
    • ontology: the ontology closure of the document.
    • class: the list of classes used in the document.
    • predicate: the list of predicates used in the document.
    • domain: the third-level domain of the document.
    • explicit_content_size: the number of (explicit) triples in the document.
    • explicit_content_length: the number of bytes of the document.
    • updated: the date when documnet was last time indexed
    • formats: the list of source document formats the metadata was extracted from
    By default, the link, title, updated, formats, explicit_content_size and explicit_content_length fields are retrieved. The field can be specified multiple times. In the example below, only the fields link, title and class are retrieved for each records.;=title&field;=class&format;=json

Examples:;=class:city&format;=json;=class:city&&field;=updated&format;=json* <label> 'Rome'&fq;=class:city&page;=2&sortbydate;=1&format;=json

Query Limits

Sindice currently limits to 100 the number of result pages for each query. For special needs you can refer .

Result formats

You can negotiate the content and retrieve three different formats:

  • json: curl -H "Accept: application/json" "
  • rdf: curl -H "Accept: application/rdf+xml" "
  • atom: curl -H "Accept: application/atom+xml" "

The result format is composed of three sections:

  • metadata
  • query
  • result entries


The metadata section is composed of metadata information about the search results and links to navigate through the results.

  • totalResults: number of total results
  • updated: generation time of this search
  • base: base url, without the specific page
  • author: author field,
  • itemPerPage: number of items per page
  • startIndex: starting index in this page
  • link: url of this result page
  • previous,self, next, first, last: url of previous, self, next, first and last page of results
  • alternate: link to the HTML alternate representation for this page, i.e., the sindice frontend page.
  • cache_batch: link to the sindice cache api which allow to fetch cache version of all documents at once ( only json format )


A query object containing information about the request that has produced the current search results. The query object is composed of the parameters of the search API, i.e., q, nq, fq, page, sortbydate, field.

Result Entries

The last section is the list of search result entries. Each entry is composed of the fields to be retrieved, defined by the field parameter of the search API. In addition, each entry contain an additional field, cache, which provides a link to fetch the content of the result from the Sindice cache.

Response Format Example

 "updated": "2008/06/03 18:27:29 \+0100",
 "base": "\u0026qt=term"
 "totalResults": 211,
 "search": "",
 "self": "\u0026qt=term\u0026page=1",
 "previous": "\u0026qt=term\u0026page=",
 "title": "Sindice search: gabriele",
 "last": "\u0026qt=term\u0026page=22",
 "alternate": "\u0026qt=term",
 "author": "",
 "first": "\u0026qt=term\u0026page=1",
 "itemsPerPage": 10,
 "startIndex": 1,
 "next": "\u0026qt=term\u0026page=2",
 "link": "\u0026qt=term\u0026page=1",
   "role": "request",
   "startPage": 1,
   "searchTerms": "gabriele"
    "title": ["Gabriele Albertini"],
    "formats": ["RDF"],
    "content": "183 triples in 32484 bytes",
    "link": "",
    "updated": "2008/05/23"
    "title": ["Gabriele Paonessa"],
    "formats": ["RDF"],
    "content": "111 triples in 16153 bytes",
    "link": "",
    "updated": "2008/05/23"

The format closely matches the OpenSearch format, so refer to that for further details, the only two differences are the title field in the entry, which is a list (a document can have different labels) and the format field which is a list of the formats found in one page (for example, RDFa and microformats).

<?xml version="1.0" encoding="iso-8859-1"?>
<feed xmlns:opensearch=""
  <title>Sindice search: gabriele</title>
  <link href=""/>
  <opensearch:Query role="request" startPage="1" searchTerms="gabriele"/>
  <link href=""
        rel="alternate" type="text/html"/>
  <link href=""
        rel="first" type="application/atom+xml"/>
  <link href=""
        rel="previous" type="application/atom+xml"/>
  <link href=""
        rel="next" type="application/atom+xml"/>
  <link href=""
        rel="last" type="application/atom+xml"/>
  <link href=""
        rel="self" type="application/atom+xml"/>
  <link href=""
        rel="search" type="application/opensearchdescription+xml"/>
    <title>Gabriele Albertini</title>
    <link href=""/>
    <content>183 triples in 32484 bytes</content>
    <title>Gabriele Paonessa</title>
    <link href=""/>
    <content>111 triples in 16153 bytes</content>

It is a simple ATOM file, plus the OpenSearch schema plus a single additional tag for carrying informations about the document format. You should be able to parse this easily with any XML parser.


The RDF representation defines the base search URI as a search:Query object, which has links to search:Pages, each one having many search:Results. the other fields should be obvious, and mimic the other searches.

<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:dcterms=""
  <Query rdf:about="">
    <dc:title>Sindice search: gabriele</dc:title>
    <first rdf:resource=""/>
    <last rdf:resource=""/>
    <page rdf:resource=""/>
    <opensearchDescription rdf:resource=""/>
    <result rdf:resource="#result1"/>
    <result rdf:resource="#result2"/>
  <Page rdf:about="">
    <dc:title>Sindice search: gabriele [page 1]</dc:title>
    <previous rdf:resource=""/>
    <next rdf:resource=""/>
    <foaf:page rdf:resource=""/>
  <Result rdf:about="#result1">
    <dc:title>Gabriele Tarquini</dc:title>
    <link rdf:resource=""/>
    <content>59 triples in 9131 bytes</content>
  <Result rdf:about="#result2">
    <link rdf:resource=""/>
    <content>29 triples in 3374 bytes</content>

Integrating JSON in your script

If you want, you can add an additional argument to the request called callback, which will cause the code to be wrapped in a function with the name you choose.
This allows clean integration of the Sindice results in your webpage, for example:

<script type="text/javascript"

Notice that to force the rendering of JSON output we added an additional parameter format. It can obviously be used with values atom and rdfxml

Other API versions

Currently, our API Version is 3, with base address
As new APIs will be released, the old one will be kept at the existing locations.

The API v2 is still accessible at
The documentation of API v2 is accessible here.