Skip to main content

Changelog

Notable changes to the embed SDK, the platform API and these docs. The SDK is versioned at /embed/v1/* and the API at /inference-api/b2b/v1/*; a breaking change ships as a new major version beside the old one (CDN versioning). Additive changes, such as a new stream event or response field, ship without a version change, which is why clients must ignore what they do not recognize.

2026-10-21: the viewer chat bar, and answers from the map's own places on​

  • A chat bar for your page. <kaleidr-map product="viewer" layout="bar"> is one question field that opens the published map with the visitor's question: over the page by default, or on your own page with results-url. Its title, placeholder, example questions, accent, theme and language are attributes. See Chat bar.
  • A viewer can open with a question. prompt, or prompt-param to read it from the page's URL, and the iframe's q parameter put a question to the map's Kaleidr AI when the map opens; handle.send() asks from code. Additive: no version change.
  • Answers from the map's own places are on. The Ask Kaleidr panel on a published map or share link answers first from the named places the map shows. See Answers from the map's own places.
  • The template store writes the code. template.kaleidr.com builds both snippets for a map you choose. The downloadable website templates are retired.

2026-10-18: a share link's Kaleidr AI needs its map published​

  • A share link's Kaleidr AI stops when its map is unpublished. It also works only on the pages the map's allowed domains include now, not those of the link's snapshot. Unpublishing the map or removing a page's domain stops it within five minutes, as on the published map, and publishing again restores it. Its Control Tower and Popup Window switches still come from the snapshot, and the link itself keeps showing its map. POST /sdk/share-sessions answers 404 not_found for a share link whose map is unpublished. See Kaleidr AI on a published map.

2026-10-16: Kaleidr AI on a published map follows the map's own switches​

  • The map's Kaleidr AI tile is the only switch. In Studio, Control Tower gives the published map's visitors the Ask Kaleidr panel and Popup Window gives them AI chat in its popups, in the iframe and the Viewer element alike. The Visitor AI Chat switch in Share, Embed is gone. See Kaleidr AI on a published map.
  • No per-map monthly limit. The Monthly AI Credit Limit field is gone. Visitors spend the owner's AI credits up to the plan's allowance; the per-visitor and per-map rate limits are unchanged.
  • POST /sdk/share-sessions takes feature. control_tower (the default) or popups, each granted only while its switch is on, else 403 chat_disabled. See POST /sdk/share-sessions.
  • A share link opens Kaleidr AI too. Its id is granted from the link's snapshot: the Control Tower and Popup Window switches and the allowed domains as they were when the link was created, with the map's owner paying. Turning Kaleidr AI off in Studio does not turn it off on a share link already handed out. An unknown id is still 404 not_found.
  • Viewer and Tile zoom on scroll, as in Studio. Scrolling with the pointer over the map zooms it, with no Ctrl or ⌘; with the pointer outside the map, scrolling moves the page. The gestures=greedy iframe parameter is no longer read.

2026-10-14: what is at a point, and two endpoints deprecated​

  • New: POST /spot and POST /spot/overview/stream. /spot answers what is at a point: the clicked place, the nearest street address and the regions that contain it, each value with the credit to show, and on request the place's content and photos. /spot/overview/stream streams the overview of one thing it returned, after a place frame that names the place in full. See POST /spot.
  • /spot charges for content only when it is fetched for the call. Content already fetched for an earlier request costs nothing, so a /spot content lookup costs the same as /retrieval/poi/enrich or less.
  • Deprecated: GET /retrieval/poi/enrich and POST /chat/summary/stream. They answer as before until 2027-01-15 and can be removed after it. Their responses carry Deprecation, Sunset and a Link to the successor. See Moving from the deprecated endpoints.
  • tenants are returned. /spot returns the businesses in a building as tenant entities with a poi: ref, under CDLA-Permissive-2.0, instead of withholding them. They stay free.
  • Every summary is charged. A place summary or overview is charged for the tokens used on every request; the cached field of its start and end events is no longer sent.
  • A building summary has no successor. A building's overview is not available through the API. See What the API does not return. /spot/overview/stream accepts building: with no id and answers it, like building:<id>, with one error frame.

2026-10-13: product changes, and the documentation corrected and expanded​

This entry has two parts. Product changes and API limits and refusals list what changed in the product with this release. Corrections to these pages lists where the documentation described something the product does not do: the pages were checked line by line against the SDK and the API, corrected and expanded. If you built against an earlier version of these pages, read the corrections.

Product changes​

  • Business data is uploaded in Kaleidr Studio. The upload screen is the Data for AI Answers section at the bottom of the Data panel of any map: choose a .csv or .json file, propose and review a column mapping for a CSV, preview, publish, and see the result in the Releases list. It is the only upload screen, its upload controls appear only for an owner or admin of an organization that may upload, and it runs the same pipeline as the upload API, which is unchanged. An organization that has left Enterprise and still holds releases keeps the section for its owners and admins, with the sentence "Uploading is part of the Enterprise plan." and the Releases list; everyone else below Enterprise does not see it. See Answers from your own data and What the section shows when you cannot upload.
  • Business data is Enterprise only, for uploading and for answers. An owner or admin of an Enterprise organization uploads and publishes, and Kaleidr Studio's assistant answers from the data for the organization's signed-in members only while the organization is on Enterprise. Free and Pro cannot upload it. The limits on an upload (places, documents and file size) are per organization and are set in its agreement, never above the platform's own ceilings. An upload over a limit returns 422 with the limit and the plan in the reason. The plan that counts is the organization's Kaleidr plan, the one bought and changed on kaleidr.com/billing. Reading the data through an API key or the SDK needs the vendor scope, which is also Enterprise only. See Availability by plan.
  • Datasets on a map have limits by plan. The files a signed-in user adds to a map in Kaleidr Studio's Data panel are available on every plan, and are now limited per plan: on Free, 50,000 rows in one dataset, 32 MiB for one file and 250,000 rows across all of the organization's datasets; on Pro, 100,000 rows, 64 MiB and 5,000,000 rows. On Enterprise, one dataset and one file have the same ceilings as on Pro, and the total across the organization is set in the agreement. A plan limit refuses a new upload only, with HTTP 402 quota_exceeded, and data already stored is kept. Four ceilings apply on every plan, Enterprise included, and are refused with HTTP 400 VALIDATION_ERROR, not the 402: a file over 64 MiB, a dataset of more than 100,000 rows, a geographic file of more than 50,000 features, and an image overlay over 16 MiB (the image Studio makes from a GeoTIFF, not the GeoTIFF file). JSON pasted into Studio's uploader is stored inside the map itself, for any user, and is not counted against these limits. See Datasets on a map and Errors.
  • A refused dataset upload adds nothing to the map. In Studio, any refusal from the server is shown next to the upload control and the file is not added: a plan limit (402) with the server's sentence and an Upgrade Plan link, and a signed-out session, a missing permission, a file too large to send, too many uploads, or any other refusal, including the 400 for a file over a ceiling, with a message. Only when the server gives no answer, times out or faults are the rows stored inside the map instead, with a warning, and only for a table within the plan's limits; otherwise nothing is added. See When an upload does not go through.
  • Deleting a dataset in the Data panel deletes it for good. The trash control on a stored dataset asks for confirmation, then deletes the dataset, removes it and its layers from the map, and frees its rows from the organization's total. The dataset stops being served on the published map and on share links. Uploading a file with the same name replaces the earlier dataset once the new one is stored; if the new file cannot be read, the map goes back to the earlier data and Studio says so. Undo can bring back the map's reference to a deleted dataset, and that layer is then not drawn. See Delete or replace a dataset.
  • Studio's limits follow the organization's Kaleidr plan. The number of maps an organization can keep and the dataset limits above are those of the plan bought and changed on kaleidr.com/billing. Kaleidr Studio has no plan of its own.
  • A published map and a share link show the map's uploaded data. The datasets added in Studio's Data panel are drawn as layers, and image overlays are drawn, for visitors in the embedded viewer and on share links. Only data a published map includes is served. Deleting the dataset in the Data panel stops it everywhere, on the published map and on every share link that drew it. Unpublishing the map stops its embeds, while share links already handed out keep working with the data they had. A browser that already loaded the data keeps it, and a download link already issued can stay readable for up to one hour. Each visitor downloads a dataset whole, with all of its columns, so a large table loads slower for visitors and a published dataset is public. See Uploaded data on a published map.
  • A published map can be unpublished in Studio. The Publish & embed page has an Unpublish button for a live map, with a confirmation. Every embed of the map then shows its "isn't available" message. The map keeps its id, so publishing again restores the same embed URLs. See Unpublish a map.
  • Studio's AI assistant answers questions about a whole dataset. On the map that is open, the assistant works on every row of an uploaded dataset, not on a sample: it can filter, sort, count, total, average and group the rows, and find the rows near a point or inside an area. It answers from one dataset at a time, a result lists at most 100 rows or groups, and it reads the data without changing it. See Ask the assistant about a dataset.
  • Datasets have column roles. After an upload, Studio detects which column is the Name, Category, Description and Address, and the author corrects them in the dataset's Column Roles fold in the Data panel. The Name column is what Studio's AI assistant, and a published map's chat, call each place. Uploading a file with the same name in Studio stores a new dataset, and the roles set on the earlier one are carried over to it where the new file still has those columns. See Column roles.
  • Visitor AI Chat can answer from a published map's uploaded datasets, where answers from the map's own places are on. That behavior is switched on by Kaleidr for the whole platform and is off by default. Where it is on, the places the chat reads now include the rows of the datasets the published map includes, when the dataset has a Name column and the row has point coordinates, within the limit of 200 places for one map. See Answers from the map's own places.
  • A new call reports what an organization may upload. GET /shared-api/datahub/limits returns whether the organization may upload business data, its plan and its limits. It answers 200 on every plan, with can_upload: false below Enterprise. The Studio section shows the same limits in one line. See What your organization may upload.
  • The refusal for a plan that may not upload is 403 vendor_data_not_on_plan. It replaces the code these pages listed before, which is no longer returned. Update any client that matches on the earlier code.
  • A release can be unpublished and deleted. POST /shared-api/datahub/releases/{id}/unpublish takes the published release out of service at once; DELETE /shared-api/datahub/releases/{id} removes a release that is not published, with everything made from it. Both are for an owner or admin on any plan, including after a downgrade, and Studio's Releases list offers them as Unpublish and Delete, including to the owners and admins of an organization that has left Enterprise and still holds releases. The release list gained state and ingest_id. See Taking a release back out.
  • Old releases are removed automatically. A release that is no longer current (replaced, unpublished, or an expired preview) is removed 30 days after it stopped being current, and a failed one 30 days after its last processing attempt. See How long releases are kept.
  • A mapping proposal spends AI credits. POST /inference-api/vendor/mapping/propose is charged to the organization's AI credits and answers 429 quota_exceeded when they are used up. Its limit of 30 proposals per account per hour remains; the two 429s differ in their body. See Telling the two 429s apart.
  • The vendor scope is Enterprise only. Free and Pro keys cannot hold it. Creating a key that requests vendor on Free or Pro returns 403 tier_capability_not_allowed; until now a Free request had the scope dropped without an error, and Pro could create the key. Rotating an existing key that carried vendor on a plan below Enterprise returns a key without it. After a move from Enterprise to a lower plan, existing keys stop reaching the data without an error and open browser sessions are ended. Pro still adds server keys and more active keys. See Auth and scopes.
  • Chat takes a language, a title and a placeholder. New mount options lang, title and placeholder; on the element, the attributes lang, chat-title and placeholder. With no lang, the panel uses the page's <html lang> when it is a well-formed tag, otherwise English. See the Chat reference.
  • <kaleidr-map> is a block by default. The element is display:block unless your own CSS says otherwise, so a height on it applies. Until now a height had no effect unless you also set display:block. Snippets keep display:block for Safari before 16.4. See Sizing.
  • Handle calls made right after mounting are kept. On Viewer and Tile, a setCamera (and on Tile, a setStyle) made before the map inside the frame is ready is applied when it becomes ready, up to the latest 256 calls. Such a call used to be lost. If the map has not reported ready after a bounded wait, normally 10 seconds after the frame loads, the kept calls are sent anyway, with one console warning. You no longer need to wait for kaleidr-embed:ready before calling the handle.
  • The CDN base override accepts three kinds of origin only. The base option and attribute and window.__KALEIDR_EMBED_BASE__ are honored for the Kaleidr CDN (https://cdn.kaleidr.com), the origin kaleidr.js was loaded from, or the page's own origin. Any other value is ignored with a console warning and the default CDN is used. Self-hosting keeps working when the loader and the bundles are served from the same origin. See CDN versioning.
  • Product scripts load as UTF-8 on every page. The loader now loads the product scripts as UTF-8 whatever encoding the page declares. Until now, on a page that declared none, Chat or Editor could fail to mount with chat.js loaded but window.KaleidrGeoChat is missing in the console. See Troubleshooting.
  • Mounting again after destroy() is safe on the same element, including while the first mount is still loading, as happens under React's strict mode.
  • A refused request holds no credits. A request refused before it is processed (a rate or concurrency limit, a validation error, an over-large body) no longer keeps any AI credits or a concurrency slot afterward. See Quota and rate limits.
  • A camera from your page wins on Viewer and Tile. A camera passed at load (center, zoom, pitch, bearing, or camera in an iframe URL) or with setCamera now wins over the view the map's author saved, including a view saved for the visitor's screen width and content framing, and ends the map's automatic re-framing on resize. Fields the page does not pass keep the author's values, and a zoom passed at load without a center is ignored. See Camera.
  • Chat on a Viewer or Tile element keeps its pins. Pins now add up across answers there, as on the other maps, and a place sent again with new coordinates moves its pin. Closing or destroying the chat removes its pins, its route and anything else it drew. See Capabilities and limits.
  • The chat's title is the panel's title. A title you pass is shown in the chat window's header for every conversation. The header appears once a conversation starts. Until now a title taken from the conversation replaced it. A minimized chat shows its own conversation's title. See Title and placeholder.
  • The Editor identifies its basemap requests with your publishable key. An Editor mounted through kaleidr.js sends the page's publishable key with its requests to https://tile.kaleidr.com for the style, the sprites and the fonts. A session token is never put in a URL. There is no new option. See What runs in your page.

API limits and refusals​

  • Chat stream requests have limits, with their own codes. 422 too_many_messages, message_too_long, conversation_too_long, invalid_session_id and lang_too_long. See Endpoints.
  • The summary and button streams refuse an over-long field with 422 field_too_long.
  • A request body over 2 MiB (5 MiB on the design endpoints) is refused with 413 request_too_large.
  • A chat stream that ends without completing is charged for at least the conversation it sent.
  • A session token sees less. For a session token, the 429 quota_exceeded body and the quota stream event no longer carry the plan, usage or limit.
  • A product limit on a server or legacy key is enforced on each request, with 403 product_not_allowed.
  • The business-data upload gained per-field and per-list limits, 413 request_body_too_large, 409 org_ingest_in_progress and 429 ingest_rate_limited, and the mapping-proposal call now requires an owner or admin of an organization that may upload (Enterprise). See Upload your business data.
  • A dataset upload in Kaleidr Studio over a plan limit is refused with 402 quota_exceeded, and one over a ceiling of every plan with 400 VALIDATION_ERROR. See Errors.

Corrections to these pages​

Each item below is a place where the pages were wrong and the product did not change.

Error codes and statuses

  • A request over your AI-credit quota returns 429 with "error": "quota_exceeded". Earlier pages showed b2b.tokens_exceeded, which the API has never returned. The documented body was also missing detail, product and period.
  • There is no map_load_hard_stop code. See "Plans" below.
  • A session exchange from an origin outside the key's list returns 403 origin_not_allowed. Earlier pages said session_origin_mismatch, which is the code for a session token used from a different origin than the one it was issued for.
  • vendor_scope_requires_acknowledgement is a 422, not a 403, and applies to publishable keys only.
  • sessions_disabled is a 404 and sessions_not_configured is a 503. Both were listed as 403.
  • A 401 has the body {"detail": "Invalid or missing API key"}. It was documented as having none.
  • map_load_quota_exceeded arrives as {"detail": "map_load_quota_exceeded"}. The flat example body shown before does not exist.
  • A key-service outage answers 401, not 503.
  • Passing a key to a Viewer embed does not fail with product_not_allowed. Viewer needs no key.
  • Codes that were missing are now listed, including visitor_limit_reached, chat_disabled, not_found, owner_has_no_organization, org_admin_required, key_not_found and key_already_rotated.
  • key_already_rotated and key_expired on an edit concern expires_at only; a key's other fields can still be edited. Revoking a key that is already revoked returns 200.
  • Where a refusal's code is. A 403 or 404 carries its code in detail. A 429 from the platform API carries it in error, with a sentence in detail; map_load_quota_exceeded is the exception and arrives in detail. The upload API's 429s are listed in Response shapes.

The full catalog is in Errors.

Plans, quota and keys

  • Your own data in answers was described as "starting at Pro". Business data in AI answers is Enterprise only: both uploading it and the vendor scope that reads it through the API or the SDK. What Free and Pro have is a separate feature, datasets added to a map in Kaleidr Studio. See "Product changes" above.
  • Map loads stop at the allowance on every plan. Earlier pages described paid plans continuing to five times the allowance. That behavior does not exist. A map-load pack raises the limit.
  • AI credits are one pool per organization, shared by your API keys and your team's use of Kaleidr's own apps. Earlier pages described a separate monthly API token budget.
  • The quota period is your billing period, not always the calendar month.
  • Rate limits are per key; concurrency is per organization. Earlier pages said keys "rate-limit together".
  • An allowed-origins list is optional on a publishable key. One page said a live key required at least one origin; an empty list means any origin.
  • Scopes cannot be edited after a key is created. Pages that described editing or removing a scope were wrong: create a new key and revoke the old one.
  • Server keys and legacy keys are sent directly on runtime calls. One page said every runtime call uses a session token.
  • Rotation on Free. A publishable key rotated on Free becomes the whole Free surface (ai, maps, design; all four products), whatever the old key held, and rotating a server or legacy key on Free is refused with 403 free_plan_publishable_only.
  • monthly_cap_tokens: 1 or more is a cap; 0 or null means no cap.
  • org_id on key creation goes in the JSON body. A query org_id is read on the other key routes only.
  • Visitor AI Chat counts every request. One question is one request for the answer plus one photo request for each result card in it. Opening a place card, a follow-up question, an address lookup in Directions and a route are further requests, all against the per-visitor limit. See Chat on a published map.

See Quota and rate limits and Auth and scopes.

Streaming

  • The quota event is the last event of a stream, after end or error. It was documented as arriving mid-stream. It reports usage; it cannot warn you before a stream ends.
  • A place event can arrive without coordinates, marked unverified: true.
  • The error event carries code in one case only, upstream_stall.
  • Card and layer events that the stream sends (weather_card, building_card, arrivals_card and others) are now listed.
  • The summary and button streams are now documented.
  • A session token's quota event carries only type, meter and reset_at. One example showed usage numbers, which are sent to a server key only.
  • end repeats five card and layer events, not all of them: weather_card, satellite_card, constellation_layer, weather_layer and vehicles_layer.

See the SSE wire contract.

Endpoints

  • The request bodies for POST /design/analyze and POST /design/apply-direct were wrong; the documented analyze body returned a 422. Both are corrected, and the catalog responses are shown with their wrapper key.
  • POST /chat/control/route takes lat and lng directly on each place, not nested under coordinates.
  • system messages sent to POST /chat/control/stream are ignored. This was not stated.

See Endpoints.

Published maps and share links

  • A published map shows the map as it is currently saved. Earlier pages said an embed shows "the last published version" and that Re-publish updates it. It does not work that way: an edit saved in Studio, including a dataset added to the map, is public the next time an embed loads, with no re-publish. Re-publish records a new published version and keeps the same id, link and embed code. To change a map privately, unpublish it first and publish it again when you are done. See Embed a map.
  • Share links cannot be deleted or paused in Studio. Opening Studio's Share dialog publishes the map and creates a new share link each time. A share link is a snapshot of the map's design; it keeps working after the map is unpublished, until its map is deleted or Kaleidr removes the link at your request. Earlier pages described deleting or pausing a link, which no screen offers. See Share links.

SDK and embeds

  • Chat moves the map. Earlier pages said chat does not drive the map camera. It does: it flies and fits your map to the places in an answer, adds its own pins and draws routes. Only the mount handle's setCamera is unsupported on chat.
  • The Editor's scope. The Editor embed is an in-page editor whose work lives in the page's memory. It does not save, export or publish, and it does not call the design API. Pages that described publishing from the embed were wrong.
  • Content Security Policy hosts. The Editor loads its basemap from https://tile.kaleidr.com, which was missing from the policy page. No embed contacts a third-party map host by default. Chat loads the icons of the sites an answer cites from Google's favicon service, which the policy page and Capabilities and limits now list.
  • Leaflet is documented again as a supported map for Chat, with Mapbox GL JS, MapLibre GL JS and the Google Maps JavaScript API.
  • The Tile frame's URL carries no credential. It holds the style id and the camera only: neither the publishable key nor the session token. The session exchange for Tile checks the key, counts the map load and returns the organization's default basemap; the map in the frame makes no call with it. See Tile reference.
  • Kaleidr.enable(false) holds only mounts made after the call. A <kaleidr-map> element the browser has already read when the loader runs mounts at once, before your call. Use the page flag window.__KALEIDR_EMBED_ENABLED__ = false, set before the loader.
  • Kaleidr.mount with no options object throws a TypeError. Every other failed mount logs one console error, which contains [kaleidr:<product>] (it is printed as Error: [kaleidr:…), and does not throw.
  • The embedded Editor's rail has Text, Image, Marker, Popup, Background, Layer, Design and Legend. Earlier pages said it had no Design entry; what the embed lacks is Studio's design catalog, the Data tab, the AI panel and the 3D model library.
  • kaleidr-plain has 3D buildings from zoom 15. It was described as having none.
  • A Tile with no style and no organization default posts kaleidr-embed:error with code: 'no_id' and id: null.
  • shareId on Viewer takes the published map's id or the 16-character id of a share link. Chat on a published map takes the published map's id only.

New pages​

2026-10​

  • More on each address result. GET /retrieval/geocode/forward results now carry id on a street address (Kaleidr's identifier for that door, stable across data updates), and an estimated address also carries within_m and score beside method and matched_numbers. method can be "range": a US house number placed along the block that holds it. All additive; see Endpoints.
  • API keys on the Free plan. A Free organization's publishable key now runs AI chat, published maps and the editor as well as basemaps (ai, maps, design scopes; every product), spending the Free plan's AI credits. Server keys need Pro or Enterprise. (The vendor scope is Enterprise only as of 2026-10-13.) Each plan now limits active keys per organization: Free 2, Pro 10, Enterprise 25 (409 key_limit_reached; rotation does not count, and existing keys above a limit are kept).

2026-09​

  • Street addresses in address search. GET /retrieval/geocode/forward now also answers a typed street address (type: "address"). Its attribution.sources names each address dataset used, with the credit and any use restriction its license imposes; G-NAF results are not for compiling mailing addresses. A house number missing from the data is placed from the nearest numbers on its street and marked approximate: true, with method and matched_numbers. Additive: place results are unchanged.
  • Transit directions. POST /chat/control/route accepts profile: "transit" and answers a one-seat journey under action.payload.transit, or { "error": "…" } when no direct ride serves the trip. Additive: the request body is unchanged, and every other profile routes as before. New GET /retrieval/geocode/forward (ai scope, charged) serves a From/To search box. The chat panel's Directions view gained typeable From/To fields and a Transit mode.
  • What a key can do follows the current plan. The session exchange and every runtime call check the key against your organization's plan at that moment, so a plan change takes effect without editing or rotating keys. Two codes tell the cases apart: tier_capability_not_allowed (the key has it; the plan no longer includes it) and insufficient_scope (the key never had it).
  • Plan changes reach issued sessions. A downgrade ends sessions issued before it, within minutes, instead of at their expiry. An upgrade applies from the next session exchange.
  • Free-plan product edits are checked. Editing a Free-plan key's allowed_products to an empty list, or to a product outside the plan, returns 403 tier_capability_not_allowed.
  • Stream event grounding removed. Clients that listened for it no longer receive it.

2026-08​

  • Basemap access needs a key. Direct third-party use of tile.kaleidr.com is restricted; <kaleidr-map> embeds and Kaleidr-hosted maps are unaffected. Tile sessions count against the organization's map loads (quota).
  • Session exchange and refresh. Publishable keys are exchanged for short-lived, origin-bound sessions (kld_sess_…, 15 minutes); the SDK refreshes them.
  • Chat can drive a Kaleidr map element. A chat mount can point map-target at a Viewer or Tile element on the same page.
  • Organization default basemap. POST /sdk/sessions returns your organization's default basemap as basemap_style_id, and an embed that names no style uses it.
  • Server keys are refused in the browser. The SDK rejects kld_sk_… at mount.
  • Separate base options. viewerBase and tileBase were split from the loader's base option.
  • Route colors. The route stream event carries color, label, alternatives and comparison.

v1​

  • kaleidr.js loader and the <kaleidr-map> element: one loader, four products (chat, viewer, editor, tile).
  • Publishable browser keys (kld_pk_) and server keys (kld_sk_) with scopes ai, maps, design and vendor; publishable keys are exchanged for short-lived, origin-bound sessions. Legacy kld_live_ keys keep working.
  • /inference-api/b2b/v1/chat/* (streaming) and /design/* endpoint families.