search mobile facets autocomplete spellcheck crawler rankings weights synonyms analytics engage api customize documentation install setup technology content domains user history info home business cart chart contact email activate analyticsalt analytics autocomplete cart contact content crawling custom documentation domains email engage faceted history info install mobile person querybuilder search setup spellcheck synonyms weights engage_search_term engage_related_content engage_next_results engage_personalized_results engage_recent_results success add arrow-down arrow-left arrow-right arrow-up caret-down caret-left caret-right caret-up check close content conversions-small conversions details edit grid help small-info error live magento minus move photo pin plus preview refresh search settings small-home stat subtract text trash unpin wordpress x alert case_deflection advanced-permissions keyword-detection predictive-ai sso

Document Indexing

To index is to upload, to retain, to store, your various documents. The act of indexing takes data and places it within your engine, so that you can search it and curate it. You can use the Site Search API in place of the crawler. The Site Search API allows you to have more granular control over how documents are indexed into your engine.

If the Site Search Crawler is not for you, the App Search product provides the most robust API-centric experience. Explore that before continuing!


This document has four core pieces:

Basic Indexing

The following example demonstrates how you could POST a new document into your engine. Indexing requires the use of your private API Key, which can you can acquire within your dashboard.

curl -XPOST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token":"YOUR_API_KEY",
        "document": {
          "external_id": "1",
          "fields": [
            {"name": "title", "value": "The Great Gatsby", "type": "string"},
            {"name": "author", "value": "F. Scott Fitzgerald", "type": "string"},
            {"name": "genre", "value": "fiction", "type": "enum"}
          ]
        }
      }'

curl -XPOST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token":"YOUR_API_KEY",
        "document": {
          "external_id": "2",
          "fields": [
            {"name": "title", "value": "The Brothers Karamazov", "type": "string"},
            {"name": "author", "value": "Fyodor Dostoevsky", "type": "string"},
            {"name": "genre", "value": "fiction", "type": "enum"}
          ]
        }
      }'

Engines

Search engines are the top-level container for the objects you wish to search, and most sites will have a single engine. The engines themselves contain one or more document types, each of which contain the documents themselves.

GET /api/v1/engines.json
POST /api/v1/engines.json
GET /api/v1/engines/{engine_id}.json
DELETE /api/v1/engines/{engine_id}.json
Example - List every Engine in your account
curl -X GET 'https://api.swiftype.com/api/v1/engines.json?auth_token=YOUR_API_KEY'
Example - Create an Engine called bookstore
curl -X POST 'https://api.swiftype.com/api/v1/engines.json' \
-H 'Content-Type: application/json' \
-d '{
      "auth_token": "YOUR_API_KEY",
      "engine": {"name": "bookstore"}
    }'
Example - Get an Engine called bookstore
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore.json?auth_token=YOUR_API_KEY'
Example - 'Delete an Engine called bookstore
curl -X DELETE 'https://api.swiftype.com/api/v1/engines/bookstore?auth_token=YOUR_API_KEY'

DocumentTypes

DocumentTypes specify the structure of a set of documents in the Engine and are the entry point for searches. There are multiple types of fields on a DocumentType — string, text, enum, integer, float, date, and location.

GET /api/v1/engines/{engine_id}/document_types.json
POST /api/v1/engines/{engine_id}/document_types.json
GET /api/v1/engines/{engine_id}/document_types/{document_type_id}.json
DELETE /api/v1/engines/{engine_id}/document_types/{document_type_id}.json
Example - Get every DocumentType in an Engine
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/document_types.json?auth_token=YOUR_API_KEY'
Example - Create a DocumentType called books in the bookstore Engine
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "document_type": {"name": "books"}
      }'
Example - Get a specific DocumentType called books in the bookstore Engine
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books.json?auth_token=YOUR_API_KEY'
Example - Delete a DocumentType called books in the bookstore Engine
curl -X DELETE 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books?auth_token=YOUR_API_KEY'

Documents

