Back to Blog
Integration

Qlik Is Moving Its Webhooks API. Your Deliveries Won't Notice. Your Setup Scripts Will.

On November 3, 2026, Qlik deprecated its /api/v1/webhooks management API in favor of /api/core/webhooks. Deliveries keep flowing, but the code that creates, rotates and audits your webhook subscriptions is the part that breaks.

WebhookVault Team · Webhook Infrastructure Experts10 min read
Laptop screen at an angle showing a dark terminal window with npm error output and a start script log, layered over a code editor, with app icons in the dock on the right

The deliveries are fine. The code that creates them is not

Here's a failure that never shows up as a webhook failure. A new customer signs up. Your onboarding job creates their workspace, provisions their database row and calls the provider to register a webhook. The registration call gets a 404. The job logs a warning and carries on, because webhook setup was always the boring step that worked.

Every dashboard stays green. Deliveries to your existing customers keep arriving. The new customer just never gets an event, and it looks like they haven't done anything yet. Weeks later someone finally asks why their account looks idle.

That's what a management API deprecation does to you. The deliveries you monitor keep working. What breaks is the code that sets them up, and that code runs maybe once a week, usually while nobody is looking at it.

What Qlik announced on November 3

Qlik published a changelog entry on 3 November 2026 that deprecates its Webhooks API under /api/v1/webhooks, all ten published operations of it. The replacement is the Core webhooks API under /api/core/webhooks. The old paths will be removed on or after November 1, 2027.

As migrations go, this one is gentle. Qlik says both paths operate on the same webhook resources. Existing webhooks keep their IDs and their delivery history, and you don't need to recreate anything. The migration steps are short: replace /api/v1/webhooks with /api/core/webhooks, leave the rest of the path, the query parameters and the request bodies alone, test outside production, deploy, and remove the remaining old calls.

The entry describes path changes and nothing else. It doesn't mention payload format, headers, signing or retry behavior. What lands on your endpoint is out of scope. The change is in how you talk to the provider about your endpoint.

That's exactly why it's easy to miss.

Why receivers miss this kind of deprecation

When you run a webhook receiver, your attention goes to the data plane: requests coming in, signatures, status codes, latency, retries. Most webhook tooling watches that plane too, ours included.

The control plane is the set of calls you make to the provider to create, update, list and delete subscriptions. Almost nobody watches it with the same care.

Part of that is frequency. A delivery handler runs thousands of times a day. A registration call runs once per tenant, once per environment, or once per secret rotation. A path that's called twelve times a month won't show up on any error-rate graph.

It's also spread out. Delivery handling usually sits in one service. Registration code ends up wherever someone needed it: an onboarding worker, a migration script, a Terraform module, a README snippet that got pasted into a runbook.

And the email goes to the wrong people. Deprecation notices go to whoever subscribed to the changelog. The code they affect was usually written by someone who has since moved teams.

Where webhook management calls hide

Before you can migrate, you need an inventory. In most codebases I've seen, management calls live in at least four of these places:

  1. Tenant onboarding, the job that registers a webhook when a customer connects their account. It fails silently and the cost lands on a new customer, so check it first.
  2. Infrastructure as code. Terraform providers and Pulumi components that manage subscriptions pin API paths internally, so the fix there is a provider upgrade. Your own code may not change at all.
  3. Secret rotation jobs that update a subscription's secret on a schedule. They run quarterly or less, which is the worst possible frequency for catching a dead path.
  4. Drift and health checks that list subscriptions and compare them to what you expect. If one of them reads a 404 as "no subscriptions", it can start re-creating webhooks that already exist.
  5. Disaster recovery runbooks. The script you'd run to point every subscription at a standby region was tested once, in 2024.
  6. Internal CLIs and admin panels, like the "re-register webhook" button support uses when a customer complains.
  7. Integration tests that hit the real API. Useful, as long as they call the path production uses.

Number 4 is the dangerous one. A read that quietly returns nothing turns a dead path into duplicate subscriptions, and duplicate subscriptions turn into duplicate deliveries.

Finding them before the removal date does

Start with text search, because it's cheap and it catches most of it. Look for the old path in every repository that talks to the provider, including infrastructure repos and the docs folder.

