Link
✎

Make Integration

In short: a Make scenario can start from a NetLicensing notification (the Custom webhook module) and can call the NetLicensing REST API (the HTTP module). You get both directions without code and without a dedicated NetLicensing app.

Make is a visual automation platform: you build a scenario from modules. NetLicensing does not provide a Make app, so the generic Webhooks and HTTP apps do the work.

React to NetLicensing events: Custom webhook

The Custom webhook module (in Make’s Webhooks app) creates a URL that any service can call. It starts the scenario each time a request arrives.

  1. In the scenario builder add Webhooks > Custom webhook, click Add next to Webhook, and give the webhook a name. Make generates the URL. Each scenario uses its own webhook; one webhook cannot serve several scenarios.
  2. In the Management Console, open Settings / Notifications and create a notification of type WEBHOOK. Paste the Make URL as the endpoint and select the events you need. NetLicensing requires an HTTPS endpoint with a public certificate.
  3. Run the scenario once so that it waits for data, then let NetLicensing (or a test request, see the example below) send one notification. Make reads the payload and offers its fields in the next modules. The event name is in the payload at entities.Event[0].name: LICENSEE_CREATED, LICENSE_CREATED, PAYMENT_TRANSACTION_PROCESSED or WARNING_LEVEL_CHANGED. See Notifications for each payload.

Notes on the Custom webhook module:

  • Data structure. Make recommends defining the structure of the incoming data. Without one, Make accepts everything without validation. If you let Make learn the structure from a test call, Make does not validate later requests either. To get the original JSON, enable the JSON pass-through option in the webhook settings.
  • Size. The maximum payload is 5 MB, far above a notification.
  • Protect the URL. Make can require an API key in the x-make-apikey header (ASCII, up to 512 characters). The notification settings in NetLicensing have no field for custom headers (a notification has a name, number, events, type, endpoint and payload), so you cannot use that option here. Keep the generated URL secret, and check the event data in the scenario before you act on it.
  • Answer. Without a Webhook response module, Make answers 200 with the body Accepted as soon as it queues the request. If the queue is full it answers 400 (Queue is full), and if you exceed the rate limit it answers 429. Make accepts up to 300 webhook requests per 10 seconds.
  • Inactive webhooks. Make deactivates a webhook that is not connected to any scenario for more than 5 days (120 hours); it then answers 410 Gone. If your notification stops arriving after a pause, check the scenario first.
  • Order and parallelism. By default Make processes instant webhooks in parallel. Turn on Process data in order in the scenario settings if the order of events matters.
  • Queue and logs. Each webhook has its own queue, with up to 667 items for every 10,000 credits of your monthly allowance and at most 10,000 items. Make keeps webhook logs for 3 days (30 days on the Enterprise plan).

NetLicensing does not guarantee the delivery of a notification, so build the scenario to handle a missed or repeated event; see Notifications.

Act in NetLicensing: HTTP module

The HTTP > Make a request module (HTTP version 4) calls any endpoint of the REST API.

Create a license:

Setting Value
Authentication type Basic Auth, with a keychain that holds the user name apiKey and your API key as the password
URL https://go.netlicensing.io/core/v2/rest/license
Method POST
Headers Accept: application/json
Body content type application/x-www-form-urlencoded
Body content licenseeNumber, licenseTemplateNumber (and number, see below)
Parse response Yes

Make recommends keeping credentials in the Credentials field rather than in headers or query parameters, which is why the API key goes into a Basic Auth keychain. The API expects form-encoded bodies, which is why the content type above is the right choice.

The same module creates a customer (POST /licensee with productNumber) and deactivates a license (POST /license/{licenseNumber} with active=false, see License Services).

A repeated call is an error response. Creating a license or customer with a number that already exists returns HTTP 400 with DuplicateEntityException (see IDs as numbers). The module option Return error if HTTP request fails stops the scenario on a 4xx or 5xx answer. Leave it off for these calls if a duplicate should count as “already done”, and handle the status in the next module. The module also has a Timeout option (1 to 300 seconds).

Example: tell your team when a warning level changes

  1. Custom webhook, with a NetLicensing notification on WARNING_LEVEL_CHANGED.
  2. Any Make module that sends a message or an email, using the customer name and number from the payload.

Example: create a license when a payment succeeds elsewhere

  1. A trigger module of the payment platform (an instant trigger or a Custom webhook).
  2. HTTP > Make a request: create the licensee.
  3. HTTP > Make a request: create the license for that licensee.

Platforms differ in how they sign their webhooks. Check the platform’s method in the billing platform guides before you rely on an unsigned receiver.

Example: the calls

NetLicensing posts a notification to the Make custom webhook; Make answers 200 Accepted, runs the scenario modules, and the HTTP module calls the NetLicensing API.

Text version of this diagram (click to expand)
  1. NetLicensing → Automation tool: notification (POST) (trigger: webhook)
  2. Automation tool: steps: filter, map
  3. Automation tool → Other apps / NetLicensing: action: HTTP request (e.g. POST /license)

1. Test the Custom webhook

curl --request POST "https://hook.make.com/<32 characters>" \
  --header "Content-Type: application/json" \
  --data '{
    "timestamp": "2024-09-19T04:30:26.006Z",
    "origin": "Notification",
    "entities": {
      "Event": [ { "name": "LICENSE_CREATED" } ],
      "License": [ { "number": "LN2TD47QY", "active": true, "licensee": "IKWUYQ9GR", "licenseTemplate": "E27NV3IQD" } ]
    }
  }'

Use the URL that the Custom webhook module shows. Make answers 200 with Accepted.

2. The call behind the HTTP module

The module settings above send this request; licenseeNumber comes from the license in the event (licensee in the payload) or from your own data:

curl --user "apiKey:$NETLICENSING_API_KEY" --header "Accept: application/json" \
  --data "number=pay-98765&licenseeNumber=IKWUYQ9GR&licenseTemplateNumber=EUJK1BXQ52" \
  https://go.netlicensing.io/core/v2/rest/license

Send the same call twice and the second answer is HTTP 400 with DuplicateEntityException. That makes the call safe to repeat; treat the duplicate as “already done”.

Sources


You run this integration yourself; NetLicensing does not host a Make app. The Make details on this page are based on the sources above, and the NetLicensing calls it relies on were tested against the live API. Make changes its product, so verify the details against the linked pages before you go live. Back to Automation and Alerts.