Documents represent all of the pieces of content in an Engine. They are children of a DocumentType and conform to its field specification (note: you do not need to specify the fields ahead of time, they will be inferred by the contents of a document). When you perform a search on a DocumentType, you will receive Document results. external_id is the only required field for a Document. It can be any value, such as a numeric ID.

GET /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents.json
POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents.json
GET /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/{external_id}.json
PUT /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/{document_id}/update_fields.json
POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/create_or_update.json
DELETE /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/{document_id}.json
DELETE /api/v1/engines/{engine_id}/document_types/page/documents/destroy_url?url={url}
Example - List every Document in the books DocumentType
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents.json?auth_token=YOUR_API_KEY'
Example - Create a Document in the books DocumentType
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents.json' \
-H 'Content-Type: application/json' \
-d '{
      "auth_token": "YOUR_API_KEY",
      "document": {
        "external_id": "2",
        "fields": [
            {"name": "title", "value": "my title 1", "type": "string"},
            {"name": "page_type", "value": "user", "type": "enum"}
      ]}
    }'
Example - Get a specific Document with external_id=1 from the books DocumentType
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/1?auth_token=YOUR_API_KEY'

Updating Fields

Updates fields on an existing document. This method will only update existing fields on the document. It will not create new fields on an existing document. In most cases you probably want to use bulk_create_or_update_verbose, which will create new fields on existing documents.

Existing fields will not change if not listed in the request.

Example - Update fields for Document with external_id 1.
curl -X PUT 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/1/update_fields' \
-H 'Content-Type: application/json' \
-d '{
      "auth_token": "YOUR_API_KEY",
      "fields": {"title": "my title 2", "page_type": "user2"}
    }'
Example - Create or update a Document in the books DocumentType
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/create_or_update.json' \
-H 'Content-Type: application/json' \
-d '{
      "auth_token": "YOUR_API_KEY",
      "document": {
        "external_id": "2",
        "fields": [
            {"name": "title", "value": "my new title", "type": "string"},
            {"name": "page_type", "value": "user", "type": "enum"}
        ]}
      }'
Example - Delete a Document with external_id=1 from the books DocumentType
curl -X DELETE 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/1?auth_token=YOUR_API_KEY'
Example - Delete a Document with url=http://example.com/section/page.html
curl -X DELETE 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/page/documents/destroy_url?url=http://example.com/section/page.html&auth_token=YOUR_API_KEY'

Bulk Operations

Bulk operations will allow you to perform rapid indexing updates and avoid the latency overhead of making repeated requests.

POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/bulk_create
PUT /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/bulk_update
POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/bulk_create_or_update_verbose
POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/bulk_create_or_update
POST /api/v1/engines/{engine_id}/document_types/{document_type_id}/documents/bulk_destroy

bulk_create

To create Documents in bulk, use bulk_create. bulk_create will return an error if a Document with a given external_id already exists. In most cases, it is easier to use bulk_create_or_update_verbose.

Example - Create Documents in bulk
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/bulk_create' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {"external_id": "3", "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]},
            {"external_id": "4", "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]}
          ]
      }'

bulk_update

To update Documents in bulk, use bulk_update. bulk_update will return an error if a Document with a given external_id does not exist. In most cases, it is easier to use bulk_create_or_update_verbose.

Example - Update Documents in bulk
curl -X PUT 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/bulk_update' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {"external_id": "1", "fields": {"title": "my title 5", "page_type": "user2"}},
            {"external_id": "2", "fields": {"title": "my title 4", "page_type": "user2"}}
          ]
      }'

bulk_create_or_update_verbose

To create or update Documents in bulk, use the bulk_create_or_update_verbose endpoint. This endpoint returns an array of responses, one for each Document. If the create or update was successful, the response will be true, and Documents will be created if they do not exist or updated if they already exist.

Example - Create or update Documents in bulk (all succeeded)
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/bulk_create_or_update_verbose' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {"external_id": "3", "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]},
            {"external_id": "4", "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]}
          ]
      }'
Example Response
[true, true]

If a create or update fails, the response for that Document will be a string containing an error message.

