docs.discord.food Paid content

The Unofficial Discord User API Documentation at docs.discord.food is a community-maintained reference for the user side of Discord's API — the endpoints the official client and developer portal rely on, authenticated with user and bearer tokens. It is not affiliated with or endorsed by Discord, and it is not the place to look for bot development guidance. If you want to build a bot, use Discord's official documentation instead. If you want to understand how the client itself talks to Discord, this is the reference for you.

What "user API" means here

Discord exposes an open API serving requests for users, bots, and OAuth2 integrations. This documentation narrows its focus to how non-bot users interact with that API. In practice that means:

• User and bearer authentication tokens are the primary credential types documented.
• Bot endpoints may appear, but how bots interact with the API is explicitly out of scope.
• The material reflects how the official client and developer portal use the API, not a supported public contract.

The distinction matters because the two surfaces have different guarantees. Bot endpoints are officially supported and documented by Discord. User-side endpoints are not officially supported, which is exactly why a community project exists to map them.

The risk you need to weigh first

Automating user accounts is against the platform Terms of Service. The documentation states this plainly: doing so unsafely might get you banned. That is not a footnote — it is the single most important condition for deciding whether this reference is useful to you.

Two separate risks stack here:

1. Policy risk. Automation of user accounts violates the ToS regardless of how carefully you implement it.
2. Accuracy risk. Much of the documentation is based on reverse engineering and educated guesses. The maintainers state that inaccuracies may be present, even though they try not to publish information without basis.

If your goal requires a stable, supported, non-breaking endpoint, this is the wrong resource. The documentation itself points you to Discord's official documentation for that.

What the documentation covers

The presence of billing, payment, subscription, and premium referral resource pages tells you the scope extends into account and monetization surfaces of the user API, not just messaging or profile calls.

How to use it responsibly

The documentation is hosted on GitHub, and the project depends on community contributions. If you have knowledge of the Discord API, the maintainers ask you to consider contributing; corrections and improvements are explicitly welcomed, with a CONTRIBUTING.md describing the process.

A practical workflow:

1. Check the official docs first if your target is a bot-accessible endpoint. The unofficial docs direct bug reports for bot-accessible API parts to the official documentation issue tracker.
2. Treat every page as reverse-engineered until you verify behavior against the live client. Expect drift.
3. Contribute corrections through GitHub when you find inaccuracies — that is how the reference stays useful.

Who this is for

This documentation suits developers who want to understand or replicate how the official Discord client communicates with the API, and who accept both the ToS risk and the accuracy caveats. It does not suit anyone building a bot, anyone needing a stability guarantee, or anyone unwilling to verify reverse-engineered details themselves. The project's own framing is simple: go make cool stuff — but go in knowing what you are working with.

Userdoccers is the community-maintained, unofficial documentation for the user side of the Discord API, hosted at docs.discord.food. It covers how the API behaves for non-bot users — specifically requests made with user and bearer authentication tokens, as used by the official client and developer portal. It is not affiliated with or endorsed by Discord, and its contents are largely based on reverse engineering and educated guesses, so inaccuracies are possible. If you need bot endpoints, interactions, or any guarantee that an endpoint won't break, this is the wrong resource; use Discord's official documentation instead.

What Userdoccers actually documents

The scope is deliberately narrow. According to the introduction, the project documents "the user side of the Discord API, which is not officially supported, as used by the official client and developer portal."

That means:

• User and bearer authentication tokens are the focus, not bot tokens.
• Client-facing behavior — the same routes the official client relies on — is what gets described.
• Bot endpoints may appear, but how bots interact with the API is explicitly not the point of the documentation.

If your goal is a bot, an interaction handler, or anything with a stability promise, the introduction points you to Discord's official documentation rather than this project.

Why the information comes with caveats

The introduction is unusually direct about its own reliability. Two limitations matter before you build anything on top of it:

1. Reverse engineering and guesswork. The maintainers state they try not to publish anything without basis, but "quite a lot of the documentation contents are based off of reverse engineering and educated guesses," so inaccuracies may be present.
2. No official backing. The project is not affiliated with or endorsed by Discord in any way.

Treat the pages as a map of observed behavior, not a contract. Endpoints can change without notice, and a documented field may not match what you see in practice.

The Terms of Service risk

The introduction includes a plain warning: automating user accounts is against the platform Terms of Service, and doing so unsafely might get you banned.

This is the single most important constraint for anyone considering the documentation. Reading it is harmless; building a self-bot or automating your own account is a different matter. The documentation describes how the user API works — it does not make that use permissible.

Where to send corrections and bug reports

The project is community-driven and hosted on GitHub, and the introduction explicitly invites contributions:

• Corrections and improvements to the documentation are welcome; see CONTRIBUTING.md in the repository.
• Bugs in bot-accessible parts of the API should go to the official documentation's issue tracker, not this project.

If you have knowledge of the Discord API, contributing is framed as the thing that keeps the project useful.

When to use it — and when not to

The practical takeaway: Userdoccers is a reference for understanding the user-facing API, useful for research and for filling gaps the official docs don't cover. It is not a foundation for production systems, and it is not a green light to automate a user account.

