Skip to content
HookDeploy

Accelo webhooks

Last verified against Accelo's documentation on September 27, 2026.

On this page ↓

Accelo sends webhooks when something changes in a deployment: a task is assigned, a request comes in, an invoice is created, a sale is updated. Accelo’s webhooks are thin. They tell you which object changed and where to fetch it, not what changed. Its documentation is short, and it leaves out things you need to know, including which hash algorithm the signature uses and whether failed deliveries are retried. This page covers what Accelo sends, how it delivers, how to fix the common problems, and where HookDeploy fits.

What Accelo sends webhooks for

Each subscription listens for one event_id:

AreaEvents
Taskscreate_task, assign_task, unassign_task
Requestscreate_request, update_request_status
Issuescreate_issue, update_issue
Salescreate_sale, update_sale, create_quote
Invoices and purchasescreate_invoice, update_invoice, delete_invoice, create_invoice_pdf, create_purchase_pdf
Companies and contactscreate_company, update_company, create_contact, update_contact
Activitiesdelete_activity (beta)

For status changes on companies, contacts, prospects, jobs, issues, and contracts, Accelo offers progression webhooks. Accelo’s docs say these can only be created from the web application’s administration pages.

Every payload has the same two fields:

FieldMeaning
idThe ID of the object that changed
resource_urlThe full API URL of that object

Your handler requests resource_url with an OAuth access token to get the record’s current state.

How Accelo delivers webhooks

BehaviorDetail
Payloadid and resource_url only
Content typeapplication/json or application/x-www-form-urlencoded, chosen per subscription
Event headerX-Accelo-Event, the event_id that fired
Signature headerX-Hub-Signature, an HMAC hex digest of the payload using the subscription’s secret. Only present if you set a secret
Hash algorithmNot documented
Timestamp in signatureNone described
Timeout10 seconds
Too many timeoutsAccelo deletes the subscription automatically
410 Gone responseAccelo deletes the subscription immediately
RetriesNot documented
OwnershipSubscriptions belong to the user who created them. The list endpoint returns only your own
LimitsNo limit on the number of webhook subscriptions
API rate limit5,000 requests per hour per deployment, which covers your resource_url fetches

Common Accelo webhook errors and how to fix them

Subscription disappeared

Two things delete an Accelo subscription without warning. Accelo removes it after too many deliveries exceed the 10-second timeout, and removes it immediately if your endpoint returns 410 Gone. Check whether your handler fetches resource_url or does other slow work before responding, and whether anything in your stack returns 410 for routes it doesn’t recognize. Then recreate the subscription.

Signature verification fails

  • No secret set. Accelo only sends X-Hub-Signature if the subscription was created with a secret.
  • Wrong algorithm. Accelo’s docs don’t name the hash. Check the digest length on a real delivery: 40 hex characters is SHA-1, and 64 is SHA-256. Configure your handler for that algorithm, rather than choosing it from each request’s header.
  • The body changed. The HMAC covers the payload as sent. With the form-encoded content type, verify the raw body, not the decoded fields.
  • Wrong secret. Each subscription has its own secret.

The payload doesn’t say what changed

That’s by design. Request resource_url with an OAuth access token to get the object. For update events, compare the fetched record against what you stored to see what changed.

429 errors when fetching records

Every webhook means an API call, and Accelo allows 5,000 requests per hour per deployment. A burst of updates, such as a bulk import, can use that up quickly. Queue fetches, back off on 429, and fetch each object once when several events for it arrive close together.

Status changes don’t send webhooks

The standard event list covers creates, some updates, and a few deletes. For status changes on jobs, contracts, prospects, and similar objects, set up a progression webhook in the web application’s administration pages.

Can’t find a colleague’s subscription

Subscriptions belong to the user who created them, and the list endpoint only returns the current user’s. List them while authenticated as the user who created them.

Why use HookDeploy with Accelo

Keep subscriptions from being deleted

Accelo deletes subscriptions that time out too often, and the most natural handler, one that fetches resource_url before responding, is exactly the kind that times out. HookDeploy captures each delivery at Cloudflare’s edge and responds to Accelo right away, before forwarding it to your server, so a slow fetch or an outage on your side can’t cost you the subscription.

A safety net Accelo doesn’t document

Accelo’s docs don’t describe retries, so a delivery your server misses may simply be gone. HookDeploy captures every delivery first. From there:

  • Destination retries. Starter retries 3 times (after 30 seconds, 5 minutes, and 30 minutes). Pro and Scale retry up to 5 times on a schedule you choose. Free doesn’t retry automatically.
  • Incidents. Forward failures are grouped into incidents, and you can bulk-replay them once your server recovers.
  • History. HookDeploy keeps captured deliveries for your plan’s retention period, from 7 days on Free to 365 days on Enterprise, and any of them can be replayed.

Signatures arrive intact

HookDeploy forwards Accelo’s original body and X-Hub-Signature header unchanged. That header is on HookDeploy’s protected list: it’s never redacted from stored requests, and custom header strip rules can’t remove it. You can also check the digest length in HookDeploy’s request inspector to confirm which algorithm your subscription uses.

One event, many systems

Accelo data usually feeds several places: accounting, a data warehouse, a team channel. Forward each delivery to all of them in parallel. A failing destination doesn’t hold up the others. Free includes 1 destination per endpoint, Starter includes 5, and Pro and above are unlimited.