Example - Error messages from create or update in bulk (all failed)
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/bulk_create_or_update_verbose' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {"fields": [{"name": "title", "value": "my title 1", "type": "string"},
                        {"name": "page_type", "value": "user", "type": "enum"}]},
            {"external_id": "4", "fields": [{"name": "title", "value": "my title 1", "type": "bogus"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]}
          ]
      }'
Example Response
["Missing external_id", "Invalid field type: Invalid type for \"title\": \"bogus\""]

There is also a non-verbose version which only returns false when a create or update fails. This version is not recommended but it is still available for backwards compatibility.

bulk_destroy

To remove Documents in bulk, use bulk_destroy. The output is an array of true/false values. If an individual destroy succeeds, its entry in the result array will be true. If it fails, its entry in the result array will be false.

Example - Delete Documents in bulk
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/bulk_destroy' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents": ["1","2"]
      }'
Example Response
[true, true]

Crawler-based engines

If you do not wish to create Documents by hand, you can create a domain in an Engine and our crawlers will automatically crawl the domain and create a Document for each page it finds.

Note The following Crawler specific endpoints only apply to Crawler-based Engines. It is not possible to make use of the Crawler specific endpoints for an Engine or Engines created with the Indexing API.

GET /api/v1/engines/{engine_id}/domains.json
POST /api/v1/engines/{engine_id}/domains.json
GET /api/v1/engines/{engine_id}/domains/{domain_id}.json
DELETE /api/v1/engines/{engine_id}/domains/{domain_id}.json
PUT /api/v1/engines/{engine_id}/domains/{domain_id}/recrawl.json
PUT /api/v1/engines/{engine_id}/domains/{domain_id}/crawl_url.json

Creating a domain

Example - Create a Domain for example.com in the bookstore Engine. The crawler begins indexing immediately
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/domains.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "domain": {"url": "http://example.com"}
      }'

Get a domain

Example - Get every Domain in an Engine
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/domains.json?auth_token=YOUR_API_KEY'

Delete a domain

Example - Get a specific Domain with ID 4fcec5182f527673a0000006 in the bookstore Engine
curl -X GET 'https://api.swiftype.com/api/v1/engines/bookstore/domains/4fcec5182f527673a0000006.json?auth_token=YOUR_API_KEY'

Recrawl a domain

You may trigger a recrawl of a domain via the API. The frequency of the requests are dictated by your specific plan limitations.

Example - Recrawl a Domain with ID 4fcec5182f527673a0000006 in the bookstore Engine
curl -X PUT -H 'Content-Length: 0' 'https://api.swiftype.com/api/v1/engines/bookstore/domains/4fcec5182f527673a0000006/recrawl.json?auth_token=YOUR_API_KEY'

Crawl a single URL

You may trigger the crawl of a single URL by using the domain's crawl_url endpoint with the URL as a parameter. If the URL belongs to the parent domain and has a corresponding result document, it will be updated. If the URL validates against the parent domain and has not yet been indexed, it will be added.

Example - Crawl a URL in the Domain with ID 4fcec5182f527673a0000006 in the bookstore Engine.
curl -X PUT 'https://api.swiftype.com/api/v1/engines/bookstore/domains/4fcec5182f527673a0000006/crawl_url.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "url": "http://example.com/new-page"
      }'

Note: Crawling the URL happens asynchronously, so there is limited error checking. There are several scenarios that will prevent the URL from being added as a document:

  • The URL does not respond successfully (for example, if it responds HTTP 404 or HTTP 503).
  • The URL does not belong to the domain (for example, you try to crawl http://anotherdomain.net/contact on the example.com domain).
  • The URL is a duplicate of an existing document.
  • The URL is excluded by robots.txt, a robots meta tag, or a path whitelist or blacklist.
  • The URL has a canonical link that belongs to a different page or domain.

Asynchronous Indexing

Swiftype's API supports asynchronous indexing to efficiently index large numbers of Documents.

Asynchronous indexing consists of two stages: submission and result. Both stages support batch operations.

Submitting a batch of Documents

First, submit a list of one or more Documents to the asynchronous indexing API. This API follows create-or-update semantics. The Documents will be created if they do not exist, or updated if they already exist.

This endpoint does basic parameter validation, but in order to check and see if the Documents were successfully created or updated you must check the document receipt resource. For your convenience, a link to show the status of all the documents included in the batch is returned in the result.

Example - Submitting a batch of Documents for asynchronous indexing.
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/async_bulk_create_or_update' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {"external_id": "3", "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]},
            {"external_id": "4", "fields": [{"name": "title", "value": "my title 1", "type": "enum"},
                                            {"name": "page_type", "value": "user", "type": "enum"}]}
          ]
      }'