In this documentation, "client" refers to the official Discord client and the user-side API it consumes — not a bot. The site documents the user side of the Discord API as used by the official client and developer portal, with a focus on user and bearer authentication tokens. If you are building a bot and need endpoints that are officially supported, this is the wrong reference; use Discord's official documentation instead.

The scope of this documentation

The project is a community effort, not affiliated with or endorsed by Discord. Its stated scope is the user side of the API, which is not officially supported. Two consequences follow directly from that:

• Authentication focus. The documentation centers on user and bearer authentication tokens — the credentials a logged-in human account uses.
• Bot endpoints are secondary. Bot endpoints may appear in the pages, but how bots interact with the API is explicitly not the focus.

The introduction also notes that much of the content is based on reverse engineering and educated guesses, so inaccuracies may be present. That is a description of the source material's reliability, not a guarantee about any particular endpoint.

Client vs. bot: what actually differs

The practical takeaway: "client" here means the software and credential type a normal user account runs under. A bot is a different kind of client with a different token type, a different support status, and a different documentation home.

The risk you should weigh before building

The introduction states plainly that automating user accounts is against the platform Terms of Service, and that doing so unsafely might get you banned. This is not a minor footnote — it is the single most important constraint on anything you build against the user-side API. If your project depends on a user account continuing to work, treat account loss as a real possibility rather than an edge case.

When to use this documentation, and when not to

Use it when you are trying to understand how the official client talks to Discord — for example, replicating a !userinfo-style lookup from a user context, or studying request shapes that the client itself sends.

Do not use it when you need a bot that will keep working. The introduction directs readers who want bots, interactions, and "a semblance of a guarantee that your API endpoint won't break" to Discord's official documentation. If you believe you have found a bug in a bot-accessible part of the API, the same page points you to the official documentation's issue tracker rather than this project.

If you want to contribute

All documentation lives on GitHub, and the project states that its success depends on community contributions. If you have knowledge of the Discord API, the introduction asks you to consider contributing and points to CONTRIBUTING.md for details. Corrections and improvements are explicitly welcomed — which matters given the reverse-engineered basis of much of the content.

A developer cheat sheet is a condensed quick-reference for syntax, commands, shortcuts, or snippets — not a tutorial. Use one when you already understand the concept and just need the exact form: the right flag, the correct method signature, the keyboard shortcut, or a copy-paste snippet. Skip it when you're learning a topic from scratch, because a cheat sheet assumes context it doesn't teach.

What a cheat sheet actually contains

Cheat sheets trade explanation for density. A typical one packs several of these into a single page or screen:

• Syntax patterns — how a loop, function, or query is written in a specific language
• Command flags — options for a CLI tool like git, docker, or grep
• Keyboard shortcuts — editor, terminal, or OS bindings
• Snippets — short reusable blocks you can paste and adapt
• Code tables — HTTP status codes, regex tokens, ASCII values, operators

CheatSheets.zip, for example, describes itself as a place to "share quick reference and cheat sheet for developers," covering areas like Linux, commands, and shortcuts. That scope tells you what to expect: breadth of recall material, not depth of teaching.

When a cheat sheet saves you time

Reach for one in these situations:

1. You know the concept but not the exact syntax. You understand Python list comprehensions but forget the ordering of the if clause.
2. You're scanning options. You want to see all the flags for a command at once rather than reading prose.
3. You're refreshing a familiar tool. You used tmux six months ago and need the pane-splitting keys again.
4. You're context-switching. Moving between languages or shells and need to re-anchor on the local conventions.
5. You want a starting snippet. You'll adapt a short block rather than write it from a blank file.

When a cheat sheet is the wrong tool

A cheat sheet is a memory aid, not a teacher. If you can't yet read the snippet and predict what it does, you're in the wrong resource.

How to read one effectively

Don't read a cheat sheet top to bottom. Use it like a lookup table:

1. Scan the categories or headings to find the section matching your task.
2. Locate the single line or block you need — ignore the rest.
3. Copy only the relevant snippet, not the whole section.
4. Adapt names and values to your variables and environment.
5. Run it in a real environment before trusting it.

That last step matters. A snippet that looks right can fail because of a version difference, a missing dependency, or a typo introduced when the sheet was transcribed.

Verify before you rely on it

Treat every snippet as a hypothesis. Test it in a scratch file, a REPL, or a throwaway branch:

• Run it once with known inputs and check the output matches your expectation.
• Check the version. A command that worked in one release may be deprecated or renamed in another.
• Confirm side effects. Some snippets delete, overwrite, or push — read before you run.

For example, if a sheet shows a git command to undo a commit, verify whether it preserves your working changes before using it on real work.

Signs a cheat sheet is outdated or too vague

• No version or date. You can't tell which release it targets.
• Bare snippets with no context. A line like config.set(x) with no indication of what config is.
• Deprecated syntax. Patterns you know were replaced years ago.
• No examples of output. You can't tell what "correct" looks like.
• Overly broad categories. A single "Linux" section covering everything usually means shallow coverage.
• Broken or missing links to the source it was derived from.

