MasonHub ERP Integration home pagelight logo
  1. Callback Holds
  2. Delete Callback Holds
DELETE
/callback_holds
curl --request DELETE \
     --url https://sandbox.masonhub.co/dragonfly-cosmetics-demo/api/v1/callback_holds \
     --header 'Authorization: Bearer <token>' \
     --header 'Content-Type: application/json' \
     --data '{
  "message_types": "<value>"
}'

Remove callback holds to resume delivery of specific message types to your webhook endpoints. After removing holds, new events will be delivered according to your callback configuration.

Removing holds only affects future events. Events that occurred while holds were active are not retroactively delivered.

​
Request Body

The request body accepts an array of message type strings to remove from hold.

message_types
required
string[]

Array of message types to remove from hold. Common types include:

  • skuInventoryChange - Inventory level changes
  • orderEvent - Order status and lifecycle events
  • shipmentEvent - Shipment tracking updates
  • inboundReceived - Inbound shipment receipts
curl -X DELETE "https://app.masonhub.co/{account}/api/v1/callback_holds" \
  -H "Authorization: Bearer your_jwt_token" \
  -H "Content-Type: application/json" \
  -d '[
    "skuInventoryChange",
    "orderEvent"
  ]'

{
  "status": "success",
  "holds_removed": [
    "skuInventoryChange",
    "orderEvent"
  ],
  "remaining_holds": []
}

​
Response Fields

status
string

Status of the operation. Returns success when holds are removed.

holds_removed
string[]

Array of message types that were successfully removed from hold.

remaining_holds
string[]

Array of message types that still have active holds after this operation.

​
Behavior

​
Idempotent Operations

If you attempt to remove a hold that doesn’t exist, the API will return a 404 error but will still process other valid hold removals in the request.

​
Multiple Message Types

You can remove holds from multiple message types in a single request for efficiency.

​
Immediate Effect

Once holds are removed, callback delivery resumes immediately for new events. The system does not retroactively deliver events that occurred during the hold period.

​
Partial Removal Handling

If some holds cannot be removed (e.g., not found), the API will still remove other valid holds:

{
  "status": "partial_success",
  "holds_removed": ["skuInventoryChange"],
  "remaining_holds": ["orderEvent"],
  "errors": [
    {
      "message_type": "shipmentEvent",
      "error": "Hold not found"
    }
  ]
}

​
Post-Removal Verification

1

Verify Removal

Use Get Callback Holds to confirm holds are removed.

2

Monitor Callbacks

Check that your webhook endpoint starts receiving events again.

3

Check Logs

Review callback delivery logs to ensure normal operation has resumed.

4

Validate Processing

Confirm your application is processing incoming events correctly.

​
Use Cases

Resume After Maintenance

Remove holds immediately after completing system maintenance.

Staged Rollout

Remove holds gradually for different event types during rollout.

Emergency Recovery

Restore normal operations after resolving webhook processing issues.

Testing Complete

Resume production events after finishing debugging or testing.

​
Best Practices

Verify your webhook endpoints are ready to receive events before removing holds. Failed deliveries will trigger retry logic, which could overwhelm recovering systems.

Test Endpoints First

Verify your webhook endpoints are operational before removing holds.

Remove Gradually

For high-volume systems, consider removing holds one message type at a time.

Monitor Initially

Closely monitor callback delivery for a period after removing holds.

Document Changes

Keep records of when holds are removed for audit and troubleshooting.

​
Example Workflow

# Complete maintenance tasks
complete_system_maintenance()

# Verify endpoints are ready
if verify_webhook_endpoints():
    # Remove holds to resume callbacks
    hold_types = ["skuInventoryChange", "orderEvent"]
    response = requests.delete(
        f"{base_url}/callback_holds",
        headers=headers,
        json=hold_types
    )

    # Verify removal
    current_holds = requests.get(
        f"{base_url}/callback_holds",
        headers=headers
    ).json()

    if len(current_holds["holds"]) == 0:
        print("All holds removed successfully")
    else:
        print(f"Remaining holds: {current_holds['holds']}")

​
What Happens After Removal

1

Immediate Resume

Callback delivery resumes immediately for the specified message types.

2

New Events Only

Only events occurring after hold removal are delivered.

3

Normal Retry Logic

Standard retry and timeout policies apply to all subsequent deliveries.

4

No Backfill

Events missed during the hold period are not retroactively sent.

If you need to retrieve events that occurred during a hold period, consider using the relevant GET endpoints (e.g., GET /inventory, GET /orders) to fetch current state.