Example Response
{
  "batch_link": "https://api.swiftype.com/api/v1/document_receipts.json?ids=5473d6142ed96065a9000001,5473d6142ed96065a9000002",
  "document_receipts": [
    {
      "id": "5473d6142ed96065a9000001",
      "external_id": "3",
      "status": "pending",
      "errors": [],
      "links": {
        "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
        "document": null
      }
    },
    {
      "id": "5473d6342ed96065a9000002",
      "external_id": "4",
      "status": "pending",
      "errors": [],
      "links": {
        "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000002.json",
        "document": null
      }
    }
  ]
}

Checking the status of document receipts

Once you have submitted documents for indexing, you can check the status of the documents using the document receipts API endpoint. Each receipt will have a status value.

Status Meaning
pending The Document has not yet been processed.
complete The Document was successfully created.
failed The Document could not be created. Check the errors array for details.
expired The receipt is over 24 hours old and can no longer be checked.
unknown The document receipt could not be found.

You may need to check the receipts a few times, because the Documents will be processed asynchronously.

You can check the status of document receipts with either a GET or POST request. There is a limit 1000 document receipts per API request.

To use a GET request, submit a request with the document receipt IDs joined together with , as the ids parameter (for convenience, a link to this resource is included as the batch_link when you submit a batch of documents).

Example - Checking the status multiple document receipts with a GET request
curl -X GET 'https://YOUR_API_KEY:@api.swiftype.com/api/v1/document_receipts.json?ids=5473d6142ed96065a9000001,5473d6142ed96065a9000002'
Example Response
[
  {
    "id": "5473d6142ed96065a9000001",
    "external_id": "3",
    "status": "pending",
    "errors": [],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
      "document": null
    }
  },
  {
    "id": "5473d6142ed96065a9000002",
    "external_id": "4",
    "status": "complete",
    "errors": [],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
      "document": "https://api.swiftype.com/api/v1/engine/xyz/document_type/abc/document/547e513f2ed9609fa7000001.json"
    }
  }
]

Using a GET request is convenient, but to check the status of many document receipt IDs, a JSON encoded POST is easier.

Example - Checking the status of multiple document receipts with a POST request
curl -X POST 'https://api.swiftype.com/api/v1/document_receipts.json' \
     -H 'Content-Type: application/json'
     -d '{"ids": ["5473d6142ed96065a9000001", "5473d6142ed96065a9000002"]}'
Example Response
[
  {
    "id": "5473d6142ed96065a9000001",
    "external_id": "3",
    "status": "pending",
    "errors": [],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
      "document": null
    }
  },
  {
    "id": "5473d6142ed96065a9000002",
    "external_id": "4",
    "status": "complete",
    "errors": [],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
      "document": "https://api.swiftype.com/api/v1/engine/xyz/document_type/abc/document/547e513f2ed9609fa7000001.json"
    }
  }
]

When a document cannot be created due to incorrect input, the receipt will have a status of failed and include a list of error messages.

Example - A receipt for a failed document creation
curl -X GET 'https://YOUR_API_KEY:@api.swiftype.com/api/v1/document_receipts.json?ids=5473d6142ed96065a9000002'
Example Response
[
  {
    "id": "5473d6142ed96065a9000002",
    "external_id": "4",
    "status": "failed",
    "errors": ["Invalid type for title: Got enum, but title is already defined as string in schema."],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
      "document": null
    }
  }
]

Receipts are only available for 24 hours. If you request a receipt more than 24 hours old, you will see the expired status.

