Deliver installers and keys
Upload the software file and add a pool of license keys. Zwely assigns one after checkout and includes it in the delivery email.
Zwely supports software products that need a secure checkout, installer download, license key delivery, and product-scoped license validation.
Upload the software file and add a pool of license keys. Zwely assigns one after checkout and includes it in the delivery email.
Use product-scoped validation tokens for client-safe checks, or account API keys for server-side validation.
Orders keep the payment, customer, license, and delivery context together so support is easier to reason through.
Selling software plugins, installers, extensions, presets, VSTs, templates, or developer tools usually means you need more than a download button. You need payment, file delivery, license keys, customer records, refunds, and a way to validate licenses later.
Zwely gives software sellers a focused checkout and delivery layer. It helps you sell plugin downloads from your own site, assign license keys after purchase, and validate those keys through an API when your app needs to check entitlement.
A plugin buyer usually needs two things after checkout: the installer or downloadable file, and proof that they are allowed to use it. That proof might be a license key, serial number, activation code, or product-specific entitlement your software checks later.
If those pieces live in separate tools, support gets painful quickly. The order is in one place, the key list is in another, the file is somewhere else, and the buyer email is in a payment processor. Zwely keeps the commercial context together so you can answer the normal support questions: who bought it, which product, which key, and whether the order is still active.
That makes Zwely useful for solo developers, small software shops, audio plugin makers, template sellers, and creators who want a real software selling workflow without building an internal commerce system first.
Software buyers often need to read compatibility notes, supported operating systems, version details, changelog context, license terms, and installation instructions before they buy. That information belongs on a carefully written product page, not buried inside a generic catalog tile.
Zwely lets the product page stay on your site. You can write the technical details in your own voice and use an embedded checkout button for the purchase.
The checkout should feel trustworthy, but it should not take over the product experience. Zwely handles payment and delivery while your page explains compatibility, installation, licensing, and why the software is worth buying.
For products that require a license, Zwely can assign a key from the product's license pool when checkout completes. That key can be included in the customer delivery email along with the download button, so the buyer receives the pieces they need in one place.
Keeping keys product-scoped is important. A license intended for one plugin shouldn't accidentally unlock another product. Product-level key pools make the assignment clearer, and they make validation safer when your app checks a key later.
This also helps with support. When a buyer asks for their key, you can look at the order and see the assigned license without searching through raw files or spreadsheets.
A download alone doesn't prove that a user should keep access forever. If your plugin or app needs activation, Zwely's API can validate whether a license key is valid for a specific product. That lets your software check the key the customer enters without exposing account-level secrets.
Zwely supports two validation patterns. Server-to-server validation can return richer account context when you use an account API key from a trusted backend. Product-scoped validation tokens are safer for client-side or app-bundled checks because they only validate a specific product and return less sensitive data.
This matters for real-world software. You want to confirm the key belongs to the product, was assigned by checkout, and is not tied to a failed or refunded order. Zwely's validation workflow is designed around those practical questions.
Software refunds create edge cases. A buyer might request a refund after receiving a key, lose an email, reinstall a plugin, or enter a license key into the wrong product. The selling system needs to keep enough context for you to respond clearly.
Zwely links orders, customers, products, license keys, payment status, delivery settings, and refunds. It doesn't expose raw card details or secrets, but it does give you the operational context you need to handle support.
That context is what separates a real software checkout workflow from a plain download link. Buyers get a clean email, and you get a record you can trust.
Before launch, create the product, upload the installer or ZIP file, add license keys if the product requires them, connect Stripe, preview the delivery email, and test the checkout. Then embed the button on the product page where you explain compatibility, version support, and what the buyer receives.
If your app validates keys, create the right kind of API credential. Use an account API key only from a trusted server. Use a product-scoped validation token for safer product-specific license checks. Document the activation flow in your product so buyers know where to paste the key.
The goal is a software purchase that feels obvious: buy the plugin, receive the file and key, install it, activate it, and get help if something goes wrong.
Software buyers need to know whether the product will work for them. State supported operating systems, host apps, plugin formats, framework versions, dependencies, update policy, and any known limitations before checkout.
Zwely handles payment, file delivery, and license assignment, while your product copy gives buyers technical confidence. Clear compatibility notes reduce refunds and make support feel more professional.
A software checkout can be secure while the app integration is not. The biggest mistake is putting broad account credentials into distributed software. If customers can inspect the app, they can potentially inspect whatever is bundled with it.
Zwely separates account API keys from product-scoped validation tokens so you can choose a safer pattern. Trusted servers can use account keys. Client-side validation should use narrower product-scoped tokens and limited responses.
Activation should not feel like punishment for paying. Ask for the license key, optionally ask for the customer email, show a useful error when validation fails, and explain what to do if the buyer cannot find their key.
Because Zwely's validation statuses are more specific than a generic failure, your app can provide better messages. A refunded order, an email mismatch, and a missing key should not all produce the same confusing error.
Software products change. You may ship a new installer, patch a bug, rename a product, or create a paid upgrade later. A selling system should keep earlier orders understandable while letting the product evolve.
Zwely keeps orders connected to the product record and delivery context, so you have a clearer history of what customers bought. If you update the downloadable file, your page and customer communication can explain what changed.
If your plugin uses license validation, your own docs matter too. Buyers need to know where to paste the key, what happens during activation, and how to contact you if they reinstall or change machines.
Zwely provides API docs for the commerce and validation side. Your product docs should translate that into buyer-facing instructions, activation screenshots, troubleshooting notes, and plain-language licensing terms.
Yes. You can sell downloadable software products and assign license keys after checkout.
Yes. Zwely includes API endpoints for rich server-side validation and client-safe product-scoped validation.
No. Account API keys are server-only. Use product-scoped validation tokens for safer client-side license validation patterns.
Yes. Delivery emails can include both the download button and the assigned license key when the product uses both.
Start with one product, one button, and one clean delivery email. You can add more polish when the product is already moving.