Sample End User License Agreement Template
If you develop or create software, you need an End User License Agreement (EULA). This agreement prevents the end user from abusing your app or misusing it in any way, and it ensures that you retain your existing rights over the asset.
An EULA is not quite the same as a Service Level Agreement (SLA), although they are often confused as the same thing.
The End User License Agreement regulates the relationship between the developer and the end user. A Service Level Agreement sets out the actual service details, including what end users can expect and what to do if they have a complaint.
In practice, then, many developers use both SLAs and EULAs, but we're talking specifically about EULAs here.
Let's take a closer look at these important agreements and what information yours should include.
- 1. What is an End User License Agreement?
- 2. Who Needs an End User License Agreement?
- 3. What are the Benefits of Having an End User License Agreement?
- 4. Are EULAs Binding Under the Law?
- 5. What Clauses Should All EULAs Have?
- 5.1. Effective Date
- 5.2. Company Name & Designation
- 5.3. Introductory Clause
- 5.4. Permitted Use
- 5.5. Restricted Use
- 5.6. Termination Conditions
- 5.7. Warranties & Disclaimers
- 5.8. Limitation of Liability
- 5.9. Jurisdiction and Governing Laws
- 5.10. Contact Information
- 5.11. Related Agreements
- 5.12. Copyright & Intellectual Property
- 6. Displaying Your EULA & Getting Consent
- 7. Conclusion
What is an End User License Agreement?
An EULA is a specific contract between the software creator, developer, or publisher, and the individual end user who purchases the software. The contract gives the user a right to use a copy of the app or software in a specific way, subject to clear conditions.
The end user can't download or install the software copy until they agree to these conditions of use. In other words, think of an EULA like a rental agreement. The user pays to use the software, but the developer still owns it.
This is important because there's a common misconception that end users "own" their copy of your app. People often assume that when they buy something, it belongs to them. However, all the end user has is a functioning copy of your software - not rights to the software itself.
Who Needs an End User License Agreement?
Essentially, if you make your technology available for public use, then you have a need for an EULA.
So, for example, if you're a video game company that supports online gaming, or you're a developer and you've made an app available on the Apple App Store, you should have an EULA.
What are the Benefits of Having an End User License Agreement?
It's vital that you draft and publish an EULA on your website for many reasons. However, there are a few reasons in particular that we'll draw your attention to.
- Limiting your liability: For software and hardware crashes, and other indirect damage. Without a limitation clause, a user could theoretically try to sue you for anything that happens to their machine after they download your software.
- Restricting Use: You can restrict what users do with your app or software. This is critical because it means that people can't use your app for illegal activities, such as hacking or spamming, or abuse it in any way.
- Controlling Your Property: Your software is your property. Without an EULA, you risk someone using your app for their own commercial purposes and potentially claiming ownership.
- Disclaiming Warranties: An EULA warranty protects you from legal action if your services aren't running 100% of the time. Since no software is bug-free, and downtime is inevitable, a warranty manages your users' expectations.
- Terminating Accounts or Service: An EULA allows you to revoke someone's license or end your services for any reason. Remember, an EULA keeps your property firmly within your control - it's up to you who has a license to use it.
Are EULAs Binding Under the Law?
An EULA is legally binding.
Why? Because it's a legally enforceable contract between two consenting parties - you, and the individual user.
Since an EULA is a contract, contract law applies. Whichever jurisdiction you're in, contracts are typically only valid if they are:
- Mutually agreed to
- Clear and unambiguous
- Fair i.e. they're not unfairly biased in favor of one party
What this means in practical terms is that you can enforce the contract if the user agrees to it and the terms are not unclear or unfair.
So, how do you ensure that you have a legally binding contract? By including certain clauses.
What Clauses Should All EULAs Have?
Every End User License Agreement shares certain clauses in common. Although some EULAs are far more complex, there's no need for the majority of EULAs to run on for pages - user-friendly, jargon-free clauses are vital.
Let's take a look at what clauses you should include in your EULA:
Be clear about when your EULA came into force. This is good administrative practice.
Here's an example from Nintendo's Animal Crossing EULA:
Company Name & Designation
Always include your company's full name. It helps the customer clarify exactly who they're entering into a contract with, which improves transparency and user friendliness.
Here's how Huawei sets out its full name and designation. First, it clarifies its full company name, and then highlights that all references to "Huawei" throughout the EULA refer to this company:
Remember, you don't have a legally enforceable EULA unless it's properly agreed to by both parties. You should begin your End User License Agreement, then, with a clause explaining:
- It's an EULA
- This is an agreement between you (the company) and the individual end user
Take a look at this very simple clause from Cisco. It succinctly explains the nature of the agreement - In this case, a contract for how people may use the software:
Next, you should set out what end users can do with your app or software. Typically this means end users can only use the software for personal purposes.
Be clear that you're only offering a license, not property rights.
Here's an example from Nintendo. First, it's made clear that the company is offering a revocable license, not ownership. Then, it highlights that end users must only operate the app for noncommercial, personal reasons:
You must specify what end users can't do with your product. You should set out these restrictions clearly and succinctly so that they're easily understood.
There are some restrictions you'll definitely want to include, such as:
- Using it for commercial purposes
- Selling, leasing, or copying the technology
- Using the app to facilitate criminal activity, including hacking
- Reverse engineering
Here is how Huawei addresses these restrictions.
First, it prohibits commercial use:
Then, it bans users from lending or selling the app, but does allow for a one-off full transfer:
Next, it prohibits reverse engineering. This is a common restriction that you'll see in pretty much every single EULA:
While this company makes most of its restrictions into separate paragraphs, you can also make a list of the restrictions. It depends on the nature of your business and your personal preferences. Just remember to be as accurate, concise and understandable as possible so your users know exactly what they cannot do.
It should be clear that you can terminate the agreement at any time if an end user breaches the EULA. It should also be obvious how the end user can withdraw from the agreement if they wish.
Huawei has a nice, concise clause for this. You'll note that some clauses remain effective even after termination:
Warranties & Disclaimers
You can't promise that your services will be up and running smoothly all the time, and you can't promise that you have a perfect product. So, you need the appropriate disclaimers.
Be clear that, while end users have basic consumer rights that you can't "contract out" of, they take the product "as it is." You don't promise that they'll enjoy the app, or that it meets all their expectations.
Here's a good clause from Huawei. Huawei makes no promises or assertions to the end user about the product other than the fact that the software meets basic legal standards:
Similarly, Ubisoft puts the risk back to the end user. It's their responsibility to choose the right product for their purposes, and they download and use the software at their own risk:
Limitation of Liability
You must limit your liability for any damage caused to an end user's property if they use your software. Examples include:
- Personal injury (To the extent the law permits. You can't deny liability entirely or else it's an unfair contract term.)
- Hardware malfunction
- Loss of reputation or business goodwill
Rockstar Games sets out its liability very clearly. The company won't be held responsible for incidental, special, or consequential damages so far as the law allows. If the company must accept liability, it'll only pay up to the same amount that the user paid for the software - again, unless the law says otherwise:
Jurisdiction and Governing Laws
Be clear about which country's laws govern your agreement. This is known as establishing the jurisdiction. Typically, you'll choose the laws of the country in which you have your main place of business, but not always.
Consider this clause from Rockstar Games. End users agree that New York has jurisdiction over any contractual dispute. However, if the end user has the legal right to raise proceedings in, for example, the EU, they're free to do so. It's flexible, but fair:
Set out how users can contact you if they have questions or queries about your End User License Agreement. This is a simple clause - all you need is one method of contact, such as a telephone number or email. Keep this up-to-date and accurate. However, you can add more methods if you have them.
Here's an example from Candy Crush Saga's EULA:
If users can't query you about your End User License Agreement, it's arguably unfair and it will be harder to enforce the terms.
Copyright & Intellectual Property
To stop others from stealing your software, designs, technology, and any other relevant information, you must declare that your intellectual property (IP) is protected under copyright law. It's important that end users understand that using your software doesn't mean they have any rights to replicate, steal, share, or sell your IP.
What's covered varies from app to app, but typically, you'll want to protect your:
- Any patented technology
- Logos and trademarks
You must strike a balance between keeping the clause broad enough to cover your relevant IP, but specific enough that it's still a valid clause.
Here's a good example from Ubisoft. The phrase "including, without limitation" perfectly strikes this balance:
So, once you have a working EULA, how do you display it, and how do you get users to consent to it? Let's explore.
Displaying Your EULA & Getting Consent
You can't enforce an End User License Agreement unless the user clearly consents to its terms. In other words, you need explicit agreement to make the EULA a binding contract.
So, how do you get this consent? It's simple - you use what's known as clickwrap. Clickwrap means you either get someone to check a box to confirm they've read and agreed to the EULA, or you draw special attention to the EULA.
For example, to download Adobe Reader, there's no need to check a box. However, Adobe highlights the EULA and gives the user special notice of the Agreement:
On the other hand, Nintendo users must tick a checkbox to confirm they've read Nintendo's relevant agreements. This is a more classic example of clickwrap, but either approach is sufficient:
You can also upload links to your License Agreement on your website so that users can read it before they download the software or app, or buy hardware.
Apple does this. Users can download the exact EULA they need and read it whenever they wish:
Apple also draws attention to the EULAs for apps on its app store by adding a link to the app store listing. This way, users can read the relevant EULA before downloading the app:
You'll note that there's also, helpfully, a link to the other key policies in the same place. This is the definition of user-friendliness.
What matters is that users have advance notice so they know exactly what terms they're consenting to, and they understand how they may and may not use your products.
Any software developer needs an End User License Agreement, or EULA. The EULA is a binding contract between the developer and the end user who purchases, downloads, or installs a copy of the product. Since it's a contract, it's legally binding, and you need an end user's consent to the agreement.
Although EULAs vary, every EULA should include clauses explaining:
- The enactment date
- The binding nature of the agreement
- Your contact details and full business name designation
- The governing laws
- Permitted and restricted uses
- Termination conditions
- Warranties and limitation of liability
- Related agreements
- Copyright and IP