Are you working with large number of entities, being customer specific prices or entities that changes often like e.g. inventory numbers?

Up until now Enterspeed has had its strength on static data from a CMS, a PIM system or something similar. This is because the way Enterspeed preprocesses the data making it stable and fast to fetch on the client.

But no approach is the perfect solution for all use cases, and we know that not all data is static and requires transformations. So, why put data through a transformation process that takes a lot of resources if the data doesn’t need transformation or if it’s never even being fetch by the client?

That’s why we added a new type of data flow in Enterspeed called Auto Indexing.

It’s a feature you enable on the Source group. Once it’s enabled all the data you ingest into this Source group will automatically be added directly to an Index you can query from the Query API.

The new Auto Indexing mode lives comfortably together with the existing schema transformation mode, given you the options to use whatever mode is the best for your specific data set and often it will be a combination of both for your project.

When using Auto Indexing you don’t have the option to create schemas for the source entities, so you can’t do transformation on the data. But instead, you can ingest a large volume of data and have frequently changes to the data making it perfect for dynamic data like customer specific prices or inventory numbers. And especially in combination with the bulk Ingest API you can really send some data through to Enterspeed and have a fast and flexible Query API to fetch the data and offload your ERP system or wherever your data is coming from 🚀

Head over to your Enterspeed tenant today and start using the now Auto Indexing mode and if you need more information, check out the documentation about Auto Indexing.

🚀 The Query API .NET SDK has been updated with a completely new syntax.

We've rebuilt the SDK around a fluent QueryBuilder API. Queries are now constructed in a way that feels natural in .NET – type-safe, chainable, and with full IntelliSense support. If you're on the previous version, it's worth upgrading.

What's new

• Fluent QueryBuilder API – chain filters, sorting, pagination, and facets in a single expressionTyped query builders – use your own C# models to drive queries; property names are automatically camelCased, or mapped via [JsonPropertyName]
• Lambda-based filtering – reference model properties directly instead of magic strings
• Nested logical grouping – compose complex AND/OR filter trees with ease
• ISuccess / IFailure result handling – no more silent failures or unchecked nulls
• Non-typed builder still available – if you prefer to work without generics

Getting started

1. Install or update the NuGet package
2. Register the service:
   services.AddEnterspeedQueryService()
3. Start building queries – check the GitHub repo for full docs and examples

We've added a safeguard to prevent accidental type changes that could break your content delivery.

What changed

The Ingest API will now reject requests that attempt to change the type of an existing source entity. If you re-ingest a source entity with a different type than what was originally stored, you'll receive a 422 validation error.

Why we made this change

When a source entity's type changes, any routes or views bound to that type become stale — potentially breaking content delivery without warning. This guard makes type mismatches fail loudly rather than silently, giving you immediate visibility into the issue.

What you need to do

In most cases, nothing. This guard only triggers if your ingest pipeline is attempting to change the type of an entity that already exists.

If you see the error and the type change is intentional, you have two options:

1. Delete the entity first — Remove the source entity via the delete endpoint, then re-ingest with the new type. This is the recommended approach as it properly invalidates dependent routes and views.
2. Use the bypass header — Include the X-Enterspeed-Force-Type header in your ingest request to override the protection. Only use this if you're certain the type change won't cause downstream issues.

Example error response

If you encounter this unexpectedly, it likely indicates a data inconsistency in your ingest pipeline that's worth investigating.

Questions or concerns? Reach out to us on our support Slack channel or at support@enterspeed.com — we're happy to help.

We have added a bunch of new features for the source entities, making it easier for you to navigate, find the right source entity, and even edit existing source entities.

The list of new features includes:

• Show source entities as a tree view – lets you navigate to a specific source entity using the same structure you have in your CMS instead of searching by id or URL, or navigate product data by category, product, and variants.
• Open source entities in a side panel – makes it easier to quickly view different source entities without leaving the list of source entities. You can still navigate to a full page view of a source entity if you need more space.
• Edit source entities – Until now you have been able to add and delete new source entities directly from the Management App. Now you can also edit existing source entities which is especially useful when testing in early stages – and of course this will be logged in the Activity log, so you can see who changed a source entity.
• Add new source entity as child entity – this is just a nice little addition to the context menu of a source entity so you don't have to figure out the parent id yourself.

The above list is just some of the hightlights, even more small improvements have been added, so make sure to check it out next time you sign in to your tenant in the Enterspeed Management App 🚀

