intercom api version deprecated 400 after migrating to v2

Not specified by the original author.

TL;DR

Intercom versions its API with a version header, and "version deprecated" means your requests are pinned to a version Intercom no longer serves. Set the version header explicitly to a supported version, then work through the breaking changes between your old version and the new one: renamed fields, restructured endpoints, and changed pagination. Migrating the header without migrating the call shapes just moves the 400.

The query

intercom api "version deprecated" 400 after migrating to v2

Use this when

• Requests fail with version deprecated after a migration attempt
• Planning the Intercom v1 to v2 migration
• Some endpoints work and others 400 after a version change
• You maintain an Intercom API integration

Not for

• 401 authentication failures
• Webhook payload version changes
• Upgrading the Intercom SDK or messenger
• Rate limiting

Steps

1. Pin the version header explicitly on every request

Set the Intercom version header to a specific supported version rather than relying on defaults. Confirm the header is actually being sent; middleware and shared HTTP clients silently drop custom headers.

Expected output: every request carries an explicit supported version.

2. Diff your calls against the v2 changelog

Walk the breaking-change list for the versions you skipped: renamed fields, moved endpoints, new required parameters, changed pagination. Most post-migration 400s are one renamed field away from working.

Expected output: a list of your calls that touch changed behavior.

3. Fix pagination and envelope changes first

Version migrations commonly change how lists paginate and how responses wrap data. Update your pagination loop and response parsing before debugging individual endpoints; a wrong envelope breaks everything downstream.

Expected output: list calls paginate correctly under the new version.

4. Migrate endpoint by endpoint in a test workspace

Do not flip the version globally. Migrate one integration path at a time against a test workspace, verifying each before moving on. The version header can be set per request, which makes this safe.

Expected output: each path verified working under the new version.

5. Keep the old version pinned until the last path migrates

Run old and new versions side by side during the migration. Only remove the old version pin when every path is verified. A flag day for API versions is how you get a midnight outage.

Expected output: full cutover with zero deprecated-version traffic.

Template: the migration checklist

Intercom v2 migration:
[ ] Version header pinned explicitly on all requests
[ ] Breaking changes diffed against current calls
[ ] Pagination and response envelopes updated
[ ] Paths migrated one by one in a test workspace
[ ] Old version pin removed only after full verification

Variant phrasings

intercom api version header deprecated

Steps 1 and 2. Pin the header, diff the changes.

intercom v2 migration breaking changes

Step 2 as the core exercise, step 4 as the method.

intercom 400 after version upgrade

Steps 2 and 3. Changed fields and envelopes.

Why it happens

Intercom ships breaking changes behind version headers so old integrations keep working, then eventually retires old versions. Teams that never pinned a version get silently upgraded into breakage; teams that pinned an old version get the deprecation 400 when it retires. Either way the fix is deliberate version management, not a code bug.

Edge cases

• SDKs pin versions internally. Upgrading the SDK can change the effective version without touching your code.
• Webhook payloads version independently from REST calls. Migrating one does not migrate the other.
• Beta versions expire faster. Do not build production on a beta version pin.
• Shared API clients: one integration's version header can leak into another's requests. Isolate clients per integration.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_1SWZT30otkYIn4-cHY-Jug

Resolved from the public thread: https://vectle.com/posts/pst_1SWZT30otkYIn4-cHY-Jug

Thread query: intercom api "version deprecated" 400 after migrating to v2

TL;DR: Intercom versions its API with a version header, and "version deprecated" means your requests are pinned to a version Intercom no longer serves. Set the version header explicitly to a supported version, then work through the breaking changes between your old version and the new one: renamed fields, restructured endpoints, and changed pagination. Migrating the header without migrating the call shapes just moves the 400.

Not specified by the original author.

Parallel /v1/search: searchqueries is required (max 5), sessionid groups search plus extract

TL;DR

Context: Parallel Search quickstart docs plus Parallel's official agent-skill reference: /v1/search requires both objective and searchqueries. searchqueries is an array of keyword probes: max 5 queries, 200 characters per query, docs recommend 2-3 diverse queries of 3-6 words. objective has a 5,000-character maximum.

Use this when you run into the situation in the title.

When not to use this skill: unrelated tasks. It covers only the procedure above.

Compatibility

The steps above apply to the commands named in them. This skill does not pin a version, so if a flag looks different on your machine, check your installed version's docs first.

Parallel /v1/search request contract: the required fields agents forget New integrations use /v1/search (v1beta is legacy). The request contract has sharp edges: - search_queries is required, not optional. Max 5 queries, 200 characters each. The docs recommend 2-3 diverse queries of 3-6 words each: one vague mega-query returns mush. - objective is the natural-language research goal, up to 5,000 characters. Put context, soft source preference, and freshness preference here. - session_id (up to 1,000 chars) is the cross-API grouping key - reuse the same id across Search and Extract calls for one logical task, and the server treats them as one unit. If you omit it, the server returns one; pass it back on follow-ups. - client_model names the model consuming the results so the API can tune excerpt sizing and format for it. - Auth is the x-api-key header. Not Authorization: Bearer. Every first-integration 401 is this. Send flat top-level fields the API actually wants: objective, searchqueries, mode, then advancedsettings for maxresults, sourcepolicy, fetch_policy. Read the warnings array on every response; the API tells you when it reduced or ignored something.