Example - Checking the status of an expired document receipt
curl -X GET 'https://YOUR_API_KEY:@api.swiftype.com/api/v1/document_receipts.json?ids=5473d6142ed96065a9000002'
Example Response
[
  {
    "id": "5473d6142ed96065a9000002",
    "external_id": null,
    "status": "expired",
    "errors": [],
    "links": {
      "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000002.json",
      "document": null
    }
  }
]

Checking the status of a single document receipt

Checking multiple receipt IDs is most efficient, but you can also check the status of an individual receipt. This is especially useful for debugging.

You can check a document receipt's status by executing a GET request to the link returned in the async_bulk_create_or_update response.

Example - Checking the status of a single document receipt
curl -X GET 'https://YOUR_API_KEY:@api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json'
Example Response
{
  "id": "5473d6142ed96065a9000001",
  "external_id": "3",
  "status": "complete",
  "errors": [],
  "links": {
    "document_receipt": "https://api.swiftype.com/api/v1/document_receipts/5473d6142ed96065a9000001.json",
    "document": "https://api.swiftype.com/api/v1/engines/5025a35185307b737f000008/document_types/5025a35485307b737f00000a/documents/5025a3036052f6b650000006.json"
  }
}

Handling errors at submission time

The asynchronous indexing API handles errors related to the document at a later time. However, it performs basic parameter validation at submission time. Requests must contain a documents key that is a non-empty array. Additionally, there is a 100 document limit on the number of documents that may be submitted in a single batch as well as a maximum request size of 50 megabytes.

If a request cannot be validated, an error response will be returned.

Example - Incorrectly submitting Documents for asynchronous indexing.
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/async_bulk_create_or_update.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents": []
      }'
Example Response
{
  "error": "Invalid field type: documents"
}

Document Expiration

If you have Documents which you do not want to be searchable after some time in the future, you can use Swiftype's document expiration feature to automatically delete them from your search engine.

Specifying document expiration when creating or updating documents

In order to create (or update) a Document with an expiration date, you must use the asynchronous bulk indexing API. Add an expires_after key to the Document object with the time to expire as a Unix Epoch timestamp as its value. The expires_after value must be in the future.

Example - Submitting a batch of Documents with an expiration date.
curl -X POST 'https://api.swiftype.com/api/v1/engines/bookstore/document_types/books/documents/async_bulk_create_or_update' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "documents":
          [
            {
              "external_id": "3",
              "fields": [{"name": "title", "value": "my title 1", "type": "string"},
                         {"name": "page_type", "value": "user", "type": "enum"}],
              "expires_after": 1450574556
            },
            {
              "external_id": "4",
              "fields": [{"name": "title", "value": "my title 2", "type": "enum"},
                         {"name": "page_type", "value": "user", "type": "enum"}],
              "expires_after": 1450574556
            }
          ]
      }'
Note: There is no guarantee that a Document will be removed exactly at its expires_after time. However, it is guaranteed that a Document will not not to be automatically deleted before its expires_after time.

Searching with precise expiration

As noted above, Documents are not guaranteed to be deleted exactly at their expiration time. Therefore, there is some period of time after a Document expires that it will still appear in search results. Depending on your use case, this may be fine. However, if you need to ensure that expired Documents do not appear in search, you can use the precise_expiration search option. This option is available for both the search and suggest API endpoints.

When the precise_expiration option is used, all Documents that are not not expired (e.g., have an expires_after value in the future) and those that don't have an expires_after value set set will be returned. In other words, it filters all expired Documents from the results.

The format of the precise_expiration option is as follows:

"precise_expiration": {
  "<document_type_1_slug>": true,
  "<document_type_2_slug>": true
}

The default value is false for all Document Types (that is, expired but not yet deleted Documents will be returned in the results).

Example - Specifying precise_expiration for a Document Type.
curl -XGET 'https://search-api.swiftype.com/api/v1/engines/bookstore/document_types/books/search.json' \
  -H 'Content-Type: application/json' \
  -d '{
        "auth_token": "YOUR_API_KEY",
        "q": "brothers",
        "precise_expiration": {
          "books": true
        }
      }'

Stuck? Looking for help? Contact Support!