Shopify is undoubtedly the leading commerce platform out there, and now you can push products directly from Enterspeed to Shopify. 

With our new Shopify Destination, you can map your product, variant, and pricing data – and more – from any source system in Enterspeed, then push it directly to one or multiple shops in Shopify.

The Shopify Destination is now in preview. It supports things like price lists, metafields, and translations all in a single unified model. You don't need to deal with Shopify's GraphQL API, async bulk ingests with callbacks, rate limits, internal Shopify ids, or multiple request to fully update a product. We handle it all for you .

If you want to get started or have any question, just reach out. 

Check out the blog post for more info https://www.enterspeed.com/blog/announcing-the-enterspeed-shopify-destination or head over to the documentation: https://docs.enterspeed.com/integrations/shopify

 🚀 Today we launched the .NET SDK for the Enterspeed Query API. 

The Query SDK works seamlessly with the existing Delivery SDK and brings all the powerful features of the Query API directly into your .NET projetcs:

✅ Filtering, sorting, pagination, and facets
✅ Dynamic view references
✅ Strongly typed results – no more generic data structures or magic strings 

Getting started is simple:

1. Install the Nuget Package
2. Add the service registrations
   
   
   
3. Start querying your index in a strongly typed way – no need to worry about HTTP clients or plumbing. We’ve done the heavy lifting for you.

Check out the open source Github repo for documentation and more examples 🚀

You can now read Delivery views as your own C# types. Keep the flexible fetch you know, but de-serialise per-view into real models with IntelliSense and compile-time safety. No more rummaging through dictionaries.

What’s new

• Typed variant of Fetch: fetch as usual, then read each view with GetContent().
• Per-view typing: mix multiple handles (e.g. article, navigation, footer) in one request and deserialise each into its own model.

Why it matters

• Fewer runtime surprises: let the compiler and your IDE do the heavy lifting.
• Cleaner contracts: define a C# model instead of magic dictionary keys all over your code base.
• Less boilerplate: no need for custom serialization.

Example: multiple views, multiple types

Fetch several views in one go, then read each as its own model:

Useful links

• Delivery SDK (.NET) repo & README – install, register, usage, and strongly-typed examples. GitHub
• Docs: Delivering data – overview of Delivery API. Enterspeed Documentation | Enterspeed Docs

Thanks to the community

This shipped because a user opened a clear feature request with suggested behaviour. So, keep the issues and PRs coming – we’re listening.

We’ve improved how you track deployments in the Activity section. Instead of just seeing that “someone deployed something,” you now get full transparency:

• Clear logs showing deployments – including who did it
• Optional comments attached to each deployment, so you can understand the why
• See which items were deployed together
• Detailed history for individual schemas, including when they were created or published

These improvements make it easier to keep track of projects and give you a complete overview of who did what, when, and why.

Go to your activity log to see what you can do: https://app.enterspeed.com/settings/activity-logs

We are proud to announce the public release of our new Query API, adding even more power to the Enterspeed platform.

The last couple of months during the public preview phase we've gained a lot of valuable feedback and brought a lot of this feedback into the public release. Thank you so much to all of you helping to shape and make Enterspeed an even better product.

The Enterspeed Query API

The Enterspeed Query API lets you easily build search indexes from a new Index schema type and return lists of items – directly within the Enterspeed platform. It also, as the name implies, brings a new Query API that lives side by side with the existing Delivery API, which gives you even more power and flexibility in the way you can fetch data from Enterspeed.

Some of the highlights in the Query API are:

• Easy creation of new search indexes without new infrastructure or external search providers
• Filtering, sorting, pagination, and even facets on request time
• Deep integration with existing full-schema views, letting the query result return views
• Do multiple queries in a single request

Quick start

1. Create an Index Schema for the data you need list/filter on (e.g., productIndex). Index schemas define the fields and their types you want in the index and maps the data to go into the index.
2. Get an Environment API key (Management App → Environment client) to call Delivery & Query API. Just like you know it from the Delivery API.
3. Query the index via POST https://query.enterspeed.com/v1/{indexAlias} with filters/sort/pagination — optionally add aliases to get Delivery API views per item. 

Check out the full launch blog (background, facets & Delivery API integration examples - plus pricing) 👉 Launching the Enterspeed Query API 

Links

• Query API docs (endpoint, filters, facets, aliases, responses) Enterspeed Docs
• Index Schemas (when & why to use indexes vs. full schemas) Enterspeed Docs