01 / Start here
A clear hand-off from idea to listing.
MerebHub handles the marketplace setup, checkout, and license delivery. You own the product experience. This guide explains what we need from you, what we send back, and the small integration your app should complete before final review.
-
01
Apply with the product context
Tell us what the app does, who it is for, which platforms it supports, and what stage it is in. A working demo or product link helps, but an honest in-development application is welcome.
-
02
Answer the commercial questions
After the first review, we will ask about price, billing period, license type, device limits, editions or variants, supported operating systems, and any features that should be included in each edition.
-
03
Receive your integration details
We add the matching product and policy records to our licensing database, then send you the identifiers, API base URL, policy behavior, test credentials, and any platform-specific notes your implementation needs.
-
04
Integrate the identifiers in your app
Use the product and policy identifiers we provide when your app validates a license or requests an activation. The interface is yours: a settings screen, first-run prompt, account page, or another flow that fits the product.
-
05
Upload the finished build
Send us the release-ready installers, checksums, release notes, and a short test path. We test installation, launch, licensing, updates, and the purchase-to-download journey before approving or declining the listing.
02 / Before we configure your product
Bring the decisions, not just the binary.
The more precise the commercial brief, the faster we can prepare the right records and the fewer changes your app will need later.
- Offer structure
- Product name, editions or variants, platform builds, and which features belong to each one.
- Commercial model
- Price in Br, one-time or recurring billing, trial or grace period, and whether a customer can renew or upgrade.
- Activation model
- Simple key validation, a device limit, named machines, or an offline workflow. If you are unsure, describe the customer scenario and we will recommend a policy.
- Support promise
- Supported operating systems, minimum versions, expected response time, and how customers should report a licensing problem.
Important: identifiers are environment-specific.
Use the exact values from your MerebHub integration email. Do not copy identifiers from a demo, another product, or a local test environment into a production build.
03 / Connect your app
Keep the online check small and deliberate.
The public validation endpoint is designed to be called from your software. It does not require a private administrator token. MerebHub will give you the account identifier, API base URL, product identifier, and policy identifier for your product.
https://<api-host>/v1/accounts/<account-id>/licenses/actions/validate-key
{
"meta": {
"key": "<customer-license-key>",
"scope": {
"product": "<product-id>",
"policy": "<policy-id>",
"fingerprint": "<optional-device-fingerprint>"
}
}
}
Treat the response as a decision. Continue only when the response says the license is valid. Keep the machine-readable result code for your support logs, and show a calm, useful message when a key is expired, suspended, out of seats, or tied to a different product.
Scope the check. Always include the product identifier. Include the policy identifier when we provide one, and include a fingerprint when the policy is tied to a device. This prevents a valid key for another product from being accepted by your app.
Plan for network failure. A timeout is not the same as an invalid license. Offer retry, keep the last successful state only for the grace period we agree on, and never ship a private admin, environment, or product token inside the client.
04 / Choose an activation experience
Make the licensing moment feel native to your product.
There is no required visual pattern. We care that the flow is understandable, reversible, and tested. These are the implementation paths we support.
Key-only validation
Best for a simple product that only needs to know whether a purchased key is active. Ask for the key, validate it against your product, and store it using the platform’s secure credential storage.
Device activation
Use this when a plan has a machine limit. Generate a stable, privacy-conscious fingerprint, validate it first, then create a machine activation with the license. Do not use a raw MAC address if a hashed or app-generated identifier is more stable for your platform.
Server-side validation
For SaaS products, keep the license check on your server and pass only an entitlement state to the browser or client. Store all private credentials server-side and rotate them if they are ever exposed.
https://<api-host>/v1/accounts/<account-id>/machines
Authorization: License <customer-license-key>
{
"data": {
"type": "machines",
"attributes": {
"fingerprint": "<stable-hashed-fingerprint>",
"name": "<human-readable-device-name>",
"platform": "<platform>"
},
"relationships": {
"license": {
"data": { "type": "licenses", "id": "<license-id-from-validation>" }
}
}
}
}
Your policy may use a different authentication strategy. We will confirm the supported activation request in your integration hand-off.
05 / Offline activation
For customers who cannot keep the app online.
Offline licensing uses a signed license file instead of a live validation request. The file can carry a tamper-evident snapshot of the license or activated machine, an expiry, and the product relationships your app needs to make a local decision.
-
01
Create a request on the disconnected device
Your app collects the entered license key, your product and policy identifiers, a stable device fingerprint, and a fresh nonce. Use the request-file helper we provide; do not invent your own file format or include unrelated personal data. Save the result as a
.lreqfile. -
02
Let the customer transfer the request
The customer signs in to MerebHub on an internet-connected device and uploads the request from Purchased Licenses. We check that the request contains a license they own before asking the licensing service to create the response.
-
03
Install the returned license file
MerebHub returns a signed
.licfile. The customer transfers it back to the disconnected device. Your app should import it through a clear “Activate offline” action, not ask the customer to edit or rename its contents. -
04
Verify locally before enabling the product
Verify the file’s signature with the public verification material supplied in your integration pack. Then check the product ID, policy ID, device fingerprint, status, entitlements, and expiry. Reject altered, expired, mismatched, or unreadable files with a next-step message.
-
05
Respect the file lifetime
Offline files can expire so changes such as suspension, renewal, or a device-limit update can eventually reach an installation. Show the customer when a refresh is needed and provide the request-file action again instead of silently locking them out.
Offline does not mean unsigned.
Your application must verify the signature locally. Never accept a file because it merely has a .lic extension, and never put a private signing or administrator secret in the app.
06 / Submit for review
Give us a build we can actually test.
When your integration is complete, send a release candidate rather than a screenshot. We test the same customer journey a buyer will experience.
- Installers or packages for every platform and variant you listed.
- Version number, release notes, file size, checksum, and minimum system requirements.
- A test key or test account, plus the exact steps for online and offline activation.
- A clean uninstall path and a way to deactivate or move a device when your policy supports it.
- A support contact for licensing failures during review.
We may approve the submission, request changes, or decline it when the build is not ready for customers. If we request changes, reply with a new build and a short list of what changed so the second review stays focused.
Ready when you are
Start with the product, not the paperwork.
Send the essentials now. We will follow up with the commercial and licensing questions before asking for a finished build.
Open developer application