If a sheet fails two or more of these, find a maintained alternative or fall back to official documentation.

The bottom line

Use a cheat sheet to recall, not to learn. It's fastest when you already know the concept and need the exact form, and it's a liability when you copy without verifying. Keep one or two trusted, version-labeled references handy, test snippets before depending on them, and switch to real documentation the moment you need to understand rather than remember.

Docker's official documentation lives at docs.docker.com, and it is organized so that a beginner can move from "I've never installed Docker" to "my app runs in a container" without leaving the site. The fastest path is: install Docker, complete the Get Started tutorial, then jump to a language-specific guide for your stack. Use the Reference section only when you need exact command syntax, and browse Samples when you want a working project to copy.

This guide explains what each section of Docker Docs is for, gives you a reading order, and shows you how to find things quickly once you're past the basics.

What the main sections of Docker Docs are for

Docker Docs is not a single manual — it's a set of distinct areas, each written for a different moment in your learning. Knowing which one to open saves a lot of time.

The key distinction: Guides and Get Started teach you by doing; Reference tells you exactly what a command accepts. Beginners often get stuck in Reference too early, reading option lists without context. Start with the doing, then look up the details.

A step-by-step reading path for your first container

Follow this order the first time. Each step has a clear "you're done when…" signal.

Step 1: Install Docker

Open the Get Started area and find the installation instructions for your operating system (Docker Desktop for Windows and macOS, or the engine packages for Linux). Install it and confirm it works by running the version check command shown in the docs.

You're done when: a docker command in your terminal returns version information instead of "command not found."

Step 2: Complete the Get Started tutorial

The Get Started tutorial is the single most valuable page for a beginner. It walks you through building an image, running it as a container, and stopping it — using a small sample app so nothing is left to guesswork. Do every command yourself rather than reading passively.

You're done when: you have built an image and seen your container produce output.

Step 3: Understand the core concepts

Before containerizing your own project, read the conceptual material on images, containers, and registries. This is where the mental model clicks: an image is the packaged blueprint, a container is a running instance of it, and a registry is where images are stored and shared.

You're done when: you can explain in one sentence why you build an image before you run a container.

Step 4: Write your first Dockerfile

A Dockerfile is the text file that describes how to build your image. Find the Dockerfile reference in the docs and read the instructions you'll actually use first: FROM, WORKDIR, COPY, RUN, EXPOSE, and CMD. Don't try to learn every instruction — most projects use a small handful.

You're done when: you have a Dockerfile in your project that builds without errors.

Step 5: Build and run your own app

Return to the Guides section and find the guide closest to your language or framework. These guides follow the same build-and-run pattern as the tutorial but applied to real application types, so you can adapt the steps to your code.

You're done when: your own application responds correctly from inside a container.

How to find things fast once you're moving

After the first container works, your needs shift from "learn the flow" to "look up one specific thing." Use these entry points:

• Search — the search box at the top of Docker Docs is the quickest route to a command or instruction. Type the exact command name (for example, a docker run flag) rather than a vague phrase.
• CLI reference — every docker subcommand, its flags, and examples. This is your lookup table, not a tutorial.
• Dockerfile reference — every instruction with syntax and notes. Check here before guessing at an option.
• Compose file reference — when your app grows to multiple containers, this defines them in one file.
• API reference — for when you automate Docker from code instead of the terminal.
• Samples — full projects organized by language and use case. Cloning a sample and modifying it is often faster than starting from a blank file.

A practical habit: when a command fails, copy the exact error into search. The docs pages for commands and instructions usually include the conditions that produce common errors.

Guides vs. Reference: which one do you need right now?

This is the distinction that trips up most beginners, so make it explicit:

• Use a Guide when you are trying to accomplish a task and don't yet know the steps. Guides assume you want an outcome and lead you there.
• Use Reference when you already know the task and need the exact spelling, flag, or field. Reference assumes you know what you're doing and just need precision.

If you find yourself reading a long list of options and feeling lost, you're in Reference too early — go back to a Guide. If you're following a tutorial and it doesn't cover the specific option you need, that's your cue to switch to Reference for that one detail, then return.

A reusable checklist for containerizing any app

Keep this sequence handy for each new project:

1. Confirm Docker is installed and running.
2. Identify your app's language and framework, then open the matching Guide.
3. Write a minimal Dockerfile using only the instructions you need.
4. Build the image and fix any errors using the Dockerfile reference.
5. Run the container and verify the app responds.
6. Add a .dockerignore file so unnecessary files aren't copied into the image.
7. When you add a second service (a database, for example), move to the Compose file reference.
8. Save the commands that worked so you can repeat them next time.

Where to go after your first container

Once one app runs in a container, the natural next steps are multi-container setups with Compose, sharing images through a registry, and automating builds. Each of these has its own Guide and Reference area on Docker Docs, so the same pattern applies: read the Guide to learn the flow, then keep the Reference open for exact syntax.

The documentation is large, but you never need all of it at once. Install, do the Get Started tutorial, containerize your own app with a language guide, and look things up in Reference only when you need a precise answer. That path takes you from zero to a working container without detours.