DevPayr lets you ship production-ready apps while quietly controlling licenses, domains, and usage limits — so if a client disappears after delivery, you can lock or limit access in one click without breaking anything.
import { DevPayr } from '@xultech/devpayr';
DevPayr.bootstrap({
license: 'YOUR-LICENSE',
secret: 'your secret key',
base_url: 'https://api.devpayr.com',
action: 'boot',
injectables: true,
invalidBehavior: 'modal',
onReady: (res) => console.log('✅', res)
});<?php
require 'vendor/autoload.php';
use DevPayr\DevPayr;
use DevPayr\Exceptions\DevPayrException;
try {
DevPayr::bootstrap([
'license' => 'YOUR-LICENSE-KEY',
'injectables' => true,
'invalidBehavior' => 'modal',
]);
echo "License valid.";
} catch (DevPayrException $e) {
echo "DevPayr error: ".$e->getMessage();
}from devpayr import DevPayr
DevPayr.bootstrap({
"license": "YOUR-LICENSE",
"api_key": "YOUR-API-KEY",
"base_url": "https://api.devpayr.dev/api/v1/",
"secret": "shared-secret",
"injectables": True,
"invalidBehavior": "modal",
"onReady": lambda d: print("✅", d)
})If you’ve ever delivered something meaningful — code, a design, a system, a template — and watched someone use it freely while your payment dragged, you already understand why DevPayr exists.
For devs who finish a project, hand it over, and then suddenly begin chasing a client who keeps saying “give me till weekend”. DevPayr gives you quiet control, so your work isn’t fully enjoyed until it’s fully paid for.
For teams handling multiple clients at once. One unpaid web app can throw an entire workflow off balance. With DevPayr, you simply ship your work and let access match payment automatically — no awkward follow-ups.
For people who deliver dashboards, templates, branding systems, UI kits, frontends — and then find out the client is happily using everything without settling the remaining balance.
For creators who sell scripts, templates, themes, components, or design files — whether directly or on platforms like CodeCanyon, Envato, Gumroad, or your own site.
DevPayr helps make sure your item isn’t used by people who didn’t buy it, didn’t activate it, or are trying to share it illegally.
If you build software — SaaS, desktop apps, tools, plugins — and worry about your code being copied, shared, or used without authorization, DevPayr gives you a simple licensing shield that sits between your app and whoever is running it.
Trials, PoCs, custom deployments — clients love to extend them without talking about payment. DevPayr quietly shuts the door when time is up, so you don’t have to play the “just checking on that invoice” game.
If you’ve ever refreshed your banking app after delivering work and saw nothing…
If someone ever used your work like it was free…
If people have ever said, “we’ll pay soon”, but still logged into the system every day…
DevPayr is for you. It’s simply a boundary — not a threat.
Anyone who has built something for a client — code, designs, apps, templates — knows this feeling. You deliver the work. They start using it immediately. But somehow the “last payment” keeps getting postponed, explained, or ignored.
Whether you're building apps, selling digital assets, writing code for clients, or running an agency — you deserve to get paid without stress, without begging, and without tension. DevPayr helps you keep things professional, calm, and fully in your control.
DevPayr wasn’t born from a pitch deck or a “market opportunity.” It came from the frustration that every developer, designer, and builder knows too well.
I’ve worked on projects where I poured in time, energy, sleep, and emotion — only for the client to go quiet the moment the work was done. Days turned into weeks. The app was live. Users were inside. Money was being made… yet I was still sending reminders like I was the one at fault.
And the worst part? I couldn’t do anything. Because once you hand over your work, you lose every form of leverage. You either start begging, or you swallow the loss. Both feel terrible.
I wanted a better way — something peaceful and ethical. A system where your work doesn’t get fully used until it’s fully paid for. Not a destructive “kill-switch,” but a controlled and respectful lock that activates only when terms are broken.
Along the way, I realized this wasn’t only about client projects. People selling digital assets, plugins, themes, scripts, templates — all face the same thing. Someone buys once, leaks it, uses it everywhere, or installs it on ten domains when they paid for one.
DevPayr became that quiet middle layer that protects your work: from unauthorized use, from unpaid deliveries, from silent exploitation. It lets you sleep better knowing that your craft is not running wild on servers you don’t control.
I built DevPayr for myself at first — but it didn’t take long to see that every builder has lived some version of the same story. If you’ve ever felt cheated, ghosted, or undervalued in the work you poured your heart into… then DevPayr is for you.
— Michael Erastus, Founder of DevPayr
You keep building the way you already do. DevPayr simply watches how and where your work is being used, and reacts when something doesn’t match what you agreed with the client.
In DevPayr, you create a project for that client, product, or template. You define basic rules and generate either a project-specific API key or a global API key for your account. Global keys are perfect for platforms and marketplaces (like your own “Codecanyon-style” setup) that need to manage many licenses from a single integration.
For each client or purchase, you generate a license. You can either lock it to a specific domain or leave the domain field empty and let DevPayr auto-capture the first domain that calls it. From there, DevPayr can limit usage based on your settings — things like allowed domains, environments, or how many installs are permitted.
Your app, plugin, or theme calls DevPayr using the SDK or API key. DevPayr validates the license, checks the domain or environment, and then responds using the mode you’ve chosen for that project:
This works whether you’re shipping a custom app, a SaaS, a theme, or a downloadable script. If the license and usage are clean, everything runs smoothly. If not, DevPayr steps in — exactly how you configured it.
Use your global API key or a project-specific key — drop the snippet into your code and DevPayr handles the rest.
// Using your GLOBAL API key (good for platforms, SaaS, marketplaces)
import { DevPayr } from "@xultech/devpayr";
DevPayr.bootstrap({
api_key: "YOUR-GLOBAL-KEY",
license: "LICENSE-KEY",
action: "boot",
mode: "modal", // modal | redirect | silent | log
injectables: true,
onReady: res => console.log("DevPayr ready:", res),
});
// Using a PROJECT API key (recommended for client apps)
DevPayr.bootstrap({
project_key: "YOUR-PROJECT-KEY",
license: "PROJECT-LICENSE",
mode: "silent",
});
// Auto-capture domain (leave domain empty in dashboard)
DevPayr.bootstrap({
project_key: "YOUR-PROJECT-KEY",
license: "CLIENT-LICENSE",
autoDomain: true
});
<?php
require "vendor/autoload.php";
use DevPayr\DevPayr;
// GLOBAL KEY
$dp = new DevPayr([
"api_key" => "YOUR-GLOBAL-KEY",
"license" => "LICENSE-KEY",
"mode" => "redirect"
]);
// PROJECT KEY
$dp = new DevPayr([
"project_key" => "YOUR-PROJECT-KEY",
"license" => "CLIENT-LICENSE",
"mode" => "modal"
]);
// Auto-capture domain
$dp = new DevPayr([
"project_key" => "YOUR-PROJECT-KEY",
"license" => "CLIENT-LICENSE",
"autoDomain" => true
]);
echo "License valid.";
from devpayr import DevPayr
# GLOBAL KEY
DevPayr.bootstrap({
"api_key": "YOUR-GLOBAL-KEY",
"license": "LICENSE-KEY",
"mode": "modal"
})
# PROJECT KEY
DevPayr.bootstrap({
"project_key": "YOUR-PROJECT-KEY",
"license": "CLIENT-LICENSE",
"mode": "silent"
})
# Auto-capture domain
DevPayr.bootstrap({
"project_key": "YOUR-PROJECT-KEY",
"license": "CLIENT-LICENSE",
"autoDomain": True
})
DevPayr isn’t just for developers chasing unpaid balances. It’s for anyone who creates value and needs a quiet, respectful way to stay in control.
Protect your client projects without drama. If a client disappears mid-payment, DevPayr steps in quietly — modal, redirect, silent lock or logs only, depending on how gentle you want to be.
Manage hundreds of client builds with consistent licensing rules. Your team never has to write custom “disable if unpaid” logic again — DevPayr handles enforcement cleanly across all your client apps.
Bind each tenant or customer to a license, domain, or usage limit. Perfect for SaaS with workspaces, branches, or multiple environments. A global API key keeps every enforcement rule outside your core codebase.
Selling themes, plugins, templates, scripts, UI kits or digital tooling? DevPayr ensures only paying customers can use your product — no leaks, no unauthorized domains, no sharing purchase codes everywhere.
Marketplace sellers can issue a license per buyer and track how many installs, domains or activations they’re allowed. Platforms can issue global or per-product keys automatically using the DevPayr API.
As a developer, I get it. The first instinct is, “I’ll just add a quick
if (!paid) { /* block */ }
somewhere and move on.
It works the first time. Then the client changes domains. Or you need a staging URL. Or an agency asks for multi-tenant support. Or a marketplace like Envato/CodeCanyon needs a clean way to validate every install of your theme, plugin, or script. Suddenly that “small” script wants logs, dashboards, rate limiting, retries, and a dozen edge cases you didn’t plan for.
DevPayr exists so you don’t spend your nights patching a home-grown licensing system, chasing abuse reports, or arguing with clients about who changed what. You stay focused on building — DevPayr quietly sits between your work and the people using it.
You’re not glued to maintaining it forever
No custom tables, no scattered if (client_unpaid) checks hidden
inside controllers. DevPayr centralizes checks, limits, and kill modes
(modal, redirect, silent, log) in one place — for all your projects.
Real-world edge cases are already handled
Domain moves, rebrands, staging vs production, sub-domains, multiple installs from one purchase, “test” licenses, soft vs hard blocks — DevPayr is built with these in mind so you don’t have to reinvent the rules for every client.
Designed for digital products, marketplaces & platforms
Selling themes, plugins, code, templates or design systems? Or running a platform that powers many stores or tenants? You can issue licenses per buyer, bind them to domains or installs, and manage everything through DevPayr — instead of wiring custom license logic into each product.
Global keys, project keys, and clean API control
Generate a global API key for your platform, or project-specific keys when you need separation. Perfect for SaaS teams, agencies, or marketplaces that want to automate license issuance, renewals, and enforcement without exposing raw internals of their app.
Less drama, more control when clients don’t pay
Instead of nuking a site or rage-pushing a breaking update, you pick an enforcement mode that fits the relationship: a modal that locks access, a redirect to a billing page, a silent block, or just logging for now. You stay in control without burning bridges.
DevPayr doesn’t replace your contracts or your invoice tool. It simply makes sure people can’t quietly keep using your work when they’ve stopped keeping their end of the deal.
Open-source “client-did-not-pay” style scripts
Fun to try, but usually opinionated, not tailored to your stack, and rarely maintained with your business in mind. You still carry the responsibility when things break.
Rolling your own checks inside the app
Feels “cheap” at first, but ties your enforcement to one codebase, one team, and one person. When you’re busy or move on, the whole thing slowly rots.
DevPayr
Built purely to protect your work: licenses, domains, usage limits, enforcement modes, logs, and API access — all in one place, wired to your projects with a small snippet or SDK. You keep your energy for shipping, not chasing unpaid installs.
Want to stop duct-taping your own licensing rules?
Pricing that doesn’t fight you
Start small, grow into it. No hidden fees, no forced long contracts — just clear limits around projects, domains, and licenses.
For everyday client work
Best for hobby projects or testing.
A gentle way to test DevPayr on a live client project.
For everyday client work
Ideal for individual developers & Designers
Or $5 billed yearly.
For everyday client work
For growing startups managing internal tools.
Or $100 billed yearly.
Not sure where to start? You can change plans later as your work grows.
View full pricing breakdownSometimes a client stops paying but keeps the app running. DevPayr lets you respond without feeling like a villain — show a clear message, redirect them to settle the bill, or quietly lock things down in the background.
You choose the pattern per project, license or rule.
Change it anytime without touching the client’s code again.
When a license expires or a payment milestone is skipped, DevPayr shows a clean, branded modal inside the app — explaining what happened and how to fix it. No broken pages, no cryptic errors, just an honest “this isn’t paid for yet.”
Instead of letting unpaid users live inside your app, DevPayr can redirect them to a page you control — your billing portal, a “payment overdue” page, or a support form. You stay firm, but the experience stays sane.
Silent mode lets you restrict what the app can do without showing anything obvious to the end user. Maybe analytics stop syncing, exports are disabled, or a few “nice to have” features go to sleep until payment catches up.
Not ready to enforce yet? Turn on Log mode. DevPayr will quietly track license checks, domain usage, and suspicious calls — without blocking anything — so you can see how your work is really being used before pulling any switch.
DevPayr sits close to your work, so it’s normal to be careful. Here are the honest answers to the things that normally come up on first calls and DMs.
By default, DevPayr can sit in pure log mode and only record usage. No modals, no redirects, no blocking.
When you’re ready to enforce, you choose the pattern — Modal, Redirect, Silent, or Log — and the exact rules (expired license, unpaid milestone, wrong domain, etc.). You stay in control the whole time.
DevPayr ships with first-class support for Python,PHP and JavaScript frontends, as well as NODE, and will expand into more SDKs over time.
You can also call the API directly from any backend (Node, Python, Go, etc.) as long as you can make HTTP requests. For marketplaces and platforms (like template stores or SaaS builders), you can use project or account-level API keys to automate license generation and checks.
Most builders don’t actually want to “destroy” anything. They just don’t want to be used.
DevPayr is built with that in mind: clear messaging, reversible actions, and patterns that give clients a way back in once they’ve done the right thing. You decide where the line is, but we nudge you toward solutions that are firm and still human.
To be transparent: if your app depends on live checks and DevPayr is down, those checks will fail and your enforcement logic will see that as “not valid”.
That’s why we strongly recommend using the SDK with caching turned on. Once a license has been verified and cached, your app can keep running based on that cached result, even if:
In short: live checks can fail if we’re down, but with caching enabled your app doesn’t have to break just because our servers are having a bad day.
The pricing is designed so solo devs and small studios can protect their work without feeling punished. You can start on the lower tiers, test it on one or two clients, and then move up as it becomes part of how you work.
When you’re ready to see all the details, you can check the full breakdown on the pricing section.
Rather talk to a human first? Send a message and we’ll walk you through it.
If you build software for people, you deserve to be paid for it — fully, fairly, and without chasing anyone. DevPayr gives you the quiet control you need, without breaking trust or breaking the app.
No card required · No lock-in · Works with Node, PHP, JS, Python & more