A working client for the API
Python and TypeScript modules that call the recovered endpoints, with request signing, session handling and payload encryption already built in.
APK to callable API
The API behind your app, callable from your own code
A person reverse engineers the private API the app talks to and hands you a working client for it. One project costs $70: $10 to start and $60 on delivery, with a 14-day money-back guarantee.
Total price$70
To start the work$10
On delivery$60
Money-back window14 days
How a project runs
Every project follows the same four stages. Upload takes minutes. The analysis between scope and delivery is the slow part, and it is done by hand.
- Upload your APK
- Scope confirmed
- Mobilization fee
- Client delivered
- 01
Send the signed build, up to 256 MB. The manifest is read on upload and nothing in the app is executed.
- 02
We report the framework, protections and signing scheme, then agree which workflows will be recovered.
- 03
A small fee starts the work and opens a queue slot. Nothing is charged before you have read the scope.
- 04
You receive the working client, documentation and test fixtures. The balance is due on delivery.
Deliverables
What you receive
The client is the deliverable. You run it in your own service, on your own schedule, against the real backend.
OpenAPI description and Postman collection
Every recovered endpoint described in a form your existing tools can import, so the API is callable without writing code first.
Written documentation
What each workflow does, which fields it takes, what it returns, and which values have to come from a previous call.
Test fixtures from the real app
The captured request and response pairs the client was verified against. When the app updates, that turns a re-investigation into a diff.
The recovered endpoint list
Every path, method, header and body shape found in the build, including the ones the app declares but rarely calls.
Thirty days of fixes
If a delivered call does not match the app it was built from, we fix it. That is the deliverable being wrong, not a change of scope.
You can also have the platform run the recovered connector for you, if you would rather not carry the signing and encryption code yourself. That is a convenience on top of the delivery, not a requirement, and everything above arrives either way.
What we need from you
Two practical things. No paperwork.
A signed APK that installs
A build that runs on a device or emulator. If your release pipeline produces an Android App Bundle, build a universal APK from it first, because the analysis works from the APK.
Access, if the calls sit behind a login
If the workflows you want only answer for a signed-in user, we need an account in that state, or a capture taken from one. This is about being able to test the calls, not about entitlement.
We do not ask you to prove you own the app, and there is no form to sign. The request is taken in good faith and the work starts. If something about a project looks wrong, we will ask about it before starting, and that is the only time it comes up.
At upload the platform reads the APK manifest and reports the framework, the protection products it recognises, and the signing scheme it finds. That report is available before you pay, and it is the basis of the scope you confirm.
Where this gets hard
Heavily protected apps take longer, and some are genuinely not viable. Packers, native code virtualisation and integrity checks all add work, and a request signing key that only exists inside a hardware-backed keystore may not be recoverable at all. Where we can tell before payment, you are told before you pay. If a project turns out to be undeliverable after payment, the 14-day guarantee covers it.
Next step
Start with your APK
Upload takes a few minutes and ends with a scope report. You pay $10 only after you have read it.
Want the background first? The technical guides cover how Android request signing, pinning and payload encryption are actually handled.