# Every repo that might register, rotate or audit webhooks
for repo in ~/src/*/; do
  grep -rn --include='*.ts' --include='*.js' --include='*.py' \
    --include='*.go' --include='*.tf' --include='*.sh' --include='*.md' --include='*.y*ml' \
    -e '/api/v1/webhooks' "$repo" 2>/dev/null
done

# Paths are often built from parts, so search the fragments too
grep -rn -e "'v1'" -e '"webhooks"' --include='*.ts' ~/src/integrations/

Text search misses anything assembled at runtime and anything inside a third-party package. So check the other side too. If your egress goes through a proxy or an HTTP client with request logging, filter outbound calls to the provider's host by path over the last 90 days. A 90-day window catches the quarterly jobs. A 7-day window won't.

Then check your dependencies. If a Terraform provider or SDK manages subscriptions for you, find out which path the version you've pinned calls, and which release moves to the new one. That answer is in their changelog. Your own code won't tell you.

Make the base path one constant

After the search you'll probably find the path written out in several places. Fix that before you change it, otherwise you'll be running the same grep again the next time the path moves.

// webhooks/provider-client.ts
const WEBHOOKS_BASE = '/api/core/webhooks'

export class WebhookAdminClient {
  constructor(private tenantUrl: string, private token: string) {}

  private async call(method: string, path = '', body?: unknown) {
    const res = await fetch(`${this.tenantUrl}${WEBHOOKS_BASE}${path}`, {
      method,
      headers: {
        Authorization: `Bearer ${this.token}`,
        'Content-Type': 'application/json',
      },
      body: body ? JSON.stringify(body) : undefined,
    })
    recordDeprecationSignals(res, `${method} ${WEBHOOKS_BASE}${path}`)
    if (!res.ok) {
      // Never let a 404 here look like "nothing found"
      throw new Error(`Webhook admin call failed: ${method} ${path} ${res.status}`)
    }
    return res.status === 204 ? null : res.json()
  }

  list() { return this.call('GET') }
  create(body: unknown) { return this.call('POST', '', body) }
  remove(id: string) { return this.call('DELETE', `/${id}`) }
}

Every onboarding job, rotation script and admin button goes through this client. Then a path change means editing one line, and the thrown error means a dead path fails loudly in whichever job hits it first.

Run the rare code paths on purpose

The code that registers webhooks is rare by design, so you can't wait for production to exercise it. Schedule it.

A nightly job in a staging tenant does the job: create a subscription, list it, update its URL, rotate its secret, delete it. Five calls, a few seconds, and it runs against the same client and the same base path as production. When the provider removes a path, this job fails the next night. Without it, you'd hear about it the next time a customer onboards.

Use a real provider account. A mock tests your code against your own idea of the API, and that idea is exactly what goes stale during a deprecation.

If staging and production point at different paths, that's the bug the job is there to catch. Read the base path from the same config in both.

Listen for deprecation signals in responses

Some providers announce deprecations in the HTTP response as well as in a changelog. RFC 9745 defines a Deprecation response header whose value is a structured-field date, for example @1798761600. RFC 8594 defines Sunset, an HTTP date after which the resource is expected to stop responding. Some APIs also send a Link header with rel="deprecation" that points at migration docs.

Not every provider sends them, and Qlik's changelog doesn't say whether its old paths do. Log them anyway. It costs nothing, and when a provider does send them, your logs tell you about the deprecation before any human reads the changelog.

function recordDeprecationSignals(res: Response, endpoint: string) {
  const deprecation = res.headers.get('deprecation')
  const sunset = res.headers.get('sunset')
  if (!deprecation && !sunset) return

  logger.warn({
    msg: 'provider_api_deprecation',
    endpoint,
    deprecation,
    sunset,
    link: res.headers.get('link'),
  })
  metrics.increment('provider_api.deprecated_call', { endpoint })
}

Alert once per endpoint. One ticket per deprecated endpoint is something a team can act on. A warning on every call just gets muted.

Treat a missing subscription as an incident

Onboarding fails quietly because nothing downstream expects an event that never arrives. Fix that by making the expected state explicit.

Keep a table of the subscriptions you think exist: tenant, provider, subscription ID, endpoint URL, event types. Once a day, list what the provider actually has and compare. A subscription you expect but the provider doesn't have is an alert. One the provider has and you don't is also an alert, because that's how duplicate deliveries start.

This catches more than path deprecations. It catches subscriptions the provider disabled after sustained failures, which we covered in the post on senders giving up on your endpoint, and subscriptions someone deleted by hand in a dashboard. It also gives you a number to watch: tenants with zero working subscriptions. That number should be zero, and when it isn't, a customer is about to email you.

The comparison has to throw when the list call errors. A drift check that treats a failed list as an empty list will report every subscription missing, or worse, re-create all of them.

A same-resource migration is the easy kind

Be glad this one keeps IDs. Plenty of management API migrations don't.

When a provider moves subscriptions to a new resource model, IDs can change, secrets can be reissued, and for a while the same event might be delivered by both the old and the new subscription. Then you're dealing with what we described in the post on moving your webhook endpoint: retries already in flight against the old setup, and a window where duplicates are guaranteed. If secrets change as well, you're also doing a signature cutover, on the provider's schedule instead of yours.

Qlik's version avoids all of that. The resources and their IDs stay put, and so does the delivery history. Every stored subscription ID in your database stays valid, and the drift table above doesn't need a migration. The only work is finding the callers. Just don't assume the next provider's migration will be this kind.

Don't plan for October 2027

Read the removal date carefully. "On or after November 1, 2027" means the old path is guaranteed to work until then and can disappear any day after. You'll find out from whichever rare job hits it first.

So do the inventory this month, while the people who read the changelog still remember reading it. The grep takes an hour. The egress query takes another. Teams that skip it tend to rediscover the problem in November 2027, from a support ticket about a customer who connected their account and never saw any data.

Frequently asked questions

Does the Qlik change affect the webhook payloads my endpoint receives? The November 3, 2026 changelog entry only describes path changes for the management API, from /api/v1/webhooks to /api/core/webhooks. It says nothing about payload format, headers or signing, so the deliveries themselves aren't the subject of this deprecation.

Do I need to recreate my existing Qlik webhooks under the new API? No. Qlik states that both paths use the same webhook resources and that existing webhooks keep their IDs and delivery history. Update the paths your code calls, test outside production, and remove the old calls before the removal date.

What if a Terraform provider or SDK manages my subscriptions? Then the old path lives in their code and your grep won't find it. Check which path your pinned version calls, follow their changelog for the release that switches over, and upgrade well before November 2027.

How often should a drift check compare expected and actual subscriptions? Daily is enough for most teams, because subscriptions change far less often than deliveries. What matters more is that a failed list call raises an error. If it returns an empty result, an outage looks like every subscription vanished.

Should I alert on Deprecation and Sunset headers from every provider? Yes, but deduplicate by endpoint so each deprecated call path creates one ticket. Plenty of providers don't send these headers, so treat them as an early warning and keep reading the changelogs too.

Related posts