Sync to internal systems

The HookDeploy Agent connects outward from your network over mTLS and delivers webhooks to a local port, so an internal reporting database or sync service can follow Accelo without a public endpoint. It still needs outbound access to Accelo’s API to fetch records.

Know the limits

  • Don’t return 410. Accelo treats 410 Gone as a request to delete the subscription. HookDeploy never sends one by default, so don’t configure a custom response with that status.
  • Plan limits. On Free, requests beyond the monthly allowance or the daily limit get a 429. That’s a failed delivery, and Accelo doesn’t document retrying it. Paid plans keep accepting traffic past the included volume.

Retries, replays, and duplicates

Because Accelo’s payload is just a pointer, a retried or replayed delivery never carries stale data. Your handler fetches resource_url and gets the object as it is now. That makes replays safe, and it means you’re working from current data even when a delivery arrives late.

Duplicates are still possible, from a HookDeploy retry or replay, or from several events on the same object. Make processing idempotent: key your work on the object id, and compare the fetched record with what you’ve stored before acting.

Accelo’s docs don’t describe a timestamp in the signature, so replays verify like the original delivery.

Set up Accelo with HookDeploy

  1. In HookDeploy, create an endpoint (for example, Accelo production) and copy its URL.
  2. Create the subscription through Accelo’s API, with a JSON content type and a secret. You can also add webhooks from your deployment’s webhooks control panel.
curl -X POST "https://YOUR_DEPLOYMENT.api.accelo.com/api/v0/webhooks/subscriptions" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  --data-urlencode "trigger_url=https://hookdeploy.dev/h/YOUR_SLUG" \
  --data-urlencode "event_id=create_request" \
  --data-urlencode "content_type=application/json" \
  --data-urlencode "secret=YOUR_WEBHOOK_SECRET"
  1. In HookDeploy, add a forward destination pointing to your handler, or to an agent for private delivery, and set its retries.
  2. Test with Accelo’s dispatch endpoint, POST /api/v0/webhooks/subscriptions/{subscription_id}/dispatch with an object_id. It delivers synchronously and returns HookDeploy’s response status.
  3. Open the delivery in HookDeploy, note the length of the X-Hub-Signature digest, and set your handler’s algorithm to match.

Example handler (Node.js and Express)

import crypto from 'node:crypto';
import express from 'express';

const app = express();

// Set once from a real delivery: 'sha1' for a 40-character digest, 'sha256' for 64.
const ALGORITHM = process.env.ACCELO_HMAC_ALGORITHM;

// Raw body parser on this route, registered before any global body parsing.
app.post('/webhooks/accelo', express.raw({ type: '*/*' }), async (req, res) => {
  const signature = req.get('x-hub-signature') ?? '';
  const expected = crypto
    .createHmac(ALGORITHM, process.env.ACCELO_WEBHOOK_SECRET)
    .update(req.body)   // raw bytes, untouched
    .digest('hex');

  const valid =
    signature.length === expected.length &&
    crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
  if (!valid) return res.status(401).send('Invalid signature');  // never 410

  res.sendStatus(200);  // respond well inside Accelo's 10 seconds
  const { id, resource_url } = JSON.parse(req.body.toString('utf8'));
  await enqueue({ event: req.get('x-accelo-event'), id, resourceUrl: resource_url });
});

// In your worker: fetch the current record, respecting the 5,000 requests per hour limit.
async function processEvent({ event, id, resourceUrl }) {
  const res = await fetch(resourceUrl, {
    headers: { Authorization: `Bearer ${await getAcceloToken()}` },
  });
  if (res.status === 429) throw new RetryLater();
  const record = await res.json();
  await applyChange(event, id, record);  // idempotent on id
}

FAQ

Why does the Accelo webhook only contain an ID and a URL?

Accelo sends notification webhooks. The payload identifies the object that changed, and your handler requests the resource_url with an OAuth access token to get the full record. Those requests count toward Accelo's API rate limit of 5,000 requests per hour per deployment.

Why was my Accelo webhook subscription deleted?

Accelo enforces a 10-second timeout and deletes a subscription automatically after too many timeouts. It also deletes a subscription instantly if your endpoint responds with 410 Gone. HookDeploy responds to Accelo right away, so a slow handler no longer puts the subscription at risk.

Which hash algorithm does Accelo's X-Hub-Signature use?

Accelo's documentation describes the header as an HMAC hex digest of the payload but doesn't name the algorithm. Check the digest length on a real delivery. 40 hex characters means SHA-1, and 64 means SHA-256. Then configure your handler for that one algorithm.

Does Accelo retry failed webhooks?

Accelo's documentation doesn't describe any retry behavior, so plan as if a failed delivery is lost. HookDeploy captures every delivery before forwarding it, retries forwarding to your server, and lets you replay anything that still failed.

Can I get webhooks when a status changes?

Yes, through progression webhooks, which cover status changes on companies, contacts, prospects, jobs, issues, and contracts. Accelo's docs say these can only be created from the web application's administration pages, not through the API.

How do I test an Accelo webhook?

Call the dispatch endpoint for your subscription with an object_id. Accelo delivers the webhook synchronously and returns the HTTP status your endpoint responded with. When the subscription points at HookDeploy, that status is HookDeploy's response, and the delivery appears in HookDeploy right away.

Capture Accelo webhooks free

Start free