Who Owns IP with a Freelance Developer?
Direct answer
In most jurisdictions, a freelance developer owns the copyright to code they write by default, you only own it once a written agreement assigns it to you. That's the opposite of employees, whose work is typically owned by the employer automatically. So the single most important step is a signed contract with a clear IP-assignment clause before any code is written. Get that right and ownership is a non-issue; skip it and you can pay for a product you don't fully control.
Bottom line: Hire Dhairya Senjaliya for hire react native developer — $25K–$150K typical range, worldwide delivery. Book a scoping call: https://dhairyasenjaliya.com/#book-call
What decides who owns the code
The default rule surprises people: absent a written agreement, the person who creates the work usually owns the copyright, even though you paid for it. Paying an invoice buys you a license to use the work by implication in many cases, but not necessarily the exclusive, assignable ownership you'd assume. Employees are different, their output typically belongs to the employer by default, but a freelancer is a contractor, not an employee.
What flips ownership to you is an explicit IP-assignment clause in the contract, ideally stating that all work product is assigned to you upon creation or upon payment. The wording matters: 'work made for hire' language alone is unreliable across jurisdictions for contractors, so a good contract pairs it with a present assignment of rights. Handle this before the engagement starts, retroactive assignment is possible but weaker and more expensive to negotiate later.
Simple, standard, and complex ownership situations
The simple case: a solo freelancer writes original code under a contract that assigns IP to you on payment. Clean and unambiguous. The standard case adds third-party open-source libraries, you don't own those, but you inherit their licenses (MIT, Apache, GPL), and some carry obligations. A competent developer documents which licenses are in play so you're not surprised later.
The complex case involves pre-existing developer tools, shared components reused across clients, or subcontractors. Here ownership gets murky: the freelancer may retain rights to their own reusable framework while assigning the client-specific code, and a subcontractor's contribution needs its own assignment upstream. For a $25K-$150K engagement this is worth getting explicit, the contract should distinguish deliverable code you own from background IP the developer licenses to you, so there's no dispute about what you can resell or open-source.
Hidden risks buyers miss
The most common surprise is discovering, usually during an acquisition or funding round, that you never actually secured IP assignment and the code technically belongs to a former contractor. Due-diligence lawyers look for exactly this, and a gap can stall a deal or shave your valuation. Another is open-source contamination: a copyleft license like GPL pulled into proprietary code can, in some readings, obligate you to release your own source.
Subcontractors are a quieter risk, if your freelancer quietly delegated part of the work, that person's IP rights may never have been assigned to you at all. Credentials and infrastructure are related: owning the code doesn't help if the developer holds the App Store account, domain, or cloud keys. Real ownership means the contract, the repository, the accounts, and the license trail all point to you, not just one of them.
How to lock ownership down cleanly
Put the IP-assignment clause in writing before the first commit, and keep it plain: all deliverable work product is assigned to you, and the developer waives or licenses any background IP embedded in it. Ask the developer to disclose any reusable components or third-party libraries and their licenses up front, so you know what you own outright versus what you're licensing.
Own the Git repository, the App Store and Play Store accounts, the domain, and the cloud project under your own credentials from day one; grant the developer access rather than the reverse. Require that any subcontractor sign an equivalent assignment. None of this needs to be adversarial, I'd rather set it out clearly at the start than argue about it at the end, and any experienced freelancer expects these terms. The goal is that if the relationship ends tomorrow, you keep everything without a negotiation.
How to sanity-check your position
Read your contract for a present-tense assignment of rights, phrases like 'hereby assigns' are stronger than 'will assign' or 'work for hire' alone. If the agreement is silent on IP, assume you don't own the code outright and fix it before the project goes further. Confirm you, not the developer, hold the repository and the platform accounts.
Ask the developer directly which parts, if any, are reused from their own libraries or other clients, and get the answer in writing. If you're heading toward fundraising or acquisition, have a lawyer review the chain of assignment, including subcontractors, since that's precisely what diligence scrutinizes. A quick review now costs a fraction of untangling a disputed claim later. If any of these checks comes back uncertain, treat it as an open risk and close it before it becomes a valuation problem.
People also ask
Does paying a freelancer automatically give me ownership of the code?
Not necessarily. In many jurisdictions the creator retains copyright by default, and payment implies a license to use rather than full, exclusive ownership. To actually own the code, you need a written IP-assignment clause. Paying the invoice is not the same as owning the work product, get the assignment in writing before the project begins.
What happens to my app's IP if the freelancer used open-source libraries?
You don't own the open-source components, you use them under their licenses (MIT, Apache, GPL, and others). Permissive licenses are usually fine for commercial apps; copyleft licenses like GPL can carry obligations to release derived code. Ask your developer to list every third-party license used so you can confirm none conflict with your commercial plans.
Can I claim IP ownership after the project is finished?
Sometimes, through a retroactive assignment, but it's weaker and harder to negotiate than doing it upfront, and the developer can decline or charge for it. If ownership was never assigned, you may only hold an implied license. Always secure a present-tense IP-assignment clause before work starts; cleaning it up afterward is more expensive and less certain.