---
title: Initial files
category: Creating your bot
---

# Initial files

Once you [add your bot to a server](preparations/adding-your-bot-to-servers.md), the next step is to start coding and get it online! Let's start by initializing your package.json, creating a config file for your client token, and a main file for your bot application.

## Creating package.json

This command creates a _`package.json`_ file for you, which will keep track of the dependencies your project uses, as well as other information.

<CH.Code>

```sh npm
npm init -y; npm pkg set type="module"
```

```sh yarn
yarn add dotenv
# You must go into your package.json file and add "type": "module"
```

```sh pnpm
pnpm init; pnpm pkg set type="module"
```

</CH.Code>

Once you're done with that, onto the next step!

## Using config.json

As explained in the ["What is a token, anyway?"](preparations/setting-up-a-bot-application.md#what-is-a-token-anyway) section, your token is essentially your bot's password, and you should protect it as best as possible. This can be done through a _`config.json`_ file or by using environment variables.

Open your application in the [Discord Developer Portal](https://discord.com/developers/applications) and go to the "Bot" page to copy your token.

Storing data in a _`config.json`_ file is a common way of keeping your sensitive values safe. Create a _`config.json`_ file in your project directory and paste in your token.

<CH.Code>

```json config.json
{
	"token": "your-token-goes-here"
}
```

</CH.Code>

You can then access your token inside other files by using _`import`_.

 <CH.Code>

```ts
import config from './config.json' assert { type: 'json' };

console.log(config.token);
```

</CH.Code>

<Alert title="Caution" type="danger">
	If you're using Git, you should not commit this file and should [ignore it via
	_`.gitignore`_](/creating-your-bot/#git-and-gitignore).
</Alert>

### Using environment variables

Environment variables are special values for your environment (e.g., terminal session, Docker container, or environment variable file). You can pass these values into your code's scope so that you can use them.

One way to pass in environment variables is via the command line interface. When starting your app, instead of _`node index.js`_, use _`TOKEN=your-token-goes-here node index.js`_. You can repeat this pattern to expose other values as well.

You can access the set values in your code via the _`process.env`_ global variable, accessible in any file. Note that values passed this way will always be strings and that you might need to parse them to a number, if using them to do calculations.

<CH.Code>

```shellscript Command line
A=123 B=456 DISCORD_TOKEN=your-token-goes-here node index.js
```

---

```js Usage
console.log(process.env.A);
console.log(process.env.B);
console.log(process.env.DISCORD_TOKEN);
```

</CH.Code>

#### Using dotenv

Another common approach is storing these values in a _`.env`_ file. This spares you from always copying your token into the command line. Each line in a _`.env`_ file should hold a _`KEY=value`_ pair.

You can use the [_`dotenv`_ package](https://www.npmjs.com/package/dotenv) for this. Once installed, preload the package to load your _`.env`_ file and attach the variables to _`process.env`_:

##### Installing dotenv

<CH.Code>

```sh npm
npm install dotenv
```

```sh yarn
yarn add dotenv
```

```sh pnpm
pnpm add dotenv
```

</CH.Code>

##### Defining your variables

<CH.Code>

```text .env
A=123
B=456
DISCORD_TOKEN=your-token-goes-here
```

</CH.Code>

<Alert title="Caution" type="danger">
	If you're using Git, you should not commit this file and should [ignore it via
	_`.gitignore`_](/creating-your-bot/#git-and-gitignore).
</Alert>

##### Utilizing your variables

<CH.Code>

```sh node
node --require dotenv/config yourFile.js
```

```sh yarn
yarn node --require dotenv/config yourFile.js
```

---

```ts yourFile
console.log(process.env.A); // 123
console.log(process.env.B); // 456
console.log(process.env.DISCORD_TOKEN); // your-token-goes-here
```

</CH.Code>

<Section title="Online editors (Glitch, Heroku, Replit, etc.)" defaultClosed padded background gutter>
While we generally do not recommend using online editors as hosting solutions, but rather invest in a proper virtual private server, these services do offer ways to keep your credentials safe as well! Please see the respective service's documentation and help articles for more information on how to keep sensitive values safe:

- Glitch: [Storing secrets in .env](https://glitch.happyfox.com/kb/article/18)
- Heroku: [Configuration variables](https://devcenter.heroku.com/articles/config-vars)
- Replit: [Secrets and environment variables](https://docs.replit.com/repls/secrets-environment-variables)

</Section>

### Git and .gitignore

Git is a fantastic tool to keep track of your code changes and allows you to upload progress to services like [GitHub](https://github.com/), [GitLab](https://about.gitlab.com/), or [Bitbucket](https://bitbucket.org/product). While this is super useful to share code with other developers, it also bears the risk of uploading your configuration files with sensitive values!

You can specify files that Git should ignore in its versioning systems with a _`.gitignore`_ file. Create a _`.gitignore`_ file in your project directory and add the names of the files and folders you want to ignore:

<CH.Code>

```
node_modules
.env
config.json
```

</CH.Code>

<Alert title="Tip" type="success">
	Aside from keeping credentials safe, _`node_modules`_ should be included here. Since this directory can be restored
	based on the entries in your _`package.json`_ and _`package-lock.json`_ files by running _`npm install`_, it does not
	need to be included in Git. You can specify quite intricate patterns in _`.gitignore`_ files, check out the [Git
	documentation on _`.gitignore`_](https://git-scm.com/docs/gitignore) for more information!
</Alert>

## Creating the main file

Open your code editor and create a new file. We suggest that you save the file as _`index.ts`_, or _`index.js`_, depending on whether you use TypeScript. You may name it whatever you wish, however.

Here's the base code to get you started:

<CH.Code>

```ts index.ts
// Import the necessary structures.
import { Client, Events, GatewayIntentBits } from 'discord.js';
import config from './config.json';

// Create a new client instance.
const client = new Client({ intents: GatewayIntentBits.Guilds });

// When the client is ready, run this code (only once).
client.once(Events.ClientReady, () => {
	console.log('Ready!');
});

// Log in to Discord with your client's token.
client.login(config.token);
```

</CH.Code>

This is how you create a client instance for your Discord bot and login to Discord. The _`GatewayIntentBits.Guilds`_ intents option is necessary for your client to work properly, as it ensures that the caches for guilds, channels and roles are populated and available for internal use.

Intents also define which events Discord should send to your bot, and you may wish to enable more than just the minimum. You can read more about the other intents on the [Intents topic](popular-topics/intents).

Open your terminal, compile your code (JavaScript users do not do this), and run _`node index.js`_ to start the process. If you see "Ready!" after a few seconds, you're good to go!

<Alert title="Tip" type="success">
	You can open your _`package.json`_ file and edit the _`"main": "index.js"`_ field to point to your main file. You can
	then run _`node .`_ in your terminal to start the process! After closing the process with <kbd>⌃ Control</kbd>{' '}
	<kbd>C</kbd>, you can press <kbd>↑</kbd> on your keyboard to bring up the latest commands you've run. Pressing{' '}
	<kbd>↑</kbd> then <kbd>⏎ Enter</kbd> after closing the process is a quick way to start it up again.
</Alert>

## Resulting code

<ResultingCode path="creating-your-bot/initial-files" />

Code is indeed a result of code. That being said, it's being worked on. With code. Definitely.