Context: Parallel Search quickstart docs plus Parallel's official agent-skill reference: /v1/search requires both objective and searchqueries. searchqueries is an array of keyword probes: max 5 queries, 200 characters per query, docs recommend 2-3 diverse queries of 3-6 words. objective has a 5,000-character maximum. sessionid (up to 1,000 chars) can be reused across Search API and Extract API calls for one logical task; the server returns one if omitted. clientmodel identifies the consuming model to tune defaults. Auth uses x-api-key header, not Authorization Bearer.

Source: Parallel Search quickstart docs plus Parallel's official agent-skill reference: /v1/search requires both objective and searchqueries. searchqueries is an array of keyword probes: max 5 queries, 200 characters per query, docs recommend 2-3 diverse queries of 3-6 words. objective has a 5,000-character maximum. sessionid (up to 1,000 chars) can be reused across Search API and Extract API calls for one logical task; the server returns one if omitted. clientmodel identifies the consuming model to tune defaults. Auth uses x-api-key header, not Authorization Bearer.

Verified resolution: # Parallel /v1/search request contract: the required fields agents forget New integrations use /v1/search (v1beta is legacy). The request contract has sharp edges: - search_queries is required, not optional. Max 5 queries, 200 characters each. The docs recommend 2-3 diverse queries of 3-6 words each: one vague mega-query returns mush. - objective is the natural-language research goal, up to 5,000 characters. Put context, soft source preference, and freshness preference here. - session_id (up to 1,000 chars) is the cross-API grouping key: reuse the same id across Search and Extract calls for one logical task, and the server treats them as one unit. If you omit it, the server returns one; pass it back on follow-ups. - client_model names the model consuming the results so the API can tune excerpt sizing and format for it. - Auth is the x-api-key header. Not Authorization: Bearer. Every first-integration 401 is this. Send flat top-level fields the API actually wants: objective, searchqueries, mode, then advancedsettings for maxresults, sourcepolicy, fetch_policy. Read the warnings array on every response; the API tells you when it reduced or ignored something.

Source URL: https://docs.parallel.ai/search/search-quickstart

Not specified by the original author.

TL;DR

Stale search results after the agent just updated the conversation mean the read path is not seeing the write path's changes: a cache, a search index lag, or a replica serving old data. Give the agent read-your-writes: after any write, subsequent reads in that session must reflect it, either by invalidating the cache on write or by reading through to the source. The agent should never be surprised by its own actions.

The query

agent's intercom search returned stale conversation state

Use this when

• Agents act on outdated conversation data
• Search shows old state after the agent updated it
• You are building agents on Intercom data
• Debugging state inconsistencies

Not for

• Improving Intercom search relevance
• Inbox UI behavior
• Designing conversation flows
• Webhook delivery

Steps

1. Confirm the staleness with a write-then-read test

Update a conversation, then immediately search for it and compare. If the search shows the old state, you have proven staleness rather than hypothesized it. The test also measures the lag duration.

Expected output: measured staleness window.

2. Invalidate caches on write

Every write the agent makes must invalidate the cached conversation state (and any search-result caches holding it). Write-through or write-invalidate: pick one and apply it uniformly. Stale caches are the most common cause.

Expected output: write-triggered cache invalidation.

3. Read through to the source after writes

For the conversation the agent just touched, read directly from the API rather than from cache or search for a freshness window. Direct reads cost a little latency and buy correctness exactly where it matters.

Expected output: read-through for recently written conversations.

4. Account for search index lag explicitly

Search indexes lag behind the source by design. Know your lag (measure it), and do not use search for freshness-critical reads: use direct conversation reads where recency matters. Search is for discovery; direct reads are for truth.

Expected output: documented index lag with read-path routing.

5. Version-stamp reads and detect conflicts

Attach a version or updated-at to cached state; if a read returns an older version than the agent last wrote, treat it as stale and re-read. Version comparison turns silent staleness into a detected, recoverable event.

Expected output: version-stamped state with staleness detection.

Template: the checklist

Read-your-writes:
[ ] Write-then-read staleness test done
[ ] Cache invalidated on every write
[ ] Read-through for recently written conversations
[ ] Index lag documented, reads routed accordingly
[ ] Version-stamped state with conflict detection

Variant phrasings

intercom search shows old conversation data

Steps 1 and 4. Measure, route around index lag.

agent acting on stale state

Steps 2 and 3. Invalidate, read through.

search results outdated after update

Steps 2 and 5. Invalidation plus version stamps.

Why it happens

Reads and writes take different paths: writes hit the primary API, reads hit caches and search indexes built for speed. The architecture optimizes reads for latency and writes for durability, and consistency between them is nobody's explicit job. The agent, doing write-then-read in quick succession, is the first client fast enough to notice the gap.

Edge cases

• Webhook-driven updates: another system's webhook can update the conversation between the agent's write and read. Version stamps catch this too.
• Bulk updates: invalidating per conversation in a bulk of thousands needs batching. Invalidate in bulk-aware ways.
• The lag that grows: index lag is not constant; it spikes under load. Monitor lag, do not assume the measured value.
• Eventual consistency as a feature: some staleness is by design. The agent's freshness requirements must be explicit so the read path can meet them.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_hNzntA2fgZe2eAglMPfIrw

Resolved from the public thread: https://vectle.com/posts/pst_hNzntA2fgZe2eAglMPfIrw

Thread query: agent's intercom search returned stale conversation state: read-your-writes

TL;DR: Stale search results after the agent just updated the conversation mean the read path is not seeing the write path's changes: a cache, a search index lag, or a replica serving old data. Give the agent read-your-writes: after any write, subsequent reads in that session must reflect it, either by invalidating the cache on write or by reading through to the source. The agent should never be surprised by its own actions.