Change Log
These changelogs reflect the history of the Algolia Search service

  • InstantSearch Android is now out of beta and available for everyone. InstantSearch Android is a library providing search components for app developers.
  • We released Search for facet values, a new feature to give end-users full control to explore and actually use those hidden values. You can learn more about this feature in the product launch post. Follow our Filtering and Faceting guide to implement it (also available natively in instantsearch librairies).
  • We released Algolia Offline, a seamless search experience for your users - online & offline. You can learn more about this product in the product launch post.
  • We released our personalization feature that allows to have a personalized search experience per user or group. You can learn more about this feature in our personalization guide.
  • We released the graph of maximum queries per second (max QPS) in the Performance tab of your dashboard. Those graphs were previously only accessible by enterprise users and are now visible in any plan.
  • We released a new query parameter called facetingAfterDistinct that allows to specify the behavior of faceting when distinct is used.
    When using the distinct setting in combination with faceting, the facet counts might be higher than what you would expect. This is because internally the engine computes the faceting before applying the de-duplication (distinct).
    With the facetingAfterDistinct param set to true, you can force the faceting to be applied after the de-duplication (distinct).
  • The retry strategy switching to our second DNS provider has been improved in all our API clients to avoid timeouting again and again if our first DNS provider is experiencing an outage or DDOS.
  • We released a new index setting called paginationLimitedTo to control the maximum number of hits accessible via pagination. By default, this parameter is limited to 1000 to guarantee good performance and backward compatibility.
  • The objectID attribute is by default added to the attributesForFaceting and usable to filter like a facet: `filters=objectID:myObjectID`
  • We released a self-serve demo generator for Shopify store. You can now try the Algolia experience on your Shopify store in few seconds!
  • We released our Search Grader. It’s a free tool that helps you evaluate your product's search bar experience. Each user receives a customized report full of tips and material to help you understand what makes for a great search experience in terms of speed, relevance & design.
  • We released Algolia Search for Shopify, bringing instant search results to 300K+ store owners
  • We released two improvements in the API:
    • Ability to restrict the ignorePlurals API feature to a list of selected languages like in the removeStopWords feature. You can now specify the list of languages you are using in your record to avoid false positives.
    • Ability to restrict the usage of a secured api key to an IP via the restrictSources parameter
  • Beta release of InstantSearch Android. InstantSearch Android is a library providing widgets and helpers to help you build the best instant-search experience on Android with Algolia. It is built on top of Algolia's Android API Client to provide you a high-level solution to quickly build various search interfaces.
  • We released Awesome Algolia. Awesome-algolia is a public-facing, curated list of Algolia integrations, resources, and projects
  • We have performed few renaming in the Algolia API while keeping backward compatibility:
    • attributesToIndex was renamed in searchableAttributes in order to avoid the index/indexing confusion.
    • master/slave indices were renamed in primary/replicate everywhere in the API to avoid using an offensive term.
    Those changes are 100% backward compatible, the index will return the new settings only if you have set it with the new naming.
  • A new version of the index explorer has been deployed (indices tab in the dashboard). This release includes:
    • A new visualisation layout (we only display by default the searchable attributes with a "show more" option)
    • A better way to see ranking debug information with a clear visualisation of the difference with previous hit
    • A new way to display the ranking formula to help users implement easily a "sort by" on a specific attribute
  • We released Algolia Search plugin for WordPress. Help us bring relevancy, instant search and autocomplete capabilities to almost 30% of the internet!!!
  • We've deployed a new dashboard feature: users can now opt-out from specific emails, on a new dedicated Notification settings page.
  • Wet released a new major version (4.0) of our Swift API Client. The main purpose of this version is to support Swift 3, that has been recently released by Apple, alongside iOS 10 (among others). It also was the opportunity to improve in a few areas, especially Objective-C support.
  • We've released a new version of the Javascript helper. This is a minor version which mainly adds some missing capabilities to the hierarchical faceting and fixes an error message that was confusing users. The details of the release are here.
    We have also released a new website for the documentation of the Helper on our community website.
  • We released our Magento 2 extension! Check out the details on the blog.
  • We released a simpler way to manage application's team permissions.
    To access it, you can either click on the new "Team" icon on the dashboard sidebar or enter the URL https://www.algolia.com/team.
  • We've improved the pattern matching for the indices restriction and the referer restriction to allow to specify two * in the pattern. It's now possible to allow a complete domain with *domain.com*. For security reason the referer restriction should match in the domain, for example *algolia.com/search can't match fake.com/algolia.com/search.
  • We've made three improvements on our API:
    1. We've introduced a new parameter on the setSettings API call to forward the change to all replica (slaves) indices attached to the main index. This option is called forwardToSlaves and is available in all our API clients.
    2. We improved our removeStopWords feature, you can now specify the list of languages you are using in your record to avoid false positives (like "or" which is a stop word in English but means "gold" in French).
    3. Our geo-search also has a big improvement for users that want to sort by distance without filtering results - you can now use the query parameter aroundRadius=all for this use case
  • We've added two new settings to tune the exact relevance of queries with one word:
    • exactOnSingleWordQuery: This parameter controls how the exact ranking criterion is computed when the query contains one word.
    • alternativesAsExact: Specify the list of approximations that should be considered as an exact match in the ranking formula.
  • We've just released a dedicated API to manage synonyms, this API ease handling of big synonym set and introduce new features like the handling of 1-way synonym. You can learn more in this blog post.
  • We've just released a new monitoring api. This new API enables you to get health status, latency & indexing time from our probes, and, for enterprise customers, system metrics of your clusters/slaves. You can see the full documentation here. Happy monitoring!
  • We added two new index settings for advanced configuration of indexing & relevance:
    • disablePrefixOnAttributes: List of attributes on which you want to disable prefix matching (must be a subset of the attributesToIndex index setting). This setting is useful on attributes that contain string that should not be matched as a prefix (for example a product SKU). By default the list is empty.
    • disableExactOnAttributes:List of attributes on which you want to disable the computation of “exact” criteria (must be a subset of the attributesToIndex index setting). By default the list is empty.
  • We’re happy to announce the release of version 2.0 of the Algolia Go client (previously 1.4.0). This major update takes advantage of Go static typing by bringing types to the different parameters and responses. You can download it from the Releases page of our Github repository. Versions 1.x continue to be supported but they are now deprecated. We ask you to please upgrade to 2.x at your earliest convenience.

    An exhaustive list of all the changes is available on a dedicated Wiki page. It lists all the methods that have been added, changed or removed. As several users requested it, the Client and Index are now interfaces, which means that they are now mockable! Finally, Algolia synonyms are now fully handled.
  • We're excited to announce the release of our integration for Zendesk. This means anyone who uses Zendesk to power their knowledge base can now integrate Algolia's as-you-type search onto their help-center in just a few clicks, at no charge whatsoever.
  • We released a new major version (3.0) of our Android and Swift clients. This version brings a lot of new features as well as bug fixes/enhancements.

    The new Swift client is 100% compatible with Objective-C and is now the reference implementation on Apple platforms. As a consequence, the legacy Objective-C client is deprecated: still supported for bug fixes, but will not receive new features.
  • Improved dot notation handling in JSON paths. Previously, if you specified foo.bar in attributesToRetrieve, attributesToHighlight or attributesToSnippet, the entire foo object was retrieved/highlighted/snippeted. Now, only the specified path is, making the implementation eventually in line with the semantics of those parameters.

    Please note that, in effect, this restricts the returned data set as compared to the previous behavior. If you were relying on the dot notation being implicitly shortened to the first level, you may have to edit your query parameters and/or index settings to specify exactly the attributes you wish to retrieve/highlight/snippet.
  • Added backend API Client in Scala. Checkout the Scala Documentation / Reference doc on Github.
  • We released an Advice tab in the dashboard, that provides automatic recommendations to improve your index settings for a better performance and relevance.
  • We have now deployed on all clusters a big improvement in the way we do distributed consensus between our machines. The purpose of this was to improve the efficiency of Indexing speed, job processing capacity, and Replication.

    We have also improved a lot the replication time to your DSN slaves: the replication is done under one second in the vast majority of cases!
  • Launch of Algolia for Zendesk beta: a self-service to add Algolia search in your Zendesk Help Center.
  • We've just released our Scala API client.
  • Launch of DocSearch: The easiest way to add search to your documentation. Already used by dozens of companies and open sources projects (ReactNative, Scala, Laravel, …) to put their documentation search on steroid.
  • Improvement of our Secured API Key feature, the X-Algolia-QueryParameters header is no more required. All information are now encoded in the generated API Key, making it even easier to have a great security.
  • Launch of instantsearch.js: everything you need to build a great instant-search experience with Algolia packaged into one library of UI widgets.
  • Added removeStopWords boolean query parameter that removes stop words before applying the query. The option is available for 41 different languages.
  • Release of a new version of our Geo-Search feature:
    • Add support of multiple geo-locations inside one record
    • When searching around a geo-location, we have now an automatic way to adapt the radius to the density of the area
    • Add support of multiple bounding-boxes in the query
    • Add support of search in an area defined by a polygon
  • Added a way to disable typo tolerance for specific attributes via the disableTypoToleranceOnAttributes query parameter.
  • We have released a new way to add filters in a query via an unified filtering language (SQL like). We hope this language will help to ease the usage of complex filters on our API (mix or OR/AND conditions on filters)
  • Our Analytics API & dashboard now report the top rated-limited IP adresses if there are some.
  • To improve the readability of the operations graph, we're now extracting the underlying call types from your batch calls and display them using their own series.
  • Algolia service is now available in South-Africa region (Johannesburg).
  • The Browse feature has been improved to handle the same query parameters as a search query. That's definitely the right way to do an exhaustive search and retrieve more than the 1,000 hits you can fetch with a search query.
  • Algolia service is now available in US-Central region (Texas).
  • The Distinct feature has been improved! It now covers more use-cases:
    • De-duplication: retrieve a single record per distinct attribute,
    • Grouping: retrieve maximum N records per distinct attribute,
    • Big records indexing: efficiently index big records with multiple chunks.
    Last but not least, we removed the limitation of the empty query: you can now use the Distinct feature even with the empty query string + without any filters.
  • Our multi-queries endpoint now supports a strategy stopIfEnoughMatches. If this strategy is enabled and a query contains enough matches (defined by hitsPerPage query parameter), then the queries following this one are not executed and return an empty response set.
    This strategy is useful for advanced use-cases of query interpretation or if you require a minimum set of results in your query.
  • New advanced index setting to specify how numeric attributes should be indexed. numericAttributesToIndex allows to specify which numeric attributes of your records should be indexed and for which feature. This settings allow to improve indexing speed by indexing only the required attributes.
  • We have added an automatic processing of Miscellaneous Symbols and Pictographs of the Unicode format. You are now able to pass any of those symbols in the query and we will automatically add the english term in your query as optional. For example if you pass 👕 in your query it will add "t-shirt" as optional terms.
    • ignorePlurals feature was improved to handle 88 languages instead of the first 12 languages.
    • We now support indexing of html entities, for example belle époque will be indexed as belle époque
    • Added 3 new attributes for an api keys
      • description: is an attribute to identify an api key
      • queryParameters: is a way to force an api key to use specific query parameters during the queries like tagFilters=public
      • referers: allows to restrict an api key to a specific referer like *.algolia.com
      • syntax: {"description": "Key for algolia.com", "referers":["*.algolia.com"], "queryParameters": "hitsPerPage=10&tagFilters=public"}
    • Added two new per-user security headers:
      • X-Algolia-QueryParameters: allows to force the value of every query parameters
      • X-Algolia-Referers: allows to generate an api key for a specific referer
    • Added a new attribute for getObjects in order to filter the attributes to retrieve:
      • syntax: {"requests":{"objectID": "myID", "indexName":"myIndex", "attributesToRetrieve": "email,name"}]}
    • Added new endpoint to send indexing jobs across severals indices:
      • URL: /1/indexes/*/batch
      • syntax: {"requests":{"action": "addObject", "indexName":"myIndex", "body":{...}}]}
  • We merged our Node.js and JavaScript (browser) clients into one npm module: npmjs.com/alogliasearch.

    This has been done to unify our JavaScript APIs into one single implementation and provide our users an isomorphic JavaScript API client.

    Here are the main features of the new Node.js module:

    • works server-side and browser-side with the same API,
    • has a promise and callback API,
    • has automatic keep-alive,
    • has automatic proxy support through HTTP_PROXY environment variable,
    • is fully tested.
  • The synonym feature now supports multi-words synonyms like ["NY", "New York"].
  • All API clients are now using two separate DNS providers to maximize the availability of our service:
    • NSONE for the algolia.net domain. We use NSONE for the very advanced routing logic of our Distributed Search Network
    • Route53 for the algolianet.com domain that we use as a fallback.

    To upgrade your favorite API client, use this list:

  • The chart displaying the operations consumption has been split into several charts in order to be more readable. Now split in:
    • Search,
    • Records,
    • Index,
    • and ACL operations.
  • We released a new JavaScript client called V3. We wanted to bring our JavaScript client to a more modern state, thus we did it.

    Here are the main features of V3:

    • Promises and callback support
    • Callback is always the last parameter
    • Callback always called with (err, content)
    • npm, browserify, webpack compatibility
    • Full test suite

    See the migration guide if you want to upgrade.

  • A single Algolia account can now manage several applications. You can switch between apps from your Dashboard's top menu. Each application can be located in a different datacenter/region with a dedicated Algolia plan. Feel free to create extra applications to handle totally isolated dev/staging/prod environments!
  • We've upgraded the Dashboard's underlying JavaScript API client to the latest version in order the remove the OPTION preflight query that was done while performing CORS requests (some proxies/firewalls were blocking it).
  • Our Distributed Search Network option is now publicly available, you can now replicate your search engine in several locations in few clicks! No change is required in your code as soon as you use our Javascript API client or one of our mobile API client (objective-C, android, C#).
  • A new option (allOptional) was added for removeWordsIfNoResult index setting. With this option, a query that does not return any result will trigger a second trial with all words as optional (which is equivalent to transforming the AND operand between query terms in a OR operand).
    This option is recommended if you don't use faceting whereas lastWords is recommended if you are using faceting to avoid having to much change in facets.
  • A bunch of new features on the website:
    • New Getting Started section
    • Collaboration: you can now be invited in multiple teams using a single Algolia account
    • ACL: team members have now dedicated API keys, your Admin API key is kept private
    • Indices explorer now highlights the settings that have been modified
    • Here and there style improvements :)
  • Added 5 new operations to partially update an attribute
    • Add: Append an element to an array based attribute
    • AddUnique: Add an element to an array based-attribute if it doesn't exist
    • Remove: Remove the first element from an array-based attribute
    • Increment: Increment an numeric based attribute
    • Decrement: Decrement an numeric based attribute
    the syntax: { "_tags": { "_operation": "AddUnique", "value": "public" } }
  • Released two new features on the way query are handled:
    • One query word can now match two different words in a record. For example the query ladygaga will now match a record that contains lady gaga.
    • Multiple words queries can now retrieve a record that contains the fully concatenated version of the query. For example the query My little word can now match a record that contains mylittleword (was limited to two words previously, see Sept 6th entry).
  • Disjunctive faceting is now more efficient in our javascript API Client (version >= 2.8.3): instead of performing one query for each attribute used in disjunctive faceting, one query is performed for each attribute having at least one selected value. This new version allows to reduce a lot the number of queries. We strongly recommend to upgrade to this version of the API Client if you are using disjunctive faceting.
  • Added statistics on indexing performance (time between reception of an indexing job on our API and availability in search):
    • In the summary view of the dashboard you have now the number of indices that are currently building and the average availability time in seconds
    • In each index, you have a graph of time to index over time (in the "Stats" section of an index, this is the "Average build time" graph)
  • API calls can now be done on algolia.io & algolia.net domains. The algolia.net domain was added for performances reasons (DNS of .net TLD have more locations and they are less loaded, resulting in better performance for DNS resolution). All our API clients have been migrated to algolia.net domain so you have just to update your API Client to take benefit of this performance improvement.
  • Algolia is now available in 8 new regions, allowing you to get closer to your users. Learn more about our new Distributed Search Network feature.
  • We've just released a new Analytics REST API. For now it exposes 2 (beta) endpoints:
    • https://analytics.algolia.com/1/searches/{index}/popular: retrieve popular queries,
    • https://analytics.algolia.com/1/searches/{index}/noresults: retrieve popular queries returning 0 hits.
    New endpoints will be added in the next coming months. Feedback are appreciated :)
    • Introduced a new query parameter ignorePlural to consider singular/plural as identical (default to false)
    • Introduced a new index setting allowCompressionOfIntegerArray that allows compression of big integer arrays. We recommended to store the list of user ID or rights as an integer array and enable this setting. When enabled the integer array are reordered to reach a better compression ratio (default to false)
  • You can now update an API key after creation via the two new API endpoint: This feature was also added in all API clients.
  • We added a feature to consider that two words separated with a space can match a concatenated word. For example the query rap genius will now match a record that contains rapgenius.
  • We have changed the default typo tolerance settings to:
    • minWordSizefor1Typo=4 (we tolerate one typo when a query word contains at least 4 letters, was 3 before).
    • minWordSizefor2Typos=8 (we tolerate two typos when a query word contains at least 8 letters, was 7 before).
    This change allows to have less results with typos when you have a lot of entries in your index.
  • We have added a feature to prevent search queries without any result. You can now use the removeWordsIfNoResults query parameter to allows a partial match of the query. There is two different strategy available:
    • LastWords: when a query does not return any result, the final word will be removed until there is results. This option is particularly useful on e-commerce websites
    • FirstWords: when a query does not return any result, the first word will be removed until there is results. This option is useful on address search
  • Added a new query parameter aroundLatLngViaIP that use the IP as source of geolocation.
  • You can now setup double factor authentication using google authenticator on your account. You can enable it in your "My account" section of your account.
  • An API can now target a group of indices using a prefix ("dev_*" for example) or a suffix ("*_dev" for example). This feature is useful to easily target all indices of one environment (prod/qa/dev). The feature is documented in our REST api documentation.
  • We have added an option to restrict a search query to a subset of indexed attributes. This new query parameter is named restrictSearchableAttributes and is available in all API clients.
  • We have added an option to set the same priority to several attributes in the attributesToIndex settings. If you want to set the same priority to several attributes, you have just to put them in the same string using comma as separator. For example ["title,alternative_title", "text"] will give the same priority to title and alternative_title attributes.
  • Partial updates have now an option to avoid creation of the object if it does not exist in the index. This new option is supported in the partial update method of one object via the createIfNotExists=false URL parameter and in the batch method via the partialUpdateObjectNoCreate action.
  • We added a way to retrieve N objects with one API call, this new method is exposed in our REST API and in our API Clients via the getObjects method.
  • We have introduced two new index settings:
    • disableTypoToleranceOn: specify a list of words on which the automatic typo tolerance will be disabled.
    • altCorrections: Specify alternative corrections that you want to consider.
  • We have added support of NOT operator in numeric, tag and facet filters.
  • Ability to fully disable the typo-tolerance setting the typoTolerance query parameter to false.
  • We have added a new ranking parameter. The words ranking settings sort according to the number of query words matched by decreasing order. This parameter is useful when you use optionalWords query parameter to have results with all matched words first.
  • We have added an automatic processing of expressions that contain an apostroph, dash or dot:
    • Apostroph: for example dont or don't queries will retrieve records that contains dont or don't.
    • Dash: for example iphone or i-phone queries will retrieve records that contains iphone or i-phone.
    • Dot: for example A.B.C or ABC queries will retrieve records that contains A.B.C or ABC.
  • We have added support of numeric attributes in ranking. You can now use asc(attributeName) to sort by ascending order on a numeric attribute and desc(attributeName) to sort by descending order. You can specify these conditions in the ranking parameter of index settings. attributeName can be the name of any numeric attribute of your records (integer, a double or boolean).
  • Our Javascript client now supports all web browsers and misconfigured proxy/firewall. We have added an automatic fallback on JSONP when CORS is not available. You just need to update our Javascript client, you have nothing to change in your code.
  • New query parameter allowTyposOnNumericTokens to disable typo-tolerance on numeric tokens.
  • We have added support of synonyms in the index settings, you can check how to use them in our documentation page.
    We have also added support of placeholders, this is an advanced use case to define a token substitutable by a list of words without having the original token searchable. This can be used for example to allow a set of numerical values to matches, for example <streetnumber> = (1, 2, 3, ...., 9999)
  • Our rails gem is now able to configure multiple indexes (including slaves) from the algoliasearch block.
  • We've just released our Go client
  • facets query parameter now support wildcard at the end of string. For example, you can for example use "author*" to match "author.name" and "author.company".
  • attributesForFaceting index settings can now be a root element. For example you can have "author" in your attributesForFaceting that will include "author.name" and "author.company".
  • All numerical-based facets now return the associated min, max & avg values. The info is available in the facets_stats attribute of the JSON answer, statistics are computed on all facets before the application of the maxValuesPerFacet parameter.
  • A weekly usage summary email is now sent each Monday morning (current use, most frequent queries returning no results, last-week comparison...)
  • Introduce Per-User Security filters: ability to restrict a query to target a subset of your data only.
  • Numerical filters can now be ORed.
  • Ability to remove queries from the analytics feature setting the analytics query parameter to false.
  • Welcome Analytics! From a simple dashboard, get valuable information on what and how people search on your service.