# Table of Contents
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
- [Replit Docs](#replit-docs)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Getting Started
Introduction
Replit takes you from idea to app as fast as possible.
The platform provides all the tools you must create amazing applications from one browser tab—no installation required. Replit includes AI coding tools, real-time collaboration, and project sharing to give you a head start on your app creation journey.
[](#quickstart-guides)
Quickstart guides
--------------------------------------------
To create your app on Replit, choose the guide that matches your needs:
[Remix an existing app\
---------------------\
\
⏱️ _1 minute_\
\
Jump-start your project by building on community-contributed apps.](/getting-started/quickstarts/remix-an-app)
[Ask AI\
------\
\
⏱️ _7 minutes_\
\
Use the AI-powered Replit tools to create, explain, and debug your app.](/getting-started/quickstarts/ask-ai)
[Build from Scratch\
------------------\
\
⏱️ _15 minutes_\
\
Create a full-stack app with complete control.](/getting-started/quickstarts/from-scratch)
[Import from GitHub\
------------------\
\
⏱️ _2 minutes_\
\
Import an existing GitHub repository into Replit.](/getting-started/quickstarts/import-from-github)
You can also create an app from an existing GitHub repository. For instructions, see [Import a GitHub repository](/replit-workspace/using-git-on-replit/import-repository)
.
[](#what-is-replit)
What is Replit
--------------------------------------
Replit is an AI-powered platform that lets you create and deploy apps from a single browser tab. The platform eliminates the complexity of traditional app-creation environments by combining coding, deployment, and collaboration tools in a single interface.
Typically, you must install programs, languages, and packages to build apps. However, on Replit, you can rely on AI to configure your environment so you can start building without coding experience.
The platform supports full-featured development and coding environments for those familiar with coding, so there’s no limit on what’s possible.
###
[](#workspace-features)
Workspace features
Replit provides the following essential app creation tools:
* [Real-time preview](/replit-workspace/workspace-features/webview)
of your app
* [Deploy in minutes](/category/replit-deployments)
* Browser native app that requires zero installation and configuration
* [Full-featured code editor](/replit-workspace/introduction-to-workspace)
* [Mobile app](/platforms/mobile-app)
for building apps from your phone or tablet
* [AI-assisted app creation](/replitai/agent)
* [Version control integration](/replit-workspace/using-git-on-replit)
for tracking changes
* [Collaborative building](/teams/collaboration-on-replit)
over the network
###
[](#ai-companion-capabilities)
AI companion capabilities
Replit AI [Agent](/replitai/agent)
and [Assistant](/replitai/assistant)
accelerate app creation with the following capabilities:
* Complete app generation and setup from natural language descriptions
* Code suggestions and autocomplete
* Automated error detection and debugging assistance
* Documentation generation for your app
###
[](#share-in-minutes)
Share in minutes
Deploy your apps in minutes using the following tools:
* App deployment to the cloud in a few clicks
* Database integration and hosting
* Custom domain support and connection encryption for your applications
[](#additional-information)
Additional information
------------------------------------------------------
To learn more about all of Replit’s features, see the following resources:
* Learn about the workspace features from [Introduction to the Workspace](/replit-workspace/introduction-to-workspace)
.
* Learn about the capabilities of the Replit AI-powered features from [Replit Agent](/replitai/agent)
and [Replit Assistant](/replitai/assistant)
.
* Learn how to share your creations from [Sharing Your Replit App](/replit-app/collaborate)
.
* [Download the mobile app](https://replit.com/mobile/)
for iOS or Android devices.
Was this page helpful?
YesNo
[RemixLearn how to create a \*\*Remix\*\* as a starting point for your app. A Remix is a Replit App started from a publicly shared Replit App.\
\
Next](/getting-started/quickstarts/remix-an-app)
On this page
* [Quickstart guides](#quickstart-guides)
* [What is Replit](#what-is-replit)
* [Workspace features](#workspace-features)
* [AI companion capabilities](#ai-companion-capabilities)
* [Share in minutes](#share-in-minutes)
* [Additional information](#additional-information)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Apps
Collaboration
There are a few ways to share your Replit App, we’ll cover them here.
[](#collaborate-in-real-time-join-links)
Collaborate in real time (Join Links)
----------------------------------------------------------------------------------
* Join links **grant edit access** to your Replit App, so be careful who you share them with.
* Join links **share secrets** stored in the “Secrets” pane. For sharing a Replit App as you would a Repo or other code, take a look at [making your Replit App public.](/_sites/docs.replit.com/replit-app/collaborate#make-your-repl-public)
To collaborate with your friends on your Replit App, you can create a Join Link. Join Links create a unique URL that you can share with others. When they click the link, they’ll be taken to your Replit App and can start coding with you in real time.
Join Links are **private** by default, so only people with the link can access your Replit App.
If you accidentally share your link with someone you didn’t mean to, you can always regenerate a new one. to create a new join link, click the “Invite” button in the top right corner of your Replit App.
Simply toggle the Join Link to “On” and copy the resulting URL. When your friends with an active Replit account navigate to that URL, they’ll be able to edit your Replit App in real time.
You’ll also receive a notification when someone joins your Replit App.
[](#make-your-replit-app-public)
Make your Replit App Public
----------------------------------------------------------------
Making your Replit App public _will not_ expose any secrets you’ve saved in the “Secrets” pane. _However_, it will expose any code you’ve written, so be careful about sharing sensitive information.
Head over to your Replit App and click the name in the top left corner. This will open up the settings for your Replit App.
Now, you can toggle the Replit App to be public or private.
Making your Replit App public will allow anyone to view your code and run your project. It creates a unique URL that you can share with anyone, like this: [https://replit.com/@replit/Python?v=1](https://replit.com/@replit/Python?v=1)
.
###
[](#create-a-template)
Create a template
After you’ve made your Replit App visible, you should consider turning it into a **[template](https://replit.com/templates)
**.
Creating a template makes it easy for others to start their own project based on your code. It will improve the discoverability of your Replit App and surface it on pages like [https://replit.com/templates](https://replit.com/templates)
.
To lean more about templates and create your own, you can read more [here](/replit-workspace/templates)
.
Was this page helpful?
YesNo
[Previous](/category/replit-apps)
[VisibilityLearn how to create and manage private Replit Apps with a Core membership or Teams Pro account. Control access to your projects with privacy settings.\
\
Next](/replit-app/visibility)
On this page
* [Collaborate in real time (Join Links)](#collaborate-in-real-time-join-links)
* [Make your Replit App Public](#make-your-replit-app-public)
* [Create a template](#create-a-template)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
April 2025
April 4, 2025
[### Matt Palmer\
\
Head of Developer Relations](https://x.com/mattppal)
[](#what%E2%80%99s-new)
What’s new
--------------------------------------
* [Lucide icon improvements](/_sites/docs.replit.com/updates/2025/04/04/changelog#better-icons)
* [Assistant performance improvements](/_sites/docs.replit.com/updates/2025/04/04/changelog#assistant-performance-improvements)
* [Agent reliability improvements](/_sites/docs.replit.com/updates/2025/04/04/changelog#agent-reliability-improvements)
* [3D model generation milestone](/_sites/docs.replit.com/updates/2025/04/04/changelog#3d-model-generation-milestone)
###
[](#better-icons)
Better icons
Agent now matches phrases to icons better than before. You’ll notice improved icon usage in your apps!
###
[](#assistant-performance-improvements)
Assistant performance improvements
Recent performance improvements to Assistant have received positive feedback from customers and users. The enhanced performance creates a smoother experience for all Assistant users. These improvements are separate from Agent context gathering but may influence future optimizations.
###
[](#agent-reliability-improvements)
Agent reliability improvements
Several fixes are rolling out to enhance Agent reliability. These include reducing breaking changes, resolving crashes in problematic nix environments, and fixing issues with the bash tool execution.
###
[](#3d-model-generation-milestone)
3D model generation milestone
Agent users are now generating 1,500 3D models every day—a significant milestone for the 3D generation capabilities.
Was this page helpful?
YesNo
[March 28, 20252 min read\
\
Next](/updates/2025/03/28/changelog)
On this page
* [What’s new](#what%E2%80%99s-new)
* [Better icons](#better-icons)
* [Assistant performance improvements](#assistant-performance-improvements)
* [Agent reliability improvements](#agent-reliability-improvements)
* [3D model generation milestone](#3d-model-generation-milestone)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Apps
Replit Apps
[](#what-is-a-replit-app%3F)
What is a Replit App?
------------------------------------------------------
Replit Apps are cloud-hosted projects that contain code, data, and assets. You can create, run, and deploy them from a secure, isolated environment.
Replit Apps integrate with the following tools in your Replit workspace to provide a seamless development experience:
* **AI-powered tools**: Use Agent and Assistant to create, debug, and explain your code.
* **Collaboration**: Work with others in real time on the same app.
* **Deployment**: Deploy your app to the cloud with a single click.
* **Templates**: Start your app quickly using preset configurations for various use cases.
**Replit App** is the new product name for **Repl**. To learn more about the renaming, see [Repls are now Replit Apps](https://blog.replit.com/replit-apps)
.
[](#getting-started)
Getting started
----------------------------------------
For step-by-step instructions on creating Replit Apps, see the following Quickstart guides:
* [Remix an App](getting-started/quickstarts/remix-an-app)
* [Create with AI](/getting-started/quickstarts/ask-ai)
* [Build from Scratch](/getting-started/quickstarts/from-scratch)
To open a Replit App, log into Replit and open it in your workspace using one of the following methods.
Create a new Replit App
1. Select  **Create App**. You should see the following screen:
2. Select one of the following options:
* **Create with Replit Agent**: Use AI-powered tools to create a new Replit App.
* **Choose a Template**: Create a new Replit App based on an existing one.
* **Import from GitHub**: Create a new Replit App from a GitHub repository.
3. Complete the dialog prompts to start a new Replit App.
Open an existing Replit App
To access a Replit App you created previously, select  **Apps** from the left sidebar.
[](#key-features)
Key features
----------------------------------
Replit Apps offer the following features:
* **Zero-setup:** Create apps or write code directly on Replit.com without any installs or configuration.
* **Auto-save:** Your project continuously saves changes to the cloud and lets you resume coding from any web browser
* **Version Control:** Track changes, explore file history, and sync your files without any configuration, through Replit’s version control systems
* **Public/Private Visibility Controls:** Control who can view, run, or create a Remix of your app with privacy settings
* **Deployments:** Deploy your code to the cloud without making any complex configuration changes
* **Custom App URLs:** Get a unique URL for your app or assign a custom domain for a professional presence
To learn more about Workspace tools that streamline Replit App creation, see [Workspace Overview](/category/replit-workspace)
.
[](#how-it-works)
How it works
----------------------------------
When you create a Replit App, Replit sets up a private space for your project in the cloud. As you add features and modifications to your app, Replit saves your changes automatically so you can resume editing from any web browser.
Replit provides pre-configured environments with all the necessary components. This lets you start creating your app immediately without worrying about server configuration, database setup, or environment management.
Replit automatically assigns each Replit App a unique web address where you can preview your app while you’re working on it. When you’re ready to share your creation, you can deploy it with just a few clicks to make it available 24/7.
[](#use-cases)
Use cases
----------------------------
The following examples showcase how you can use Replit Apps to accelerate your app creation process.
###
[](#explore-something-new)
Explore something new
Select a template to start coding in a specific programming language or software stack.
###
[](#create-and-test-apis)
Create and test APIs
Build an API with RESTful endpoints and use workspace tools to test them before going live.
[](#next-steps)
Next steps
------------------------------
To learn more about Replit Apps, see the following resources:
* [Templates](https://www.replit.com/templates/)
: explore starter project setups to give you a head start
* [Deployment](/category/replit-deployments)
: learn which deployment option works best for your Replit App
* [Custom Domains](cloud-services/deployments/custom-domains#custom-domains-with-deployments)
: Set your domain to link to your Replit App
* [Storage and Databases](/category/storage-and-databases)
: Discover your storage options
Was this page helpful?
YesNo
[Previous](/getting-started/quickstarts/import-from-github)
[CollaborationOne of the great parts about Replit is that \_everything\_ you make can be shared with the world. Since your code is hosted in the cloud, it's as simple as one click!\
\
Next](/replit-app/collaborate)
On this page
* [What is a Replit App?](#what-is-a-replit-app%3F)
* [Getting started](#getting-started)
* [Key features](#key-features)
* [How it works](#how-it-works)
* [Use cases](#use-cases)
* [Explore something new](#explore-something-new)
* [Create and test APIs](#create-and-test-apis)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Apps
Replit App Visibility
With a free Replit account, personal Replit App are public by default.
As an individual, you can make your Replit App private by subscribing to our [Replit Core membership](https://replit.com/pricing)
(previously Hacker or Pro) that comes with unlimited private Replit App.
Teams Pro accounts come with the ability to make any Team Replit App private.
Private Replit App can only be accessed by directly invited guests or by team members.
[](#creating-a-private-replit-app)
Creating a private Replit App
--------------------------------------------------------------------
You can make a Replit App private by toggling the Replit App to Private when you’re making a new Replit App from a Template or forking an existing Replit App.
[](#making-an-existing-replit-app-private)
Making an existing Replit App private
------------------------------------------------------------------------------------
###
[](#from-the-workspace)
From the Workspace
You can make any public Replit App private by toggling it on from the Workspace.
1. Navigate to your Replit App
2. Open the info panel by clicking on your Replit App’s name in the navbar
3. Make your Replit App private by pressing the Private toggle
###
[](#from-the-my-replit-app-page)
From the My Replit App page
You can also make any of your public Replit App private from the My Replit App page.
1. Navigate to the My Replit App page from the left sidebar
2. Hover over the “Public” copy on the card of the Replit App you want to make private
3. Press the “Make private” button
Was this page helpful?
YesNo
[Previous](/replit-app/collaborate)
[Advanced ConfigurationLearn how to configure your Replit App using .replit and replit.nix files to manage dependencies, run commands, environment variables, and deployment settings.\
\
Next](/replit-app/configuration)
On this page
* [Creating a private Replit App](#creating-a-private-replit-app)
* [Making an existing Replit App private](#making-an-existing-replit-app-private)
* [From the Workspace](#from-the-workspace)
* [From the My Replit App page](#from-the-my-replit-app-page)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Apps
Replit App Configuration
Replit App are configured with two files: the `.replit` and `replit.nix`. They affect how your Replit App behaves, from code execution to development tools and languages.
These configuration files are hidden by default. Show them in your Replit App by selecting “Show hidden files” from the filetree menu.
[](#replit-nix-file)
`replit.nix` file
------------------------------------------
Replit uses `Nix` to manage packages and environments. The `replit.nix` file is used for:
**Specifying system dependencies:** Define exactly what software packages your Replit App requires, managed through Nix, a package manager.
**Creating reproducible environments:** Ensure your development environment is consistent and reproducible, ideal for collaborative projects and testing across multiple systems.
You can manage Nix packages visually through the `Dependencies` tool. Learn more in the [System Dependencies](/replit-workspace/dependency-management#system-dependencies)
guide.
To configure packages with the `replit.nix` file, you can list [Nix packages](https://search.nixos.org/packages)
in the `deps` array, prefixed with `pkgs.`. Any changes will be synced after your shell is reloaded.
{ pkgs }: {
deps = [\
pkgs.nodejs-19_x\
pkgs.nodePackages.typescript-language-server\
pkgs.yarn\
pkgs.replitPackages.jest\
];
}
[](#replit-file)
`.replit` file
-----------------------------------
The `.replit` file controls your Replit App’s behavior. It uses the `toml` [configuration format](https://toml.io/en/)
. Here are some of the key aspects that can be configured:
**Run command:** Specify the command that executes when the Run button is selected. Each template has a default run command to allow code execution immediately. For more customized and complex apps, use [Workflows](../replit-workspace/workflows.md)
.
**Language Server Protocol (LSP)**: Provides features like auto-complete, code navigation, code highlighting, and real-time linting and errors.
**Environment variables:** Set and manage environment variables essential for your applications to run correctly.
**Dependencies and packages:** Manage package installations and configurations directly through the `.replit` file, ensuring your Replit App has all the necessary tools ready upon startup. You can manage dependencies visually through the `Dependencies` tool. Learn more in the [System Modules](../replit-workspace//dependency-management.md#advanced-configuration)
guide.
For Python applications, the default `.replit` file looks like:
entrypoint = "main.py"
modules = ["python-3.10:v18-20230807-322e88b"]
[nix]
channel = "stable-23_05"
[unitTest]
language = "python3"
[gitHubImport]
requiredFiles = [".replit", "replit.nix"]
[deployment]
run = ["python3", "main.py"]
deploymentTarget = "cloudrun"
The following table provides a view of each setting within the `.replit` file, explaining what each configuration does and its impact on the Replit App environment.
| **Configuration key** | **Value/Example** | **Description** |
| --- | --- | --- |
| `entrypoint` | `main.py` | Specifies the main file to be executed and displayed by default when the editor is opened. You can rename the file name based on your application. |
| `modules` | `["python-3.10:v18-20230807-322e88b"]` | Defines specific versions of programming languages or other major dependencies supported by Replit. |
| `[nix]` | | Specifies settings for using Nix, a package manager, to manage system dependencies. Refer to [Dependency Management](/replit-workspace/dependency-management) document for more information. |
| `channel` | `stable-23_05` | Indicates the Nix channel to use, which affects the versions of system dependencies available. |
| `[unitTest]` | | Configures settings related to unit testing within the Replit App. |
| `language` | `python3` | Specifies the language used for unit testing, indicating that Python 3 is used for writing tests. |
| `[gitHubImport]` | | Settings that affect how projects are imported from GitHub, specifically which files must be included. |
| `requiredFiles` | `[".replit", "replit.nix"]` | Lists the files that must be present when importing the project to ensure it functions correctly. |
| `[deployment]` | | Contains settings for deploying the application from the Replit App to a live environment. |
| `run` | `["python3", "main.py"]` | Command executed to start the application during deployment. |
| `deploymentTarget` | `cloudrun` | Specifies the deployment target platform for hosting the application. |
Now that you have an idea of the default configurations of the `.replit` file use the next sections to understand how to configure basic and advanced settings for your Replit App.
[](#configuring-basic-settings)
Configuring basic settings
--------------------------------------------------------------
###
[](#entrypoint)
Entrypoint
This is the main file of your project. If you do not define a `run` property, `entrypoint` is the file that gets executed by the runtime.
entrypoint = ".py"
###
[](#run-command)
`Run` command
The `run` property in the `.replit` file is a key feature that determines the initial command or series of commands executed when the `Run` button is selected in a Replit environment. The `Run` command can be specified either as a string representing the command to execute, or an array of strings representing the command and individual arguments to that command.
Some common ways to configure the `Run` command:
* **Single command:** This example shows how to pass single command to execute directly in the Replit App. With this in your `.replit` file, pressing the `Run` button will display a greeting in the `Console` pane: **Example:** `run = "echo 'Hello, Replit!'"`
* **Explicit arguments:** In some situations it may be beneficial to be more explicit, avoiding the need for parsing quotes or shell interpolation rules. We can rewrite the above example to separate the arguments. Note, we no longer need both `'` and `"`, since we are explicitly passing the greeting as the first and only argument to `echo`: **Example:** `run = ["echo", "Hello, Replit!"]`
* **Multiple commands:** This example shows how to run multiple processes, such as a frontend and a backend, simultaneously. This could be useful if developing a python backend and a typescript frontend, where each server binds to a different port: **Example:** `run = "python -m app & npm run start & wait"`
####
[](#process-management)
Process management
While multiple commands can be simultaneously run with `&`, you may want a better experience distinguishing logs between services. You can [add system dependencies](/replit-workspace/dependency-management#system-dependencies)
like [`process-compose`](https://github.com/F1bonacc1/process-compose)
to better orchestrate multiple processes.
####
[](#build-phase)
`Build` phase
For some languages or runtimes, there is a separate compilation phase before code can be `run`. This covers both compiled languages like TypeScript, Golang, or Java, or offering a parameter you can use to reset your environment, data, or configuration before the next `run` is invoked.
* **Compiling:** In a TypeScript repository, you may find yourself needing to run `tsc` prior to executing your code. **Example:**
build = "tsc app.ts"
run = "node app.js"
####
[](#including-environment-variables)
Including environment variables
To supply environment variables to your service before execution, you can expand the `run` property into a [table](https://toml.io/en/v1.0.0#table)
.
This is a more involved change, and likely requires moving where your `run = "..."` property is located inside your `.replit` file.
The following diff shows supplying the command by way of `[run]`’s `args`, as well as the variable `NAME` supplied in `[run.env]`:
-run = ["bash", "-c", "echo \"Hello, $NAME!\""]
modules = ["nodejs-20"]
hidden = [".pythonlibs"]
+# We need to move our new [run] down past all the
+# top-level properties that do not start with a `[`!\
+[run]\
+args = ["bash", "-c", "echo \"Hello, $NAME!\""]\
+\
+[run.env]\
+NAME="Replit"\
\
[nix]\
channel = "stable-23_11"\
\
\
#### \
\
[](#interactivity)\
\
Interactivity\
\
Interactive programs can also be launched by way of the `Run` button, offering a way to distinguish your development environment from the terminal where your program is running. Consider the following tally script:\
\
**Example**\
\
[run]\
args = ["bash", "-c", """\
count=0\
while read -p "$PROMPT" -r next && [ -n "$next" ]; do\
count=$((count+next))\
done\
echo "The numbers you entered sum to $count!"\
"""]\
\
[run.env]\
PROMPT = "Next number ([Enter] to end): "\
\
\
[](#advanced-configuration-options)\
\
Advanced configuration options\
----------------------------------------------------------------------\
\
Explore the detailed configuration options available for your Replit App. You can customize your development environment, manage run commands, integrate language services, and handle dependencies.\
\
| **Configuration** | **Key** | **Value/Example** | **Description** |\
| --- | --- | --- | --- |\
| onBoot | `onBoot` | `onBoot = "npm install"` | Command that executes when the Replit App boots up. |\
| compile | `compile` | (No default example) | Command that runs before the `run` command, used in compiled languages like C++. |\
| language | `language` | `language = "javascript"` | Specifies the language during a GitHub import or when creating a Replit App. |\
| entrypoint | `entrypoint` | `entrypoint = "index.js"` | Main file to run and display when opening the editor. |\
| hidden | `hidden` | `hidden = [".config", "package-lock.json"]` | Files or folders to hide by default in the side file tree. |\
| audio | `audio` | `audio = true` | Enables System-Wide Audio when set to `true`. |\
\
### \
\
[](#notes-about-system-wide-audio)\
\
Notes about System-Wide Audio\
\
When setting `audio = true` in your `.replit` file, you may need to run `kill 1` in a shell to force the new setting to take effect.\
\
When running a graphical application, you will see a pair of headphones with a checkbox in the lower right of the `Output` pane. Due to browser restrictions, this will need to be enabled every time you refresh.\
\
# Ensure this is at the top of your `.replit` file, outside of any `[`-bracketed section\
audio = true\
\
\
[](#packager-configuration)\
\
Packager configuration\
------------------------------------------------------\
\
| **Configuration** | **Key** | **Value/Example** | **Description** |\
| --- | --- | --- | --- |\
| packager | `language` | `packager.language = "python3"` | Language used for package operations. |\
| packager features | `guessImports` | `packager.features.guessImports = true` | Automatically guess packages to install prior to running the Replit App. |\
| packager features | `packageSearch` | `packager.features.packageSearch = true` | Enables support for the packager when set to `true`. |\
| packager features | `enabledForHosting` | `packager.features.enabledForHosting = false` | Sets whether hosting the Replit App requires running a package installation. |\
| packager | `afterInstall` | `afterInstall = "echo 'package installed'"` | Command executed after a new package is installed via the packager. |\
| packager | `ignoredPaths` | `ignoredPaths = [".git"]` | Paths to ignore while attempting to guess packages. |\
| packager | `ignoredPackages` | `ignoredPackages = ["twitter", "discord"]` | Modules should never attempt to guess a package during installation. |\
\
### \
\
[](#example-replit-configuration-for-packager-configuration)\
\
Example `.replit` configuration for packager configuration\
\
# Define the language for the Replit App\
packager.language = "python3"\
\
# Enable features for automatic package management\
[packager.features]\
guessImports = true\
packageSearch = true\
enabledForHosting = false\
\
# Command to run after each package installation\
packager.afterInstall = "echo 'Package installed successfully'"\
\
# Define paths and packages that should be ignored by the package manager\
packager.ignoredPaths = [".git", "node_modules"]\
packager.ignoredPackages = ["twitter", "discord"]\
\
# Additional deployment settings\
[deployment]\
run = ["python3", "app.py"]\
\
\
[](#deployment-configuration)\
\
Deployment configuration\
----------------------------------------------------------\
\
| **Configuration** | **Key** | **Value/Example** | **Description** |\
| --- | --- | --- | --- |\
| deployment | `run` | `deployment.run = "npm start"` | Command that executes when a Deployment container starts. |\
| deployment | `build` | `deployment.build = "npm run build"` | Command that executes before running a Deployment. |\
| deployment | `ignorePorts` | `deployment.ignorePorts = true` | If `true`, deployment success doesn’t require an open port check. |\
\
### \
\
[](#example-replit-configuration-for-deployment-configuration)\
\
Example `.replit` configuration for deployment configuration\
\
\
# Specifies the main entry point for the project\
entrypoint = "app.js"\
\
# Configuration settings for deploying the application\
[deployment]\
run = "npm start"\
build = "npm run build"\
ignorePorts = true\
\
\
**Interpreter configuration** has been deprecated and is no longer available in Replit. Instead, you are encouraged to use the `Run` commands to configure how scripts and applications are executed within your Replit App environment.\
\
[](#networking-and-extensions)\
\
Networking and extensions\
------------------------------------------------------------\
\
| **Configuration** | **Key** | **Value/Example** | **Description** |\
| --- | --- | --- | --- |\
| ports | `localPort` | `localPort = 3000` | Port that Replit binds to an external port. |\
| ports | `externalPort` | `externalPort = 80` | Publicly accessible port linked to the `localPort`. |\
| extension | `isExtension` | `isExtension = true` | Specifies whether a Replit App is a workspace extension. |\
| extension | `extensionID` | `extensionID = "492a5fcd-f090-4356-ace8-50755e8deb2b"` | Determines if a Replit App is attached to a specific extension. Automatically filled when publishing a new extension. |\
| extension | `buildCommand` | `buildCommand = "npm run build"` | Command to bundle the extension into a static directory for uploading. |\
| extension | `outputDirectory` | `outputDirectory = "./dist"` | Path to the static directory used to render the Extension relative to the Replit App’s root directory. |\
\
### \
\
[](#example-replit-configuration-file-for-managing-networking-and-extensions)\
\
Example `.replit` configuration file for managing networking and extensions\
\
# Networking configuration to expose your application on specific ports\
[[ports]]\
localPort = 3000\
externalPort = 80\
\
# Extension settings to define and manage a workspace extension\
[extension]\
isExtension = true\
extensionID = "492a5fcd-f090-4356-ace8-50755e8deb2b"\
buildCommand = "npm run build"\
outputDirectory = "./dist"\
\
\
[](#accessing-replit-app-environment-metadata)\
\
Accessing Replit App environment metadata\
--------------------------------------------------------------------------------------------\
\
### \
\
[](#node-js)\
\
Node.js\
\
To access all environment variables:\
\
`console.log(process.env);`\
\
To access a single variable (REPL\_SLUG):\
\
`console.log(process.env.REPL_SLUG);`\
\
### \
\
[](#python)\
\
Python\
\
To access all environment variables:\
\
import os\
print(os.environ)\
\
\
To access a single variable (REPL\_SLUG):\
\
import os\
variable = os.environ.get('REPL_SLUG')\
print(variable)\
\
\
### \
\
[](#rust)\
\
Rust\
\
To access all environment variables:\
\
use std::env;\
fn main() {\
for (key, value) in env::vars() {\
println!("{}: {}", key, value);\
}\
}\
\
\
To access a single variable (REPL\_SLUG):\
\
use std::env;\
fn main() {\
let variable = env::var("REPL_SLUG").unwrap();\
println!("{}", variable);\
}\
\
\
[](#environment-variables)\
\
Environment variables\
----------------------------------------------------\
\
Following are the environment variables accessible from within your Replit App:\
\
| key | description |\
| --- | --- |\
| `REPL_OWNER` | The username of the owner of the Replit App. If your Replit App is text-based and has no webserver, `REPL_OWNER` will reflect the value of the current user accessing the Replit App |\
| `REPLIT_DB_URL` | The URL of your key-value Replit database |\
| `REPL_ID` | The unique UUID string of your Replit App |\
| `HOME` | The home path of your Replit App |\
| `system` | The operating system running on your Replit App |\
| `LANG` | Sets the language and character encoding for your Replit App, affecting how text is processed and displayed |\
| `REPL_IMAGE` | The docker image that corresponds to your Replit App |\
| `REPL_LANGUAGE` | The programming language configured for your Replit App, used to determine the runtime environment and tooling |\
| `REPL_PUBKEYS` | A stringified JSON object containing different public API keys |\
| `REPL_SLUG` | A simplified, machine-readable version of the name of the Replit App, suitable for use in URLs and file names |\
| `PRYBAR_FILE` | The main/entrypoint file of your Replit App |\
| `REPLIT_DEV_DOMAIN` | Provides the `replit.dev` URL for your Replit App in the Workspace. Note that this environment variable is not available in Deployments |\
\
Was this page helpful?\
\
YesNo\
\
[Previous](/replit-app/visibility)\
[App EmbedEmbedding a Replit App in your website or documentation allows you to display a read-only view of your code, meaning viewers can see but not edit the code. This feature is particularly useful for showcasing examples, tutorials, or code snippets directly within your content.\
\
Next](/replit-app/app-embed)\
\
On this page\
\
* [replit.nix file](#replit-nix-file)\
\
* [.replit file](#replit-file)\
\
* [Configuring basic settings](#configuring-basic-settings)\
\
* [Entrypoint](#entrypoint)\
\
* [Run command](#run-command)\
\
* [Process management](#process-management)\
\
* [Build phase](#build-phase)\
\
* [Including environment variables](#including-environment-variables)\
\
* [Interactivity](#interactivity)\
\
* [Advanced configuration options](#advanced-configuration-options)\
\
* [Notes about System-Wide Audio](#notes-about-system-wide-audio)\
\
* [Packager configuration](#packager-configuration)\
\
* [Example .replit configuration for packager configuration](#example-replit-configuration-for-packager-configuration)\
\
* [Deployment configuration](#deployment-configuration)\
\
* [Example .replit configuration for deployment configuration](#example-replit-configuration-for-deployment-configuration)\
\
* [Networking and extensions](#networking-and-extensions)\
\
* [Example .replit configuration file for managing networking and extensions](#example-replit-configuration-file-for-managing-networking-and-extensions)\
\
* [Accessing Replit App environment metadata](#accessing-replit-app-environment-metadata)\
\
* [Node.js](#node-js)\
\
* [Python](#python)\
\
* [Rust](#rust)\
\
* [Environment variables](#environment-variables)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Apps
Replit App Embed
###
[](#running-and-deploying)
Running and deploying
To interact with the Replit App, such as running the code and seeing its output, users must fork it. Forking creates a personal copy of the Replit App in their workspace, where they can run and edit the code. For a more integrated experience, you can deploy your Replit App and use an iframe to embed the deployed application from `replit.app` directly into your site.
###
[](#how-to-embed-a-replit-app)
How to embed a Replit App
To embed a public Replit App, append the `?embed=true` query parameter to the Replit App’s URL. This modification converts the URL into an embeddable link. Below is an example demonstrating how to embed a Replit App using an iframe in HTML:
Replace `YOUR Replit App LINK` with the actual link to your Replit App, for example, `https://replit.com/@user/repl-name.`
Here’s an example of an embedded Replit App:
###
[](#customizing-the-theme)
Customizing the theme
You can customize the appearance of the embedded Replit App by setting the theme. Add theme=light or theme=dark at the end of the URL to choose between a light or dark theme. For instance, to embed a Replit App with a light theme:
Example with a light theme:
Was this page helpful?
YesNo
[Previous](/replit-app/configuration)
[OverviewReplit's AI-powered tools help you code faster, solve problems more efficiently, and deliver production-ready apps.\
\
Next](/category/replit-ai)
On this page
* [Running and deploying](#running-and-deploying)
* [How to embed a Replit App](#how-to-embed-a-replit-app)
* [Customizing the theme](#customizing-the-theme)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit AI
Replit AI
Replit AI enables you to accomplish the following tasks:
* Transform a text description into an e-commerce app without prior coding experience.
* Learn what a section of code does by asking AI to explain it.
* Accelerate onboarding by providing contextual answers to questions about your codebase.
[](#what-is-replit-ai)
What is Replit AI
--------------------------------------------
Replit AI is the set of artificial intelligence capabilities integrated with the Replit workspace. Use Replit AI to create and customize apps to match your needs using natural language prompts.
Replit AI includes these powerful services:
Agent
-----
Specializes in generating new projects and building complex features.
Assistant
---------
Specializes in describing your code, making quick fixes, and adding new features.
Learn more about Agent and Assistant in the following video:
[](#getting-started)
Getting started
----------------------------------------
The quickest way to start using the Replit’s AI-powered tools is to follow the [Create with AI](/getting-started/quickstarts/ask-ai)
Quickstart to build an app.
Agent and Advanced Assistant are premium features that charge your Replit account based on usage. For pricing information and billing policies, see [Replit AI Billing](/billing/ai-billing)
.
Alternatively, open either Agent or Assistant by following:
* Open an existing Replit App
* Select the  magnifying glass at the top to open the search tool
* Scroll to the **Tools** section or enter **Agent** or **Assistant** in the input area.
Agent is only available in Replit Apps created using Agent. For more information, see [Replit Agent on existing Replit App](/replitai/agent#replit-agent-on-existing-replit-app)
.
###
[](#key-features)
Key features
Replit AI offers the following powerful development features:
* Complete app and feature generation from natural language descriptions
* Intelligent code completion to write error-free code faster
* Interactive AI chat for help on topics including code explanation, debugging, idea generation, and database design
[](#use-cases)
Use cases
----------------------------
The following examples showcase how Replit AI can transform your ideas into apps.
###
[](#improve-selected-code-using-assistant)
Improve selected code using Assistant
Select lines of code within a file and ask Assistant to explain what it accomplishes.
###
[](#add-a-complex-api-integration-using-agent)
Add a complex API integration using Agent
Add a Stripe payment processor integration to your web app to accept payments. Learn more about this topic in the following video:
[](#next-steps)
Next steps
------------------------------
To learn more about Replit’s AI-powered features, see the following resources:
* Learn more about Replit Agent and usage pricing in [Replit Agent](/replitai/agent)
* Learn more about Replit Assistant and usage pricing in [Replit Assistant](/replitai/assistant)
Was this page helpful?
YesNo
[Previous](/replit-app/app-embed)
[Replit AgentReplit Agent uses AI to set up and create apps from scratch. Describe your app in everyday language, and it can set up and create your Replit App in minutes.\
\
Next](/replitai/agent)
On this page
* [What is Replit AI](#what-is-replit-ai)
* [Getting started](#getting-started)
* [Key features](#key-features)
* [Use cases](#use-cases)
* [Improve selected code using Assistant](#improve-selected-code-using-assistant)
* [Add a complex API integration using Agent](#add-a-complex-api-integration-using-agent)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit AI
Replit Agent
Agent uses powerful AI technology to transform your ideas into applications and seamlessly add new features by describing what you want.
**Agent v2**, now in early access preview, offers the following improvements:
* Improved ability to identify necessary changes before making them
* Less likely to get stuck in a loop when addressing a bug
* Improved process for creating high-quality user interfaces, including displaying previews at an earlier stage
To use Agent v2, you must be a Core or Teams user and enable the Explorer role in your [Account settings](https://replit.com/account#roles)
.
[](#features)
Features
--------------------------
Agent uses several industry-leading AI models to create your apps. The core technology uses the following models:
* **Agent v1**:
* **Agent v2**:
Chat with Agent in your Replit App to receive the following support:
* Create full-stack apps from scratch
* Add advanced features and integrate complex APIs
* Design, create, and modify database structures
* Streamline environment setup and dependency management
[](#usage)
Usage
--------------------
Agent is available only in Replit Apps created from an Agent prompt.
You can access Agent in your Replit App workspace by selecting the Agent tool.
How to access Agent
From the **Create a new App** screen, select the **Replit Agent** tab to enter a description of the app you want as shown in the following animation:
If viewing a Replit App started by Agent, you can locate the Agent tool in your workspace in one of the following locations:
From the left tool dock, select  **Agent** as shown in the following animation:
From the **Search bar**:
1. Select the  magnifying glass at the top to open the search tool
2. Type “Agent” to locate the Agent tool and select it from the results
From the Agent tool, you can perform the following actions:
* **Chat**: Describe your app or feature in the text area and respond to Agent’s follow-up questions
* **Add detailed requests**: Upload files or import content from URLs to give Agent more information
* **Manage conversations**: Select **New chat** or select previous conversations from the  menu icon to start or resume a conversation
* **Track usage**: Select the  usage icon at the top right to view your billing page
* **Reverse changes**: Undo changes made by Agent by selecting  **Rollback to here**
###
[](#chat-prompts)
Chat prompts
To communicate your request to Agent, enter a **prompt** in the text area. A prompt is a natural language instruction that describes the task you want Agent to perform.
In addition to text, you can include the following data in your prompt:
* **File attachments**: Drag a file into the text area or select the  paperclip icon
* **Web content**: Include text data from a webpage by entering a URL and selecting **Copy page content**
* **Webpage screenshots**: Include a screenshot of a webpage by entering a URL and selecting **Take screenshot**
When you select **Take screenshot**, Agent captures only the top of the webpage. If you must capture a different part, use a screenshot tool to capture the content and attach the image or images.
You can access attachments from your prompts by opening the  **Files** tab and navigating to the `attached_assets` directory.
You can also perform the following actions in the Agent prompt area:
* **Prompt refinement**: Let AI add detail to your first prompt by selecting  **Improve prompt**
* **Feedback**: After Agent finishes processing a prompt, you can select **Have feedback?** to send feedback to Replit
* **Pause**: Stop Agent by selecting **Pause** above the text area
Your feedback helps Replit improve Agent. Use the feedback link to report issues, suggest improvements, or share your experience.
###
[](#checkpoints)
Checkpoints
A **checkpoint** is a saved snapshot of the state of your Replit App. Agent automatically creates checkpoints at logical points while working on your request. Complex tasks can generate multiple checkpoints.
Each checkpoint lets you perform the following actions:
* **Rollback**: Undo changes made by Agent and return to the state of the previous checkpoint.
* **Track usage**: Hover over the  usage icon in a checkpoint to view the amount billed for that checkpoint.
When Agent receives your initial prompt to setup and create an app, it presents an implementation plan for your review. Select **Approve plan & start** to let Agent start building your app.
Replit charges a fee for each checkpoint except when proposing initial plans. To learn more about pricing, see [Replit AI Billing](/billing/ai-billing#agent-billing)
.
###
[](#progress-tab)
Progress tab
How to access the Progress tab
1. Select  **All tools** in the dock on the left
2. Select  **Progress**
From the **Tools dock**, select **Progress** from the dock on the left.
From the **Search bar**:
1. Select the  magnifying glass at the top to open the search tool
2. Type “Progress” to locate the Progress tool and select it from the results
The **Progress** tab shows a record of Agent’s actions. You can use it to view the following:
* **Real-time updates**: monitor Agent’s progress and navigate directly to relevant files by selecting the  link icon
* **Chronological history**: review Agent’s activities to understand the details of the changes and troubleshoot issues when needed
The following animation shows the Progress tab in action:
Was this page helpful?
YesNo
[Previous](/category/replit-ai)
[Replit AssistantReplit Assistant uses AI to help you create and polish your app quickly. Type what you want in everyday language, and it can add new features or fix problems for you. Assistant can also analyze your code to explain what it does and suggest the next lines as you type.\
\
Next](/replitai/assistant)
On this page
* [Features](#features)
* [Usage](#usage)
* [Chat prompts](#chat-prompts)
* [Checkpoints](#checkpoints)
* [Progress tab](#progress-tab)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit AI
Agent integrations
Agent comes with powerful built-in integrations that help you quickly build full-featured apps. These integrations activate automatically when your prompt includes keywords related to their functionality.
[](#getting-started-with-integrations)
Getting started with integrations
----------------------------------------------------------------------------
To use an integration in your Agent prompt, simply mention the service or functionality you need. For example:
Create a web app that uses Stripe to accept payments and Sendgrid to send confirmation emails
Agent will automatically detect these keywords and implement the necessary code to integrate these services into your application.
[](#ai-services)
AI services
--------------------------------
OpenAI
Powers AI features using GPT models for text generation, content creation, summarization, and intelligent assistants within your application.
Anthropic
Incorporates Claude models (claude-3-7-sonnet-latest) for natural language understanding, content generation, and conversational interfaces.
xAI
Incorporates advanced AI models to power intelligent features like content generation and personalized recommendations.
Perplexity
Integrates AI-powered search and answer generation, allowing users to ask questions and receive comprehensive, citation-backed responses.
[](#authentication%2C-security%2C-and-payment)
Authentication, security, and payment
----------------------------------------------------------------------------------------
Replit Auth
Replit Auth allows users to sign into your app using their Replit Account credentials. This integrates natively with Replit and is the fastest and simplest way to add Auth to your Replit apps.
Firebase Auth
Provides authentication supporting email/password login, social media authentication, and secure user management with ready-made UI components.
Google OAuth
Enables quick and secure single sign-on using Google accounts.
Stripe
Handles secure payment processing, subscriptions, invoicing, and complex billing scenarios with comprehensive transaction reporting.
[](#communication%2C-notifications%2C-%26-messaging)
Communication, notifications, & messaging
--------------------------------------------------------------------------------------------------
Sendgrid
Sends transactional emails, marketing campaigns, and automated notifications to users.
Slack
Enables real-time notifications and alerts from your app directly to team channels for instant communication.
Twilio
Enables SMS notifications, verification codes, alerts, and two-factor authentication through text messaging.
Telegram
Sends notifications and messages to users through Telegram’s messaging platform.
[](#data-storage-%26-management)
Data storage & management
--------------------------------------------------------------
Database
Provides a robust, scalable relational database built into Agent for storing structured data with support for queries, transactions, and data relationships.
Airtable
Connects your app to Airtable for organizing and displaying structured content.
[](#workspace-integrations)
Workspace integrations
------------------------------------------------------
Google Calendar
Allows users to view, create, and manage events and schedules directly from your app.
Google Drive
Provides access to cloud storage for files with options to upload and download documents within your app.
Google Sheets
Integrates spreadsheet functionality for data tracking, calculations, and visualizations.
Dropbox
Enables file storage, sharing, and syncing capabilities within your application.
Was this page helpful?
YesNo
[Previous](/replitai/assistant)
[OverviewThe Replit workspace is an environment where you can create apps and write code in a single browser tab without any installation or setup. From the workspace, you can create, run, and deploy your apps from any device.\
\
Next](/category/replit-workspace)
On this page
* [Getting started with integrations](#getting-started-with-integrations)
* [AI services](#ai-services)
* [Authentication, security, and payment](#authentication%2C-security%2C-and-payment)
* [Communication, notifications, & messaging](#communication%2C-notifications%2C-%26-messaging)
* [Data storage & management](#data-storage-%26-management)
* [Workspace integrations](#workspace-integrations)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Overview
The workspace provides instant access to all the tools you need to start creating immediately. Its customizable interface, feature-rich code editor, and integrated toolset streamline the app development process.
The workspace can help you accomplish the following goals:
* Build apps using only natural language descriptions using Replit’s AI-powered tools.
* Collaborate on building an app or conduct interviews using Replit’s real-time multiplayer tools.
* Build and deploy your app from any web-enabled device, such as a phone, tablet, or laptop.
[](#what-is-a-replit-workspace%3F)
What is a Replit workspace?
------------------------------------------------------------------
The workspace is a browser user interface that lets you access Replit tools. The user interface consists of a dock that lets you quickly open tools and arrange them in resizable content panes. For a list of tools, see the [Workspace Features](/category/workspace-features)
documentation.
[](#getting-started)
Getting started
----------------------------------------
To open a workspace, log into Replit and then perform either of the following:
* Select **Create App** and complete the dialog prompts to start a new Replit App.
* Select **Apps** and open one of your Replit Apps.
From the workspace, access the complete list of tools by performing either of the following:
* Select  **All tools** in the dock on the left.
* Select the  magnifying glass at the top to open the search tool, then scroll to the “Tools” section.
To learn more about workspace customization and features, see [Introduction to the Workspace](replit-workspace/introduction-to-workspace/)
.
###
[](#key-features)
Key features
The workspace offers the following powerful development features:
* Configurable, intuitive layout for viewing tools side by side or in your [preferred arrangement](/replit-workspace/workspace-features/preferences)
* Web app preview and interaction through the [**Webview**](/replit-workspace/workspace-features/webview)
tool
* Application log monitoring in the [**Console**](/replit-workspace/workspace-features/console-shell)
tool
* Centralized management of your app’s API keys and credentials in the [**Secrets**](/replit-workspace/workspace-features/secrets)
tool
* Customizable **Run** button actions in the [**Workflow**](/replit-workspace/workflows)
tool
* Real-time [collaboration](/replit-workspace/workspace-features/multiplayer)
with teammates over the network
* Seamless [deployment](/category/replit-deployments)
to cloud services and database integration
* AI-powered tools, [Agent](/replitai/agent)
and [Assistant](/replitai/assistant)
, for project setup, feature development, and debugging.
[](#use-cases)
Use cases
----------------------------
The following examples showcase how the workspace can accelerate your app development process.
###
[](#create-a-full-stack-app)
Create a full-stack app
Build and deploy complete applications with front-end, back-end, and database components using AI-powered tools.
###
[](#create-and-share-a-template)
Create and share a Template
Publish an app and share it with others as a Template which serves as a foundation for building their own variations and enhancements.
[](#next-steps)
Next steps
------------------------------
To learn more about the workspace, see the following resources:
* Learn how to navigate and setup the workspace in [Introduction to the Workspace](replit-workspace/introduction-to-workspace/)
* Explore the workspace tools in the [Workspace Features](/category/workspace-features)
sections
* Learn more about the desktop app in [Replit Desktop App](/platforms/desktop-app)
* Learn more about the mobile app in [Replit Mobile App](/platforms/mobile-app)
Was this page helpful?
YesNo
[Previous](/replitai/integrations)
[IntroductionThe Workspace is like an IDE (Integrated Development Environment), providing a comprehensive set of development tools and features for creating, debugging, and managing your software. It helps you quickly and easily create, modify, and collaborate on your code.\
\
Next](/replit-workspace/introduction-to-workspace)
On this page
* [What is a Replit workspace?](#what-is-a-replit-workspace%3F)
* [Getting started](#getting-started)
* [Key features](#key-features)
* [Use cases](#use-cases)
* [Create a full-stack app](#create-a-full-stack-app)
* [Create and share a Template](#create-and-share-a-template)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Introduction to the Workspace
[](#how-to-create-a-replit-app)
How to create a Replit App
--------------------------------------------------------------
A Replit App (derived from REPL—“read-eval-print loop”) is an interactive programming environment where you can write and execute code in real-time. To create one, navigate to [Replit](https://replit.com)
and click the **create** button in the sidebar.
Next, give your app a name and choose the Template you want to use. You can also directly [import a GitHub repository](/replit-workspace/using-git-on-replit/import-repository)
.
To import a GitHub repository, read our docs [here](/replit-workspace/using-git-on-replit/import-repository)
.
Congratulations! You’ve just created a Replit App!
[](#workspace-dock)
Workspace dock
--------------------------------------
The left side of the workspace contains a dock which provides access to your App’s files and workspace tools.
###
[](#file-tree)
File tree
Quickly locate and access files in your project using the file tree, an organized navigation system that displays the hierarchical structure of your project with each file and folder clearly labeled. The file tree offers a comprehensive view of the structure of your project and lets you modify any file immediately.
###
[](#tools)
Tools
You can find Tools in the sidebar, like the Shell, Console, Secrets, and other helpful utilities for your Replit App.
[](#tabs-and-panes)
Tabs and panes
--------------------------------------
Files and Tools are displayed in the workspace using tabs and panes. A tab is a single file or tool, while a pane can contain multiple files and tools.
[](#run-your-code)
Run your code
------------------------------------
To execute your code, select the **Run** button. You can also use the Shell to run a custom command or modify the `.replit` file to alter the initial run command. Check out the [Configuring a Replit App](/replit-app/configuration)
doc to learn how to customize the way your Replit App runs even further.
[](#the-spotlight-page)
The spotlight page
----------------------------------------------
The spotlight page is how others can view and interact with your Replit App.
[](#multiplayer)
Multiplayer
--------------------------------
Replit’s multiplayer feature allows users to collaborate on code simultaneously in real-time.
* * *
Now you are ready to build. Get started with one of our [templates](https://replit.com/templates)
. If you need more help, check our [Community Hub](https://replit.com/community)
for additional resources.
Was this page helpful?
YesNo
[Previous](/category/replit-workspace)
[WorkflowsA Workflow is a easily configurable 'Run' button that can run any command(s) you'd like.\
\
Next](/replit-workspace/workflows)
On this page
* [How to create a Replit App](#how-to-create-a-replit-app)
* [Workspace dock](#workspace-dock)
* [File tree](#file-tree)
* [Tools](#tools)
* [Tabs and panes](#tabs-and-panes)
* [Run your code](#run-your-code)
* [The spotlight page](#the-spotlight-page)
* [Multiplayer](#multiplayer)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit AI
Replit Assistant
Assistant uses powerful AI technology to understand your Replit App and make improvements.
[](#features)
Features
--------------------------
Assistant offers **Basic** and **Advanced** modes to help you build your app efficiently and according to your needs.
Assistant uses the following industry-leading AI models:
* **Basic**:
* **Advanced**:
###
[](#basic-mode)
Basic mode
Chat with Assistant about your Replit App to receive the following support:
* Clear explanations of your code
* Intelligent autocomplete suggestions
* Recommendations to improve your app
This mode is completely free for all users.
###
[](#advanced-mode)
Advanced mode
Take your development to the next level with Assistant’s ability to directly interact with and modify your Replit App. In addition to Basic mode features, Advanced mode can perform the following actions:
* Update code automatically for adding features and fixing bugs
* Undo any of Assistant’s changes in one click
* Install and set up packages to support added features
* Create and update Workflows
* Update your database structure
For your security, Assistant cannot access or modify data in Secrets, Replit’s secrets manager.
[](#usage)
Usage
--------------------
You can use Assistant in any Replit App from your Replit workspace. Access Assistant’s AI-powered features from the Assistant tool or the File editor.
###
[](#assistant-tool)
Assistant tool
How to access the Assistant tool
From the **Tools dock**:
1. Select  **All tools** in the dock on the left
2. Select the  **Assistant** icon
From the **Search bar**:
1. Select the  magnifying glass at the top to open the search tool
2. Type “Assistant” to locate the Assistant tool and select it from the results
You should see a screen that resembles the following screenshot:
From the Assistant tool, you can perform the following actions:
* **Chat**: Type your instructions or questions in the text area or select one of the pre-created prompts
* **Switch modes**: Select **Basic** or **Advanced** mode
* **Manage conversations**: Select **New chat** or select previous conversations from the  menu icon to start or resume a conversation
* **Track usage**: Select the  usage icon to view your billing page
* **Customize settings**: Select the  gear icon to configure Assistant settings
* **Reverse changes**: Select **Undo these changes** to roll back Assistant’s modifications or select **Go to this checkpoint** to reset your code to that specific revision
To switch between **Basic** and **Advanced** mode, select the dropdown arrow and select the mode.
You should see a menu that resembles the following image:
####
[](#chat-prompts)
Chat prompts
To communicate your request in the Assistant tool, enter a **prompt** in the text area. A prompt is a natural language instruction that tells the Assistant what you need. Assistant analyzes the files in your Replit App and your prompt to create its response.
In addition to the text prompt, you can include the following to add context:
* Attach a file by dragging it into the text area or by selecting the  paperclip icon
* Specify files from your Replit App related to your request by selecting **Add file context**.
While Assistant intelligently determines which files are relevant to your request, identifying the files can help it create a more accurate solution.
####
[](#edit-requests)
Edit requests
In Advanced mode, Assistant creates **edit requests** when proposing changes to your Replit App. Edit requests contain all the code and configuration modifications it intends to make. These requests let Assistant perform the following actions:
* Display a preview of the proposed changes
* Let you review and approve the changes before applying them
* Automatically create a version control checkpoint for approved changes
* Undo changes or restore your project to a previous state
When Assistant suggests changes, select  **Preview code changes** to view the proposed changes.
To approve the edit request, select **Apply all** to implement the changes.
Replit charges a fee for each approved edit request.
To learn more about pricing, see [Replit AI Billing](/billing/ai-billing#assistant-billing)
.
###
[](#file-editor)
File editor
How to access the Assistant from the file editor
From the left tool dock:
1. Select  **All tools** in the dock on the left
2. Select  **Open files**
3. Select a file to view the contents in a file editor tab
4. Select relevant lines of text in the file
5. Either right-click the selected text to open a menu or select from the icons that appear at the top of the selected text
The following image shows the **Explain with Assistant** and **Modify with Assistant** menu items:
The following animation shows an example of using the **Modify with Assistant** function:
When viewing content in the File editor, you can access the following Assistant-powered actions:
* **Get explanations**: Highlight the code and select the  explain icon to receive a detailed breakdown.
* **Improve your code**: Highlight the code and select the  modify icon to have Assistant improve or rewrite your code.
* **Fix errors**: Hover over squiggly underlined code, which indicates Assistant detects possible issues, and select “Debug with AI” to get fix suggestions. Request automatic changes or continue your conversation in the Assistant tool.
###
[](#assistant-settings)
Assistant settings
How to access the Assistant settings
To access settings, select the  gear icon in the **Assistant** tab.
You should see a screen that resembles the following screenshot:
From the Assistant settings, you can set the following preferences:
* **Append instructions**: Add instructions automatically included in all your prompts
* **Select AI models**: Choose specific AI models to process your prompts
* **Streamline changes**: Skip the confirmation step for edit requests
* **Manage workflow restarts**: Control whether Assistant code modifications restart the workflow
Was this page helpful?
YesNo
[Previous](/replitai/agent)
[IntegrationsAgent supports numerous integrations that are enabled automatically when your prompt contains specific keywords.\
\
Next](/replitai/integrations)
On this page
* [Features](#features)
* [Basic mode](#basic-mode)
* [Advanced mode](#advanced-mode)
* [Usage](#usage)
* [Assistant tool](#assistant-tool)
* [Chat prompts](#chat-prompts)
* [Edit requests](#edit-requests)
* [File editor](#file-editor)
* [Assistant settings](#assistant-settings)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Workflows
It is a reusable, customizable sequence of steps that can be executed within your replit app. They can be as simple as running `python main.py` or as complex as executing a multi-step procedure.
Example Use Cases:
* Run multiple services in parallel (e.g., frontend + backend)
* Execute files or commands sequentially (e.g., run linter → run tests, compile → execute code)
To start [creating workflows](/_sites/docs.replit.com/replit-workspace/workflows#creating-workflows)
, go to the Workflows pane by using the tools sidebar menu, or search for the Workflows pane using `Command + K`.
[](#available-task-types)
Available Task Types
--------------------------------------------------
There are current 3 type of tasks available, `Execute Shell Command`, `Install Packages`, and `Run Workflow`.
###
[](#execute-shell-command)
Execute Shell Command
`Execute Shell Command` stores a shell command and executes it using the same environment as the Shell pane. This task type offers a wide range of use-cases, from running individual files:
python main.py
to executing complex stored database query commands:
psql -h 0.0.0.0 -U your_username -d your_database -c "SELECT * FROM your_table;"
Example use case:
###
[](#install-packages)
Install Packages
`Install Packages` utilizes Replit’s built-in dependency management system, automatically detecting your project dependencies and installing the necessary packages for your project. See [Dependency Management](../replit-workspace/dependency-management.md#the-universal-package-manager)
for more details on how UPM guesses packages to install for your project under the hood.
Example use case:
###
[](#run-workflow)
Run Workflow
`Run Workflow` allows you to run another workflow from the current workflow. This allows for reusing workflows and combining them to create more complex workflows.
Example use case:
By using this task type for creating dependencies between workflows, you can edit one workflow and have other workflows referencing it automatically use the latest changes. Note that there is a depth limit placed on deeply nested workflow calls.
[](#workflow-execution-mode)
Workflow Execution Mode
--------------------------------------------------------
Workflows offer two different modes of execution: sequential and parallel.
###
[](#sequential)
Sequential
Sequential execution will run each task in the defined order, waiting for each task to finish before moving on to the next step, and stopping execution of the sequence if a task within the workflow failed.
An example of using this mode is for defining commands that are logically connected, such as git commands for fetching the latest changes from your main branch, then rebasing your current branch on the main branch:
###
[](#parallel)
Parallel
Parallel execution will run each task in parallel, such that each task is started and runs independently of other tasks within the workflow. One task failing does not stop the execution of other tasks.
An example of using this mode is running a fullstack project that needs to start both the frontend and the backend server:
[](#creating-workflows)
Creating Workflows
----------------------------------------------
Workflows can be created using the workflows pane by clicking on the `+ New Workflow` button. Start by giving your workflow a descriptive name, chose a suitable mode of execution, and start adding tasks. Tasks can be re-ordered by dragging and dropping them into the desired order.
[](#assign-workflow-to-run-button)
Assign Workflow to Run Button
--------------------------------------------------------------------
A workflow can also be assigned to the run button to replace the default run button behavior (see [Configure a Replit App](/replit-app/configuration)
). To keep the default run command configured within `.replit`, select the default “Run Replit App” option within the dropdown.
The selected workflow within the dropdown menu next to the run button will be run when the run button is clicked. Click on your desired workflow within the dropdown menu to change which workflow should be run by the run button.
[](#viewing-workflow-outputs)
Viewing Workflow Outputs
----------------------------------------------------------
Workflow outputs will be displayed in the `Console` pane. You can toggle the display to only display latest outputs and clear the console altogether.
Was this page helpful?
YesNo
[Previous](/replit-workspace/introduction-to-workspace)
[Dependency ManagementReplit supports a variety of languages and dependency management systems through the Dependencies tool. This section will cover the different types of dependencies and how to manage them in your Replit App.\
\
Next](/replit-workspace/dependency-management)
On this page
* [Available Task Types](#available-task-types)
* [Execute Shell Command](#execute-shell-command)
* [Install Packages](#install-packages)
* [Run Workflow](#run-workflow)
* [Workflow Execution Mode](#workflow-execution-mode)
* [Sequential](#sequential)
* [Parallel](#parallel)
* [Creating Workflows](#creating-workflows)
* [Assign Workflow to Run Button](#assign-workflow-to-run-button)
* [Viewing Workflow Outputs](#viewing-workflow-outputs)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Extensions
[](#what-can-extensions-do%3F)
What can Extensions do?
----------------------------------------------------------
###
[](#streamline-workflows)
Streamline workflows
Extensions are deeply integrated with Replit, so users can automate actions like reading and editing files, formatting or linting code, and more.
###
[](#add-custom-apps-with-tools)
Add custom apps with tools
Tool Extensions lets you interact with custom experiences and products in the Replit Workspace, similar to the apps you install on your phone or computer.
###
[](#extend-native-functionality)
Extend native functionality
Extensions can extend and improve the existing functionalities within Replit, like formatting code and editor capabilities.
[](#reasons-to-build-an-extension)
Reasons to build an Extension
--------------------------------------------------------------------
###
[](#consolidate-your-tools)
Consolidate your tools
Developing an Extension allows you to integrate your preferred tools into the Replit environment, serving your specific workflow preferences.
###
[](#personalize-your-workspace)
Personalize your Workspace
Extensions empower you to customize Replit to suit your needs, creating a sense of empowerment and productivity.
###
[](#expand-your-software-reach)
Expand your software reach
Companies can use Extensions to distribute their products directly to Replit’s active Community, accessing a targeted audience within a relevant context.
[](#extensions-store)
Extensions store
------------------------------------------
The Extensions store allows you to view and install from various Workspace Extensions.
[](#access-the-store)
Access the store
------------------------------------------
In your Replit App, you can access the Extensions store by navigating to the **Tools** section on the sidebar and selecting **Extensions**.
[](#install-an-extension)
Install an Extension
--------------------------------------------------
In the Extensions store, choose an Extension and select **Activate Extension for your account**.
Select **Accept and Activate** to start using the Extension.
You’ll find installed Extensions in the **Installed** tab alongside the **Store**.
You can use the ellipses next to each Extension to manage them, allowing you to uninstall, unlist, un-bless, feature, or delete them from the store.
Was this page helpful?
YesNo
[Previous](/replit-workspace/using-git-on-replit/github-auth-errors)
[PortsLearn how ports work in Replit's cloud environment, including port forwarding, configuration, and troubleshooting for your web applications.\
\
Next](/replit-workspace/ports)
On this page
* [What can Extensions do?](#what-can-extensions-do%3F)
* [Streamline workflows](#streamline-workflows)
* [Add custom apps with tools](#add-custom-apps-with-tools)
* [Extend native functionality](#extend-native-functionality)
* [Reasons to build an Extension](#reasons-to-build-an-extension)
* [Consolidate your tools](#consolidate-your-tools)
* [Personalize your Workspace](#personalize-your-workspace)
* [Expand your software reach](#expand-your-software-reach)
* [Extensions store](#extensions-store)
* [Access the store](#access-the-store)
* [Install an Extension](#install-an-extension)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Dependency Management
[](#imported-packages)
Imported Packages
--------------------------------------------
Packages imported directly from your code are managed in the `Imports` tab. This tab allows you to view and manage the packages grouped by language. Links are also provided to the appropriate packager file, such as `package.json` for Node.js.
###
[](#search-and-add-packages)
Search and add packages
Clicking on `Add new package` will allow you to search for and install new packages. The language dropdown provides quick access between packagers.
You can view installation progress and relevant errors in the `Console` tab.
###
[](#the-universal-package-manager)
The Universal Package Manager
Replit will install most packages using [the universal package manager](https://blog.replit.com/packager)
. To see which languages and package managers are supported, please check out [UPM: Supported Languages](https://github.com/replit/upm/#supported-languages)
.
If you prefer using the CLI, you can still use language-specific package managers such as `poetry` or `npm`. Any changes to the packager files will be reflected in the `Dependencies` tool, but require the respective CLI command or using the **Run** button to properly update.
###
[](#import-guessing)
Import guessing
As your code evolves, we analyze your project for missing dependencies and automatically guess what needs to be installed to get your code to run. For example, if you add `import flask` to `main.py`, the next time you select **Run**, you’ll see a section in the **Console** indicating that the latest version of **Flask** is being installed:
###
[](#guessing-failures)
Guessing failures
This section helps you with the command to run a particular version of your package. If there’s a particular version that you need, or we guessed the wrong package entirely, you can run `upm` in the shell to resolve the conflict:
upm add 'flask==2.3.3'
To install additional packages in your Workspace, open a new tab by selecting the **+** sign and searching for **Packages**. Select the packages of your choice and select **Install**. Additional options for package guessing can be configured in the [.replit](/replit-app/configuration#replit-file)
file.
###
[](#python-package-managers)
Python package managers
When you create a Python Replit App, your package manager will be **poetry** by default. This means that you will not be able to use `pip install` to manage dependencies manually. Instead of running `pip install `, you can instead run `poetry add ` or `upm add `, which will do the same thing.
`pip` is one of the earliest, and consequently most popular, package managers for Python. You can use `pip` as your Replit App’s package manager instead of `poetry`. Follow the steps below:
1. In the Tools pane, select the **Shell** tab to add the common `requirements.txt` file using the following command:
touch requirements.txt
2. Delete the `poetry.lock` file.
3. Move your dependencies from `[tool.poetry.dependencies]` to `requirements.txt`. Note that the `flask = "^3.0.2"` in `pyproject.toml`’s `[tool.poetry.dependencies]` section would become `flask>=3.0.2,<4` in `requirements.txt`.
4. Finally, delete the other `[tool.poetry...]` sections from `pyproject.toml`.
After the above changes, the packaging infrastructure will use `pip` for all future operations.
Now, as you add code to your `main.py` file, any time you select **Run**, [upm](https://github.com/replit/upm/)
will determine whether there are any missing packages for your imports, find the latest versions of packages that provide those imports, and install them automatically.
[](#advanced-configuration)
Advanced Configuration
------------------------------------------------------
Replit supports all programming languages through integration with [Nix](https://nixos.org/)
. Nix is a tool for managing software packages and system configurations. The **System (Advanced)** tab provides quick access to Nix support for your Replit App.
###
[](#system-modules)
System Modules
Modules combine support for programming languages, formatters, and packagers. These provide the foundation for your Replit App. If you create a Replit App from a template or GitHub repository, we will automatically install the modules that are required for the languages used.
If you want to start with a blank Replit App, you will need to install a module under **System Modules** before you can use the **Imports** tab. You can also add more modules to support additional languages.
You can further customize modules and other Nix settings using the [.replit](replit-app/configuration#replit-file)
file.
###
[](#system-dependencies)
System Dependencies
If you need more specific support for a language or other system-level dependencies, you can add [Nix packages](https://search.nixos.org/packages)
under **System Dependencies**. These can also be managed in your [replit.nix](/replit-app/configuration#replit-nix-file)
file.
Was this page helpful?
YesNo
[Previous](/replit-workspace/workflows)
[OverviewExplore key features of the Replit workspace including secrets management, file history, debugging, multiplayer coding, and resource monitoring tools.\
\
Next](/category/workspace-features)
On this page
* [Imported Packages](#imported-packages)
* [Search and add packages](#search-and-add-packages)
* [The Universal Package Manager](#the-universal-package-manager)
* [Import guessing](#import-guessing)
* [Guessing failures](#guessing-failures)
* [Python package managers](#python-package-managers)
* [Advanced Configuration](#advanced-configuration)
* [System Modules](#system-modules)
* [System Dependencies](#system-dependencies)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
SSH
[](#what-is-ssh%3F)
What is SSH?
------------------------------------
SSH, which stands for Secure Shell, is a secure protocol that facilitates remote access to your Replit App’s command line interface. With SSH, you can seamlessly transfer files and leverage your preferred local Integrated Development Environment (IDE) for editing code on Replit, enhancing collaboration and productivity in your development workflow.
SSH functionality is available for Core, Teams, and all other paid plans.
Here’s an overview of the process:
* Generate a SSH keypair on your local machine
* Add that SSH key to the “SSH” Pane inside any Replit App
* Connect using an SSH client or an editor which can work over SSH (like [VSCode](https://code.visualstudio.com/)
or [Cursor](https://www.cursor.com/)
)
SSH Keys are associated with your your account, not a particular Replit App. This means that you only need to add a public key once, after which you can connect to any Replit App you have access to.
[](#why-use-ssh%3F)
Why use SSH?
------------------------------------
* **Automatic updates between Replit App and editor**: Any changes made in the Replit App are reflected in your editor instantly, and any modifications in the editor are updated in the Replit App. This seamless synchronization ensures that your codebase is always up-to-date across platforms.
* **File management synchronization**: Whether you add, delete, or update files, these changes are synchronized in real time between your editor and the Replit App. This feature ensures that your project structure remains consistent, regardless of where the changes are initiated.
* **Folder management and file moving**: Moving files across folders is also synchronized between your editors and the Replit App. This ensures that organizational changes made in one environment are accurately reflected in the other, maintaining the integrity and structure of your project.
[](#find-or-create-a-keypair)
Find or Create a keypair
----------------------------------------------------------
To configure SSH for your account, you’ll need your SSH public key.
###
[](#figuring-out-if-you-already-have-a-keypair)
Figuring out if you already have a keypair
You can check if you already have a public key by running the following command in a Terminal on your local computer:
* Mac/Linux
* Windows
ls -l ~/.ssh
If you get an error, that’s OK, proceed to [Generating a new keypair](/_sites/docs.replit.com/replit-workspace/ssh#generating-a-new-keypair)
. If you see a file called `replit.pub`, please proceed to [Get the contents of your public key](/_sites/docs.replit.com/replit-workspace/ssh#get-the-contents-of-your-public-key)
.
###
[](#generating-a-new-keypair)
Generating a new keypair
On your machine, open a Terminal (or Command Prompt) window and paste the following command:
* Mac/Linux
* Windows
ssh-keygen -t ed25519 -f ~/.ssh/replit -q -N ""
This command checks if a specific SSH public key file already exists. If not, it creates a new SSH key with some sensible parameters.
###
[](#get-the-contents-of-your-public-key)
Get the contents of your Public Key
Once you have either confirmed you have a keypair or created one, display the contents of the public key (one of the two similarly named files, suffixed with `.pub`), as we’ll need that for later.
* Mac/Linux
* Windows
cat ~/.ssh/replit.pub
Save the contents of `replit.pub` to use later in this article and proceed to [add the SSH key to your account](/_sites/docs.replit.com/replit-workspace/ssh#add-the-ssh-key-to-your-account)
.
[](#add-the-ssh-key-to-your-account)
Add the SSH key to your account
------------------------------------------------------------------------
When you have multiple public keys on your machine, it’s important to ensure that you use the correct combination of private and public keys for your SSH configuration.
[](#connecting-to-your-replit-app)
Connecting to your Replit App
--------------------------------------------------------------------
Was this page helpful?
YesNo
[Previous](/replit-workspace/workspace-features/webview)
[OverviewLearn how to connect Replit with GitHub, import repositories, use Git commands, and manage version control in your Replit workspace.\
\
Next](/category/using-git-on-replit)
On this page
* [What is SSH?](#what-is-ssh%3F)
* [Why use SSH?](#why-use-ssh%3F)
* [Find or Create a keypair](#find-or-create-a-keypair)
* [Figuring out if you already have a keypair](#figuring-out-if-you-already-have-a-keypair)
* [Generating a new keypair](#generating-a-new-keypair)
* [Get the contents of your Public Key](#get-the-contents-of-your-public-key)
* [Add the SSH key to your account](#add-the-ssh-key-to-your-account)
* [Connecting to your Replit App](#connecting-to-your-replit-app)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Ports
Because Replit runs your projects on a cloud environment, ports work differently on Replit than on your local computer. (If you need a more basic explanation of what TCP ports are, [start here](https://www.reddit.com/r/explainlikeimfive/comments/1t9s5a/eli5_what_are_ports_ex_tcp_port/)
.)
On a computer, you only have one layer of port management: your programs define a port that they listen to, and when traffic hits that port on your computer from the internet, they get routed to the appropriate process.
The `0.0.0.0` part is the address, or host. If a process is listening on `0.0.0.0`, that means it should listen on every network interface — which means that if another computer (on the internet) sends a request to your computer’s IP address, it will see it. So, listening on 0.0.0.0 means those processes are accessible to the public internet (if your computer is connected.)
Most programming frameworks will _not_ listen on `0.0.0.0` when you’re developing, because you don’t necessarily want your work exposed to the public while you’re working on it, for privacy & security. Instead, they’ll listen on a different address — `127.0.0.1`, otherwise known as `localhost`. This means only that computer can make requests to that port.
On Replit, for a process you’re running to be accessible in the webview or via an external request, it has to have an \*\*external port \*\*defined. This is because the “internal port” that processes typically use is only visible from inside the sandboxed cloud environment that Replit provides. We have to connect that internal port to an externally accessible port to send the right traffic to your programs. Even if your process listens on a port typically available to the public like 0.0.0.0, we still need to bind that port to an external port.
We do this by binding external ports to specific internal ports — for example, in the diagram above, the external port `:80` is bound to the internal port `:3000`. That means any traffic that Replit App gets on port 80 will go to the internal port 3000.
This configuration is captured in the \[\[ports\]\] section of the .replit config file.
By default, we will bind the first port you open to the default external port 80, which will allow that process to be available at the domain without a port address (e.g. customdomain.com/ instead of customdomain.com:3000/). Additional internal ports that are opened will be bound to other available external ports (see a full list below.)
[](#webview)
Webview
------------------------
In the webview, you can change which external port the webview is rendering by clicking the domain and selecting a different port. You can also open the networking tool from the “gear” icon for more details.
[](#default-port)
Default port
----------------------------------
Port :80 is the “default port” for http traffic, so http traffic sent to the root domain will automatically be routed to port 80. We don’t show the port path in the url for port 80 for that reason. Ports other than :`80` will show up in the domain path (e.g. customdomain.com:4200/). (We provide TLS by default, so it will technically be over port 443, which is the default port for https. For all intents and purposes, you can treat them as interchangeable.)
[](#networking-tool)
Networking tool
----------------------------------------
For more details about port config and networking, you can open the networking tool. It shows the status of ports open in your Replit App, what external port they’re bound to, and lets you add or remove configuration.
[](#deployments)
Deployments
--------------------------------
Autoscale and Reserved DM deployments only support a single external port being exposed, and for the corresponding internal port not to be using `localhost`. If you expose more ports, or expose a single port on localhost, your deployment will fail. An easy way to make sure your Autoscale deployments work as expected is to remove all the `externalPort` entries for the ports in your config _except_ the port for the service you want to interact with from the internet.
[](#debugging)
Debugging
----------------------------
A common reason something might not be working as you’d expect is that while your port config looks right, your program is actually looking at a different port. For example, if your config is:
[[ports]]
internalPort = 3000
externalPort = 80
Then internet traffic to port 80 will go to internal port 3000. However, if your program is actually not listening on port 3000, but rather something else (like 8080), it will appear as if no traffic is getting through. This can happen if you switch the port in your code without switching the corresponding port in your config, or copy-paste config from one project to another.
Each framework has different default ports it listens to — for example, Flask is 5000, react is 3000, and laravel is 8000. Make sure the right port is configured!
[](#preferences)
Preferences
--------------------------------
We will automatically bind ports that are opened in your Replit App to available external ports when they are opened, and record that binding in the .replit config file.
However, we don’t do this by default for internal ports that open on localhost, because services that usually run on localhost typically assume that they will only be accessible on the same computer as the process that’s running (localhost ports are only visible to the same computer running the process.) This means those services are often not as secure as services built under the assumption that they’ll be available to the public internet.
You can always override this by setting the `exposeLocalhost` config option to `true` for the port you want to expose.
If you want to _always_ expose localhost ports by default, you can set your “automatic port forwarding” setting in the User Settings tool to “All ports”.
If you want to _never_ create config for ports that are opened, and manually control the port config for all your Replit App, you can set that to “never”.
[](#supported-ports)
Supported ports
----------------------------------------
Replit App will define port 80 as the external port by default when the first port opens. A Replit App can expose 3000, 3001, 3002, 3003, 4200, 5000, 5173, 6000, 6800, 8000, 8008, 8080, 8081, as extra external ports.
Ports 22 and 8283 are not forwardable, as they are used internally.
[](#%5B%5Bports%5D%5D-replit-config)
`[[ports]]` .replit config
-------------------------------------------------------------------
Type: `{localPort, externalPort, exposeLocalhost}`
The `[[ports]]` config Allows you to configure which HTTP port to expose for your web output. By default, any exposed HTTP port with host 0.0.0.0 will be exposed as your Replit App’s web output.
Extra ports can be served without overriding the default port by adding a new \[\[ports\]\] entry to your .replit file. You are required to specify both a localPort and externalPort entry. You can add multiple extra ports by adding multiple \[\[ports\]\] entries to your .replit file as defined below.
###
[](#localport)
localPort
Determines which port Replit will bind to an external port.
###
[](#externalport)
externalPort
Determines which port should be exposed for that local port’s publicly accessible port.
[[ports]]
localPort = 3000
externalPort = 80
If you want to _never_ expose a particular port, you can leave the `localPort` config but just not add an `externalPort`:
[[ports]]
localPort = 3000
###
[](#exposelocalhost)
exposeLocalhost
Determines whether an internal port using `localhost` can be bound to an external port. Can be `true`, `false`, or null.
[[ports]]
localPort = 3000
externalPort = 80
exposeLocalhost = true
Was this page helpful?
YesNo
[Previous](/replit-workspace/extensions)
[OverviewLearn how to create, manage, and customize themes in Replit. Change colors, syntax highlighting, and UI elements to make your coding environment your own.\
\
Next](/category/themes)
On this page
* [Webview](#webview)
* [Default port](#default-port)
* [Networking tool](#networking-tool)
* [Deployments](#deployments)
* [Debugging](#debugging)
* [Preferences](#preferences)
* [Supported ports](#supported-ports)
* [\[\[ports\]\] .replit config](#%5B%5Bports%5D%5D-replit-config)
* [localPort](#localport)
* [externalPort](#externalport)
* [exposeLocalhost](#exposelocalhost)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Keyboard Shortcuts
Keyboard shortcuts let you run commands, modify text, and navigate the workspace using configurable key combinations. You can set and use keyboard shortcuts in the Replit.com web app and desktop app.
[](#viewing-keyboard-shortcuts)
Viewing keyboard shortcuts
--------------------------------------------------------------
The Replit.com web app and desktop apps keep separate shortcut preferences. Changes in one environment don’t affect the other.
To view your keyboard shortcut settings, follow these steps:
1. Open a Replit App to navigate to the workspace.
2. Open the  **User Settings** tab from  **All tools** in the dock. Alternatively, search for “User Settings” using the  magnifying glass.
3. Select the **Keyboard shortcuts** tab to view the list of commands and their assigned shortcuts.
[](#customizing-keyboard-shortcuts)
Customizing keyboard shortcuts
----------------------------------------------------------------------
To add or modify a keyboard shortcut, follow these steps:
1. Select **Add shortcut**, located next to the unassigned command, or the  pencil icon for assigned commands.
2. When “Recording…” appears next to the command, press the key combination you want to assign. To cancel recording, click an empty area inside the tab.
3. To revert the shortcut, select the  rollback icon.
[](#removing-keyboard-shortcuts)
Removing keyboard shortcuts
----------------------------------------------------------------
To remove a keyboard shortcut, select the  trash icon next to the command.
[](#tab-navigation)
Tab navigation
--------------------------------------
You can use the browser **Tab** key navigation to navigate between the interactive elements on a page. However, the File Editor, Console, and Shell tools capture the **Tab** key as input for purposes including indentation.
To continue cycling through page elements while in these tools, follow these steps:
1. Press **Esc** to release focus from the tools
2. Press **Tab** to move to the next element
Was this page helpful?
YesNo
[Previous](/replit-workspace/themes/port-from-vscode)
[TemplatesIf your Replit App can be used as a good starting point for other project, you might want to submit it as a template! Let's learn what a Replit template is and how to make a good one.\
\
Next](/replit-workspace/templates)
On this page
* [Viewing keyboard shortcuts](#viewing-keyboard-shortcuts)
* [Customizing keyboard shortcuts](#customizing-keyboard-shortcuts)
* [Removing keyboard shortcuts](#removing-keyboard-shortcuts)
* [Tab navigation](#tab-navigation)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Workspace
Templates
[](#what-is-a-template%3F)
What is a template?
--------------------------------------------------
Templates are published Replit Apps that can be used to build upon. The official templates, made by Replit, have a checkbox next to the name of the template:
The [HTML, CSS, JS template](https://replit.com/@replit/HTML-CSS-JS?v=1#index.html)
template is very popular and can be used as a starting point for creating a vanilla JavaScript project. You can fork the template to use it.
Other templates have been created by community members, like this one:
[](#creating-a-template)
Creating a template
------------------------------------------------
Public Replit Apps can be published by checking the “Publish as Template” box in the last step of the Publish this Replit Apps flow.
Before you publish your template, make sure it’s as easy to use as possible. It should include all the boiler plate code that is needed to get a project started, and it should work right away when the “Run” button is pressed.
A good template should always include well-commented code, easily editable variables, and a README file. It’s always important to comment your code, but it’s even more important when others will be using your code for their own projects. In the `README.md` file, add descriptive details about your template, and information about the variables that the user can change. READMEs help users understand how your template works, and if there are any requirements, licensing, or other factors they should be aware of.
The `.md` in `README.md` stands for Markdown, which is a basic text language. READMEs can be written in any text format, but we’ll use Markdown as it’s the best practice.
Here’s an example outline for a README - feel free to use this for your own templates!
# Template Name
Choose a self-descriptive name, you can also add a simple description about your template.
# Usage
Explain how you can install / use this template. Make sure to provide a detailed explanation and make it easy for people to read. Also, add any code snippets if needed.
# License
This will define how people can use your template. You can visit https://opensource.org/licenses to choose a license.
You can also edit your submitted template and share update messages to show how your project has changed over time.
Was this page helpful?
YesNo
[Previous](/replit-workspace/keyboard-shortcuts)
[OverviewShare your Replit Apps with the world in just a few clicks.\
\
Next](/category/replit-deployments)
On this page
* [What is a template?](#what-is-a-template%3F)
* [Creating a template](#creating-a-template)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Deployments
Overview
Replit Deployments lets you publish your Replit App to the cloud using a simplified process.
[](#what-is-replit-deployments%3F)
What is Replit Deployments?
------------------------------------------------------------------
Replit Deployments is a feature that saves a **snapshot** of your Replit App to the cloud, where it everyone can interact with it. A snapshot captures the current state of the files in your Replit App.
When you deploy your Replit App, you create a **deployment**. A deployment is a running instance of your app on Replit’s cloud infrastructure. This makes the app reliably available on the internet, separate from the version in your workspace.
Replit’s infrastructure is backed by Google Cloud Platform (GCP). All deployments are hosted in the United States.
Replit Deployments includes tools to monitor your deployment status and view web analytics.
Replit offers the following deployment types:
[Autoscale Deployments\
---------------------\
\
Automatically adjusts resources based on your app’s usage.](/cloud-services/deployments/autoscale-deployments)
[Static Deployments\
------------------\
\
Provides an affordable way to host websites that don’t change based on user input.](/cloud-services/deployments/static-deployments)
[Reserved VM Deployments\
-----------------------\
\
Provides a consistent amount of computing resources for your app to run continuously.](/cloud-services/deployments/reserved-vm-deployments)
[Scheduled Deployments\
---------------------\
\
Runs your app at scheduled times that you choose.](/cloud-services/deployments/scheduled-deployments)
[](#getting-started)
Getting started
----------------------------------------
Follow the steps below to deploy your Replit App:
1. From your Replit App workspace, select  **Deploy** at the top.
2. In the **Deployments** tab, select your deployment option.
3. If **Add a payment method** appears, follow the prompts to add a payment method.
Replit automatically selects the best deployment option for your app based on the project type and your needs.
However, to choose a different deployment type, consider the following information.
Choose the right deployment option for your app
The following video explains how to choose the right deployment option for your app:
Use the following decision tree featured in the video to help you choose:
[](#key-features)
Key features
----------------------------------
Deployments offer the following convenient features:
* **Multiple deployment types**: Select or update a deployment type that meets your needs in a few clicks.
* **Custom domains**: Serve your app from your web domain.
* **Analytics**: Track visitor data and other metrics for your deployed app.
* **Monitoring tools**: View your app’s deployment status and configuration.
* **Access controls**: Control who can see your app with a single click. Available only for **Teams** members.
[](#how-it-works)
How it works
----------------------------------
When you deploy your Replit App, Replit creates a snapshot of your app’s files and dependencies. This snapshot is then sent to Replit’s cloud infrastructure, where it runs as a separate instance of your app. To update your deployment with the latest changes, deploy again to create a fresh snapshot.
Avoid saving and relying on data written to a deployed app’s filesystem. To store data, use a storage or database option such as Replit’s [Storage and Database](/category/storage-and-databases)
offerings.
[](#use-cases)
Use cases
----------------------------
The following examples show different types of Replit Deployments.
###
[](#autoscale-deployment%3A-typing-speed-assessment-app)
Autoscale deployment: Typing speed assessment app
Let the cloud scale up resources when users take typing tests and reduce them when not in use.
###
[](#static-deployment%3A-solar-system-simulation)
Static deployment: Solar system simulation
Learn about the planets in a solar system visualization app on the web. This visualization renders in the browser and doesn’t transfer any user input to a server.
###
[](#reserved-vm-deployment%3A-discord-bot)
Reserved VM deployment: Discord bot
Run a Discord bot that helps you moderate and onboard members. It’s always online to chat with users and respond to commands with predictable pricing and performance.
###
[](#scheduled-deployment%3A-home-automation-triggers)
Scheduled deployment: Home automation triggers
Schedule API calls to start and stop your smart home devices at specific times and days.
[](#next-steps)
Next steps
------------------------------
To learn more about Replit Deployments, see the following resources:
* [Autoscale Deployments](/cloud-services/deployments/autoscale-deployments)
: Learn how to set up applications that scale with traffic
* [Static Deployments](/cloud-services/deployments/static-deployments)
: Discover how to deploy static websites quickly and efficiently
* [Reserved VM Deployments](/cloud-services/deployments/reserved-vm-deployments)
: Explore dedicated VM options for specialized use cases
* [Scheduled Deployments](/cloud-services/deployments/scheduled-deployments)
: Set up recurring tasks with simple scheduling
* [Custom Domains](/cloud-services/deployments/custom-domains)
: Connect your deployment to a custom domain
* [Troubleshooting](/cloud-services/deployments/static-deployments)
: Resolve common deployment issues
Was this page helpful?
YesNo
[Previous](/replit-workspace/templates)
[Autoscale DeploymentsAutoscale can scale to as many instances as required. You're charged in proportion to traffic, and you can scale up horizontally to handle high load when needed.\
\
Next](/cloud-services/deployments/autoscale-deployments)
On this page
* [What is Replit Deployments?](#what-is-replit-deployments%3F)
* [Getting started](#getting-started)
* [Key features](#key-features)
* [How it works](#how-it-works)
* [Use cases](#use-cases)
* [Autoscale deployment: Typing speed assessment app](#autoscale-deployment%3A-typing-speed-assessment-app)
* [Static deployment: Solar system simulation](#static-deployment%3A-solar-system-simulation)
* [Reserved VM deployment: Discord bot](#reserved-vm-deployment%3A-discord-bot)
* [Scheduled deployment: Home automation triggers](#scheduled-deployment%3A-home-automation-triggers)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Storage and Databases
Database
Replit Database uses a fully-managed, serverless SQL database that lets you add persistent data storage to your Replit App from the workspace. This serverless database implementation lets you pay only for what you use, making it ideal for projects of any size.
Replit Database uses PostgresSQL 15 hosted on [Neon](https://neon.tech)
.
[](#features)
Features
--------------------------
The Replit Database tool provides the following features:
* **Instant setup**: Add a production-ready SQL database with a single click
* **Database tools**: Run queries, manage database schema, and visualize data with the built-in SQL tools
* **Point-in-time restore**: Restore your database to a specific point in time within your specified retention period
* **Usage-based billing**: Pay only for the storage and data transfer you use
* **Environment variables**: Use environment variables in your Replit App to securely access the database
[](#usage)
Usage
--------------------
You can access the Database tool directly in your Replit App workspace. The following sections guide you through setting up and managing your database.
How to access the Database tool
From the left **Tool dock**:
1. Select  **All tools** to see a list of workspace tools.
2. Select  **Database**.
From the **Search bar**:
1. Select the  magnifying glass at the top to open the search tool
2. Type “Database” to locate the tool and select it from the results.
###
[](#add-a-database)
Add a database
Use one of the following methods to add a Replit database integration to your Replit App:
* Ask **Agent** to add a PostgresSQL database to your Replit App, including details on what data your Replit App should store. Agent adds the integration, creates the database schema, and updates the app to communicate with the database.
* From the **Database** tool, select **Create a database**. When using this method, you must create the tables and update your app to connect to the database.
###
[](#run-database-commands)
Run database commands
The SQL runner is a workspace tool that lets you run SQL commands on your database and view the results.
How to access SQL runner
From the **Database** tool:
1. Select the **My Data** tab
2. Select  **SQL runner**
To run a query, enter the SQL statement in the text area and select the adjacent  run button as shown below:
###
[](#browse-and-modify-data-visually)
Browse and modify data visually
The Replit Database tool includes [Drizzle Studio](https://orm.drizzle.team/drizzle-studio/overview)
, a tool that lets you browse and modify data visually.
These visual tools help you avoid syntax errors and offer the following functionality:
* Filter and sort data to focus on specific information
* Export data to a files for external use
* Insert or modify row data
* Create and manage schema, tables, views, and enums
You can access these tools in the **My Data** tab in the **Database** tool.
The following image shows a view from the Drizzle Studio user interface:
You can connect to your database using any PostgresSQL-compatible SQL client using the connection string found in your [environment variables](/_sites/docs.replit.com/cloud-services/storage-and-databases/sql-database#environment-variables)
.
###
[](#view-database-connection-credentials)
View database connection credentials
When you add a database, the Database tool automatically saves your connection credentials as environment variables in your Replit App. Your app uses the credentials to securely connect to the database and run commands.
How to access your database connection credentials
1. Navigate to the  **Database** tool in your workspace
2. Select the  **Commands** tab and scroll to the **Environment variables** section
The list includes the following environment variables, which you can reference from your Replit App’s code:
* `DATABASE_URL`: Database connection string which contains all details for a secure connection
* `PGHOST`: Database hostname
* `PGUSER`: Database username
* `PGPASSWORD`: Database password
To learn how to use these credentials in your code, see [Connect your app to a SQL database](/getting-started/quickstarts/database-connection)
.
###
[](#restore-tool)
Restore tool
The Restore tool lets you revert your database to a specific point in time. To activate this tool, you must select a retention period in the **History Retention** option. You can then restore from any point within that period.
Common uses for the Restore tool include the following:
* Recovering from accidental data deletion or corruption
* Reverting to a previous state for testing or debugging
* Reviewing historical data from a specific point in time
How to access the Restore tool and History Retention setting
1. Navigate to the  **Database** tool in your workspace
2. Select the  **Settings** tab and scroll to the **Restore** and **History Retention** sections
To restore your database to a specific time, follow the steps below:
1. Enter the target date and time in the **Timestamp** field
2. Select **Restore**. Select **Continue** to proceed in the confirmation dialog.
###
[](#remove-tool)
Remove tool
The remove action is irreversible. Make sure to back up any important data before proceeding.
If you no longer need a database for your Replit App, you can remove it and all its data.
How to remove a database
From the **Database** tool:
1. Select the **Settings** tab
2. Select **Remove database** and confirm by selecting **Yes, Remove Database**
###
[](#billing-and-resource-usage)
Billing and resource usage
Replit optimizes your cost savings for database usage by using Neon, a serverless database provider.
Neon’s serverless capabilities include the following:
* Zero infrastructure setup or maintenance
* Automatic scaling to handle your usage needs
* Compute time billing only when the database is active
The database enters an idle state after five minutes of inactivity, pausing compute time billing. It instantly reactivates when it receives a query.
To learn more about this serverless database technology, see the [Neon Compute lifecycle](https://neon.tech/docs/introduction/compute-lifecycle)
documentation.
Replit provides real-time tracking of your database usage. You can view the breakdown of compute time and storage usage for the current Replit App or for each Replit App on your account.
How to access database usage
To view your database compute time and storage usage for the current billing period, follow the steps below:
From the **Database** tool:
1. Navigate to the  **Database** tool in your workspace
2. Select the **Settings** tab
3. Scroll to the **Account resource usage** section to view a usage summary
To view for every Replit App on your account from the **Account resource usage** section, follow the steps below:
1. Select **View account resource limits** to open the **Usage** page
2. Scroll to **Resource usage** section
3. Expand the **PostgresSQL Storage** and **PostgresSQL Compute** rows for details on each Replit App
To learn how Replit charges for database usage, see [Deployments and Database Billing](/billing/about-usage-based-billing#databases)
.
###
[](#security-features)
Security features
When you add a database integration using **Agent**, it adds an Object-Relational Mapper (ORM) that handles all database communications with built-in security.
This ORM layer, combined with Agent’s security best practice implementation, protects your app from exploits through the following features:
* **Schema validation**: Verifies data conforms to expected formats
* **Data sanitization**: Automatically cleans up user input to prevent SQL injection attacks
Was this page helpful?
YesNo
[Previous](/category/storage-and-databases)
[Key-Value StoreLearn how to use Replit's built-in key-value database to store and manage data in your Replit Apps. No configuration required - just import and start coding.\
\
Next](/cloud-services/storage-and-databases/replit-database)
On this page
* [Features](#features)
* [Usage](#usage)
* [Add a database](#add-a-database)
* [Run database commands](#run-database-commands)
* [Browse and modify data visually](#browse-and-modify-data-visually)
* [View database connection credentials](#view-database-connection-credentials)
* [Restore tool](#restore-tool)
* [Remove tool](#remove-tool)
* [Billing and resource usage](#billing-and-resource-usage)
* [Security features](#security-features)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Storage and Databases
Storage and Databases
[Object Storage\
--------------\
\
3 items](/category/object-storage)
[SQL Database (PostgreSQL)\
-------------------------\
\
What is the Database tool?](/cloud-services/storage-and-databases/sql-database)
[Replit Key-Value Store\
----------------------\
\
What is the Replit Key-Value Store?](/cloud-services/storage-and-databases/replit-database)
Was this page helpful?
YesNo
[Previous](/cloud-services/deployments/troubleshooting)
[DatabaseDatabase is a Replit workspace tool that lets you set up a database for your apps to store and query your data.\
\
Next](/cloud-services/storage-and-databases/sql-database)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
March 2025
March 28, 2025
[### Matt Palmer\
\
Head of Developer Relations](https://x.com/mattppal)
[](#what%E2%80%99s-new)
What’s new
--------------------------------------
* [Agent v2 is now available](/_sites/docs.replit.com/updates/2025/03/28/changelog#agent-v2-is-now-available)
* [DeepLearning.AI course launch](/_sites/docs.replit.com/updates/2025/03/28/changelog#deeplearningai-course-launch)
* [Invoice threshold update](/_sites/docs.replit.com/updates/2025/03/28/changelog#invoice-threshold-update)
###
[](#agent-v2-is-now-available)
Agent v2 is now available
Agent v2 is now available for all users. This release brings significant performance improvements and new features to enhance the development experience. [Learn more about Agent v2](/replitai/agent)
and start building today.
###
[](#deeplearningai-course-launch)
DeepLearningAI course launch
Replit’s latest free course, Vibe Coding 101 with Replit, is now live on DeepLearningAI. This course takes you from idea to app in minutes, making software development more accessible. [Register for the course](https://www.deeplearning.ai/short-courses/vibe-coding-101-with-replit/?utm_campaign=replit-launch&utm_medium=partner&utm_source=replit)
and start your development journey today.
###
[](#invoice-threshold-update)
Invoice threshold update
The invoice threshold for core subscriptions has increased from to . This update reduces invoice frequency and payment-related service interruptions, creating a smoother experience for developers. The implementation includes comprehensive risk assessment and monitoring measures.
Was this page helpful?
YesNo
[Previous](/updates/2025/04/04/changelog)
[March 21, 20252 min read\
\
Next](/updates/2025/03/21/changelog)
On this page
* [What’s new](#what%E2%80%99s-new)
* [Agent v2 is now available](#agent-v2-is-now-available)
* [DeepLearningAI course launch](#deeplearningai-course-launch)
* [Invoice threshold update](#invoice-threshold-update)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Platforms
Replit Mobile App
In the Replit Mobile App, you can create, run, and deploy your apps using an app creation experience optimized for your smartphone or tablet. The mobile app provides the complete functionality of the web version on Replit.com.
[](#what-is-the-replit-mobile-app)
What is the Replit Mobile App
--------------------------------------------------------------------
The Replit Mobile App is a full-featured development environment, with an interface designed for touchscreens and mobile use. It provides access to the same workspace tools as the web version, allowing you create your app anywhere you have an internet connection.
[](#getting-started)
Getting started
----------------------------------------
Follow these steps to learn to install the app and create a Replit App.
###
[](#install-the-app)
Install the app
To install the app on your compatible mobile device, follow these steps:
1. Navigate to the [mobile app download page](https://replit.com/mobile)
and install the app for your mobile device OS.
2. Open the app and register for a new account or log in with an existing one. If you register for a new account, you must verify your email address to complete the process.
3. Create a new Replit App or select an existing one.
###
[](#create-an-app)
Create an app
You can start a new Replit App one of the following ways:
Create a new app using Agent
To access the Agent text area which lets you enter a prompt for AI to build your app, follow these steps:
1. Select **Create** in the dock at the bottom of the screen.
2. Toggle  Agent at the top of the screen.
3. Enter a description of the app you want Agent to build.
Create a new app from a Template
To start your app from a Template, follow these steps:
1. Select **Create** in the dock at the bottom of the screen.
2. Toggle the  angle brackets at the top of the screen.
3. Browse the selection of Templates or search for them by selecting the magnifying glass.
Create a new app from a GitHub repository
To start your app using files from a GitHub repository, follow these steps:
1. Select **Create** in the dock at the bottom of the screen.
2. Toggle the  angle brackets at the top of the screen.
3. Select **Import from URL** and complete the dialog prompts. To choose a private repository, select **Settings** and add a GitHub account that can access the repository.
[](#key-features)
Key features
----------------------------------
The Replit Mobile App includes the following features:
* **Workspace Tools**: Create fully functional apps using the same Replit workspace tools as the web version
* **Collaboration**: Work together using real-time multiplayer collaboration to build better projects faster
* **Deployment**: Publish your projects instantly with zero setup required to make them available for anyone to access
* **Templates**: Jumpstart your app using a Template from a community of over 15 million software creators
* **Custom domains**: Assign a custom domain to your project for a professional presence
[](#upgrade-your-plan)
Upgrade your plan
--------------------------------------------
To use Replit’s AI-powered tools beyond the free trial, you must upgrade to the Replit Core monthly or yearly subscription.
To subscribe using the mobile app, follow these steps:
1. Navigate to the **Account** section.
2. Select **Upgrade** to see the available plans.
3. Select the plan type that meets your needs and then select **Continue with Core**.
4. Follow the instructions specific to your mobile app store to complete payment.
[](#next-steps)
Next steps
------------------------------
* [Replit AI](/category/replit-ai)
: Learn about Replit’s AI-powered tools and their capabilities
* [Templates](/replit-workspace/templates)
: Learn what Templates are and how to create them
Was this page helpful?
YesNo
[Previous](/cloud-services/storage-and-databases/object-storage/typescript-api-reference/modules)
[Desktop AppThe Replit Desktop App for macOS, Windows, and Linux lets you create apps using all Replit's tools in a focused coding environment.\
\
Next](/platforms/desktop-app)
On this page
* [What is the Replit Mobile App](#what-is-the-replit-mobile-app)
* [Getting started](#getting-started)
* [Install the app](#install-the-app)
* [Create an app](#create-an-app)
* [Key features](#key-features)
* [Upgrade your plan](#upgrade-your-plan)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Storage and Databases
Key-Value Store
[](#what-is-the-relpit-key-value-store%3F)
What is the Relpit Key-Value Store?
----------------------------------------------------------------------------------
Replit Key-Value Store is a simple, user-friendly key-value store inside of every Replit App. No configuration is required; you can get started right away!
Here’s a short video on how to use the Replit database, or read the text explanation below.
[](#using-replit-key-value-store)
Using Replit Key-Value Store
------------------------------------------------------------------
Every Replit App can access and interact with its own unique Replit Key-Value Store. This database can be accessed from the library, and requires no configuration beyond import. Interacting with the Replit Key-Value Store follows much of the same syntax and logic as creating and interacting with the key-value pairs of a Python dictionary.
###
[](#importing-the-database)
Importing the database
To access the Replit database we use `import db`:
from replit import db
If you run into errors during deployment, make sure you’re using `replit` version 3.3.0 or above. For a Python Replit App, you can see what version you’re using by running `pip show replit`. To upgrade, run `upm add 'replit>=3.3.0'`.
###
[](#creating-data)
Creating data
The Replit Key-Value Store works a lot like a Python dictionary, so we can add data to our database by assigning values to keys using square bracket indexing:
from replit import db
# Add a key and associated value to the database
db["key1"] = "value1"
Replit Key-Value Store is able to handle different types of values like lists, dictionaries, integers, floats, NoneType, and strings:
from replit import db
db["key1"] = "value1"
db["integer_1"] = 100
db["float_1"] = 9.99
db["my_list"] = [1,2,3]
db["my_dictionary"] = {"key_a": "value_a", "key_b": "value_b"}
db["none_key"] = None
Make use of 2D lists as a value to create table-like structures within your database:
from replit import db
db["2D_key"] = [["id","name"],[1,"James"],[2,"Angel"]]
for column in db["2D_key"]:
print(column)
**Output:**
ObservedList(value=["id","name"])
ObservedList(value=[1,"James"])
ObservedList(value=[2,"Angel"])
The `ObservedList` object you see in the output is a Replit Key-Value Store object that acts like a Python list and can be indexed as such.
###
[](#reading-data)
Reading data
Read from your database by referencing the key of the value:
from replit import db
# Create data in the database
db["key1"] = "value1"
db["my_list"] = [1,2,3]
db["my_dictionary"] = {"key_a": "value_a", "key_b": "value_b"}
# Access and print data from the database
print(db["key1"])
print(db["my_list"][0])
print(db["my_dictionary"]["key_a"])
**Output:**
value1
1
value_a
We can use the built-in Python dictionary method `.get()` to retrieve the value at the key passed in as an argument:
from replit import db
# Create data for the database
db["float_1"] = 9.99
# Access the value of the data created by its key
print(db.get("float_1"))
We can loop through the keys stored in the database to get access to the values of those keys:
from replit import db
# Create data for the database
db["key1"] = "value1"
db["my_list"] = [1,2,3]
db["my_dictionary"] = {"key_a": "value_a", "key_b": "value_b"}
# Access the keys from the database and print the values associated for key in db
print(db.get(key))
The `.keys()` method returns a list of the keys in our database:
from replit import db
# Create data for the database
db["key1"] = "value1"
db["my_list"] = [1,2,3]
db["my_dictionary"] = {"key_a": "value_a", "key_b": "value_b"}
# Print all the keys from the database
print(db.keys())
**Output:**
{'key1', 'my_list', 'my_dictionary', '2D_keys'}
The `.prefix()` method allows us to get the values of keys with only part of that key. This allows us to return multiple values for keys that share the same prefix:
from replit import db
# Create data for the database
db["key1"] = "value1"
db["my_list"] = [1,2,3]
db["my_dictionary"] = {"key_a": "value_a", "key_b": "value_b"}
# Print all the keys from the database that have a prefix of "my"
print(db.prefix("my"))
**Output:**
('my_dictionary', 'my_list')
###
[](#updating-data)
Updating data
We can update values that are stored in our database by assigning new values to their associated key:
from replit import db
# Create data with "float_1" as key and print
db["float_1"] = 9.99
print(db[“float_1”])
# Update data at "float_1" key and print
db[“float_1”] = 3.33
print(db[“float_1”])
**Output:**
9.99
3.33
We can also mutate numbers that are stored in our database:
from replit import db
# Create data with "float_1" as key and print
db["float_1"] = 9.99
# Perform an operation on the data
db["float_1"] += 0.01
# Print result of operation
print(db["float_1"])
**Output:**
10.0
###
[](#deleting-data)
Deleting data
We make use of the `del` keyword and square bracket indexing to delete key-value pairings from our database:
from replit import db
# Create data for the database
db["float_1"] = 9.99
# Delete the data we added at the key "float_1"
del db["float_1"]
if "float_1" not in db:
print("Value deleted successfully.")
**Output:**
Value deleted successfully.
###
[](#summary)
Summary
Overall, the Replit Key-Value Store is a simple and useful database that allows us to easily and dynamically update our data. The features resembling the Python dictionary mean we can use the built-in Python dictionary functions to interact with our database.
[](#faqs)
FAQs
------------------
###
[](#where-can-i-find-my-store%3F)
Where can I find my store?
When viewing your Replit App, you’ll find the Replit Key-Value Store icon toward the bottom of the sidebar – it’s the second last icon. That’s Replit’s key-value database, built right into your Replit App!
###
[](#how-can-i-access-my-store%3F)
How can I access my store?
To access the Replit Key-Value Store, you can use a library or simple curl commands.
Replit provides official clients. Use one of these clients if your Replit App is in one of these languages:
* [Python](https://pypi.org/project/replit/)
* [Node.js](https://www.npmjs.com/package/@replit/database)
* [Go](https://github.com/replit/database-go)
###
[](#how-do-i-use-my-store%3F)
How do I use my store?
When you click on the Replit Key-Value Store icon in the sidebar, you’ll see some instructions. If your Replit App is in a language that has an official Replit Key-Value Store client, you can quickly import it and start using Replit Key-Value Store by clicking on the “Insert” buttons.
If your language does not have a client, we provide some usage examples below. They are found below, and are a useful reference if you wish to write your own Replit Key-Value Store client.
**Set**
curl $REPLIT_DB_URL -d '='
If your key and value don’t use any unsafe characters, you can use an alternative version:
curl -XPOST $REPLIT_DB_URL/=
**Get**
curl $REPLIT_DB_URL/
**Delete**
curl -XDELETE $REPLIT_DB_URL/
`Delete` returns status code 204 if the key was deleted or 404 if the key did not exist.
**List**
curl $REPLIT_DB_URL --get -d 'prefix='
or
curl "$REPLIT_DB_URL?prefix="
The returned keys will be separated by newlines.
Listing also takes a query parameter: `encode=true`. If set, the returned keys will be URL encoded. This lets you safely handle keys that contain newlines.
###
[](#what-is-replit-db-url%3F)
What is REPLIT\_DB\_URL?
This is the environment variable we have created with your Replit App. It is the key that will allow you to access your database.
The clients listed above take care of using `REPLIT_DB_URL` for you, but you will need it if you want to write your own client or use a database from a language that doesn’t yet have a client. Here are two examples:
Python:
import os
print(os.getenv("REPLIT_DB_URL"))
Node.js:
console.log(process.env.REPLIT_DB_URL)
`REPLIT_DB_URL` provides full access to your database. Therefore, you should take care not to expose it to the world or share it with people you don’t trust.
The value of `REPLIT_DB_URL` changes from time to time, so we recommend that you don’t copy it elsewhere. Subsequent reads by the same process will see the same value. We will restart your Replit App if we need to change it after it has been read.
Note: `REPLIT_DB_URL` is not available in Deployments. Instead, the value of the URL is stored in `/tmp/replitdb`. If you are writing a client for Replit Key-Value Store, read the value from `/tmp/replitdb` first, and fall back to the environment variable if that file does not exist.
###
[](#what-limits-does-replit-key-value-store-have%3F)
What limits does Replit Key-Value Store have?
The limits are currently:
* 50 MiB per store (sum of keys and values)
* 5,000 keys per store
* 1000 bytes per key
* 5 MiB per value
There are rate limits that apply to all operations. You will receive an HTTP 429 if you exceed them. We recommend implementing an exponential backoff and retry to handle this case.
###
[](#how-can-i-tell-how-much-storage-i%E2%80%99m-using%3F)
How can I tell how much storage I’m using?
The Replit Key-Value Store pane tool in the sidebar shows you the number of keys in your store along with the total storage occupied by your keys and values.
###
[](#is-my-store-private%3F)
Is my store private?
Yes, each store is private and isolated. Every Replit App has its own database, and they are not shared among Replit App.
###
[](#how-do-i-share-a-store-across-replit-app%3F)
How do I share a store across Replit App?
The easiest way to do this is to use one Replit App as the primary store and have other Replit App connect to it via web hosting. [Here’s an example Replit App in Python](https://replit.com/@util/Replit-Database-proxy)
.
Any requests sent to the above Replit App will operate on its store, so sending requests to it from other Replit App means that they all share the same information.
Was this page helpful?
YesNo
[Previous](/cloud-services/storage-and-databases/sql-database)
[OverviewLearn how to use Replit's object storage service to store and manage data objects in buckets with Python and TypeScript APIs.\
\
Next](/category/object-storage)
On this page
* [What is the Relpit Key-Value Store?](#what-is-the-relpit-key-value-store%3F)
* [Using Replit Key-Value Store](#using-replit-key-value-store)
* [Importing the database](#importing-the-database)
* [Creating data](#creating-data)
* [Reading data](#reading-data)
* [Updating data](#updating-data)
* [Deleting data](#deleting-data)
* [Summary](#summary)
* [FAQs](#faqs)
* [Where can I find my store?](#where-can-i-find-my-store%3F)
* [How can I access my store?](#how-can-i-access-my-store%3F)
* [How do I use my store?](#how-do-i-use-my-store%3F)
* [What is REPLIT\_DB\_URL?](#what-is-replit-db-url%3F)
* [What limits does Replit Key-Value Store have?](#what-limits-does-replit-key-value-store-have%3F)
* [How can I tell how much storage I’m using?](#how-can-i-tell-how-much-storage-i%E2%80%99m-using%3F)
* [Is my store private?](#is-my-store-private%3F)
* [How do I share a store across Replit App?](#how-do-i-share-a-store-across-replit-app%3F)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Platforms
Replit Desktop App
In the Replit Desktop App, you can create, run, and deploy your apps using a native application for your desktop environment. The desktop app provides the complete functionality of the web version on Replit.com.
[](#what-is-the-replit-desktop-app)
What is the Replit Desktop App
----------------------------------------------------------------------
The Replit Desktop App is a full-featured development environment, packaged as a standalone app that runs on your desktop or laptop. You can access the same workspace tools as the web version, allowing you to create your app without the distractions of a browser.
[](#getting-started)
Getting started
----------------------------------------
Follow these steps to install the Replit Desktop App and create a Replit App.
###
[](#install-the-app)
Install the app
To install the app compatible with your operating system, follow these steps:
1. Navigate to the [desktop app download page](https://replit.com/desktop)
.
2. After downloading, open the file and follow the installation instructions.
3. Open the app and log in with your existing Replit account.
The macOS and Windows desktop apps automatically update when you launch them. You must manually update the Linux desktop app.
###
[](#create-an-app)
Create an app
After logging into your Replit account, follow these steps to create a new Replit App:
1. In the desktop app, select **Create App**.
2. The desktop app opens a new browser tab on Replit.com titled **Create a new App**.
3. Follow the prompts to create your new Replit App in the browser. Take note of the Replit App name.
4. Switch to the desktop and select the app you created from the **Recent** list. Alternatively, locate the app by typing the name in the **Search Apps** field.
###
[](#open-an-existing-app)
Open an existing app
To open an existing Replit App in the Replit Desktop app, follow these steps:
1. Select the  Replit icon in the top left.
2. Select the app you want to open from the list. Alternatively, locate the app by typing the name in the **Search Apps** field.
[](#key-features)
Key features
----------------------------------
* **Focused environment**: Create your app without the distractions of working from a web browser
* **Complete toolset**: Access the same tools as the web version to create, run, and deploy your app
* **Customizable workspace**: Arrange tools on your screen and use keyboard shortcuts to maximize productivity
[](#next-steps)
Next steps
------------------------------
* [Introducing the Replit Desktop App](https://blog.replit.com/desktop-app)
: Read the Replit Desktop App announcement on the Replit blog.
* [Replit AI](/category/replit-ai)
: Learn about Replit’s AI-powered tools and their capabilities
Was this page helpful?
YesNo
[Previous](/platforms/mobile-app)
[OverviewLearn about Replit Core membership features and benefits to enhance your development experience with advanced tools and capabilities.\
\
Next](/category/replit-core)
On this page
* [What is the Replit Desktop App](#what-is-the-replit-desktop-app)
* [Getting started](#getting-started)
* [Install the app](#install-the-app)
* [Create an app](#create-an-app)
* [Open an existing app](#open-an-existing-app)
* [Key features](#key-features)
* [Next steps](#next-steps)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Core
Overview
[Replit Core](https://replit.com/replit-core)
is the membership to unlock the full Replit experience.
####
[](#ai-powered-tools)
AI-powered tools
Debug code, get intelligent autocomplete suggestions, and convert natural language to code with one click.
####
[](#lightning-fast-and-secure-workspace)
Lightning-fast and secure workspace
* A high-powered 8 GiB RAM and 4 vCPU cloud development environment with the option to upgrade.
* Generous network bandwidth (100 GiB) and storage (50 GiB), so you’ll never run out of resources.
* Additional security capabilities like SSH access and private Replit Apps to control sharing.
####
[](#monthly-credits)
Monthly credits
* Core / Teams Members have access to / in monthly credits per month that they can use on any of our paid services, such as AI, Autoscale Deployments, Reserved VM Deployments, Outbound Data Transfer, and Postgres.
####
[](#one-click-deployments)
One-click Deployments
* Use the included monthly credits to deploy your applications.
* Built-in logging & analytics.
####
[](#priority-support-and-community-events)
Priority support and community events
* Help when you need it with dedicated 1:1 support
* Access to members-only events
* Early access to new features
Was this page helpful?
YesNo
[Previous](/category/replit-core)
[OverviewLearn how to earn Cycles by completing coding tasks or post your own Bounties to get help with development projects on Replit.\
\
Next](/category/bounties)
On this page
* [AI-powered tools](#ai-powered-tools)
* [Lightning-fast and secure workspace](#lightning-fast-and-secure-workspace)
* [Monthly credits](#monthly-credits)
* [One-click Deployments](#one-click-deployments)
* [Priority support and community events](#priority-support-and-community-events)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Replit Core
Replit Core
[Replit Core Overview\
--------------------\
\
Replit Core is the membership to unlock the full Replit experience.](/replit-core/replit-core)
Was this page helpful?
YesNo
[Previous](/platforms/desktop-app)
[IntroductionLearn about Replit Core membership features including AI coding assistance, powerful workspaces, monthly credits, deployments, and exclusive perks.\
\
Next](/replit-core/replit-core)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Bounties
Bounties
[Earning with Replit Bounties\
----------------------------\
\
Bounties on Replit allow you to request and pay for coding tasks or project work using Cycles. Create a Bounty for tasks like product development or API integration.](/additional-resources/bounties/bounty-hunting)
[Posting and awarding a Bounty\
-----------------------------\
\
Posting Bounties on Replit is easy and similar to freelancing platforms. Create and award tasks to Bounty Hunters.](/additional-resources/bounties/posting-a-bounty)
[Resources for Bounty Hunters\
----------------------------\
\
Access helpful templates and resources to enhance your Bounty Hunting experience.](/additional-resources/bounties/hunter-resources)
[Bounty Templates\
----------------\
\
Check out the templates for creating your Bounties and communicating expectations clearly.](/additional-resources/bounties/bounty-templates)
[Frequently Asked Questions (FAQ)\
--------------------------------\
\
Learn more about what Bounties are and how they work with our FAQ section.](/additional-resources/bounties/faq)
Was this page helpful?
YesNo
[Previous](/replit-core/replit-core)
[Earning with Replit BountiesBounties on Replit allow you to request and pay for coding tasks or project work using a platform-specific currency called Cycles. When you have a specific need—such as developing a new product, needing coding help for a personal project, or requiring API integration—you can create a Bounty. This acts as a job posting that other members, known as Bounty Hunters, can accept to complete the specified task.\
\
Next](/additional-resources/bounties/bounty-hunting)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Bounties
Posting and awarding a Bounty
If you’re familiar with other freelancing platforms, Bounties will feel familiar.
###
[](#check-cycles)
Check Cycles
Before you post a Bounty, ensure you have enough [Cycles](/getting-started/intro-replit)
to pay the Bounty. Once the Bounty is listed, Replit will hold the Cycles as a deposit until the Bounty is completed or closed.
###
[](#post-a-bounty)
Post a Bounty
1. On the [Bounties page](https://replit.com/bounties)
, click the “Create a Bounty” button in the upper-right-hand corner of the screen.
2. Fill out the “Create a Bounty” form, adding as much detail as you can so Bounty Hunters know what they’re applying to do. Write a clear title and _pay special attention defining acceptance criteria_, as this is going to guide your Bounty Hunter’s decisions and will be referred to when settling disputes. Set the due date, your preferred method of communication, and the number of Cycles you’re offering for the work.
3. Post your Bounty!
You are not allowed to circumvent Bounties by taking projects off-platform. This includes promising payments outside the Bounties system or any future promise of work outside Bounties. You could be banned permanently for attempting to do so.
###
[](#wait-for-applications)
Wait for applications
Sit back and wait for Bounty Hunters to apply!
###
[](#pick-an-applicant-and-communicate-well)
Pick an applicant and communicate well!
Once you have a Bounty Hunter you’d like to work with, click the “Accept Application” button. This closes the Bounty to further applications.
Now it’s your turn to reach out to the Bounty Hunter you’ve selected! (Be sure you’re both clear on deliverables and timeline expectations)
###
[](#review-the-work)
Review the work
When your Bounty Hunter has completed the work, you’ll see the following screen that allows you to view the work. After checking out the work, you can request changes or accept the work.
If you request changes, be sure to give your Bounty Hunter clear and actionable feedback within the bounds of the original Bounty.
_Please do not use this mechanism to add features or increase the project’s scope - if you need another feature, make another bounty!_
Once you’re happy with the work, Accept it, and the Bounty process is complete. The code now belongs to you, and Replit will send the Cycles deposit to the Bounty Hunter.
[](#bounty-poster-feature-tutorial)
Bounty Poster Feature Tutorial
----------------------------------------------------------------------
Check out the [Bounty Poster Feature Tutorial](https://replit.com/@replit/Bounty-Poster-Tutorial)
.
Was this page helpful?
YesNo
[Previous](/additional-resources/bounties/bounty-hunting)
[Resources for Bounty HuntersFind templates, portfolio tips, and tutorials to help you succeed as a Replit bounty hunter. Learn how to showcase your work and build your skills.\
\
Next](/additional-resources/bounties/hunter-resources)
On this page
* [Check Cycles](#check-cycles)
* [Post a Bounty](#post-a-bounty)
* [Wait for applications](#wait-for-applications)
* [Pick an applicant and communicate well!](#pick-an-applicant-and-communicate-well)
* [Review the work](#review-the-work)
* [Bounty Poster Feature Tutorial](#bounty-poster-feature-tutorial)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Bounties
Earning with Replit Bounties
If you’re interested in building projects and earning Cycles while doing it, you’re in for a treat with Bounties.
[](#become-a-bounty-hunter)
Become a Bounty Hunter
------------------------------------------------------
If you’d like to become a verified Bounty Hunter, [apply here](https://replit.typeform.com/to/ss7IxmIf)
. Fill out the form, and you’ll receive the Verified Bounty Hunter badge notification on your applications.
Otherwise, you can get started by checking out the [Bounties page](https://replit.com/bounties)
and applying to earn Cycles.
[](#browse-bounties)
Browse Bounties
----------------------------------------
Each posted Bounty includes a reward in Cycles for successful completion and a description of the work they need.
[](#apply-to-work-on-a-bounty)
Apply to work on a Bounty
------------------------------------------------------------
Once you find a Bounty you’re interested in, select the “Apply to Work” button in the upper-right corner.
###
[](#tips-for-applying)
Tips for Applying
The best Bounty applications explain to the Poster why you’re a good fit for the job and include examples of your past work. Here are some additional tips for creating a quality application:
Here are some other tips on how to create a quality application:
* Add links to your GitHub, LinkedIn, Twitter, or other social profiles to your Replit account. These links will also appear in your Bounty applications.
* Consider using a professional headshot as your Replit profile picture.
* If you’d like to start your Bounty application with a greeting, you can say something like `Hello [username]...` or `Hello, my name is [your first name]...`
* Include links to relevant projects in your application, such as a Replit App, GitHub repo, or hosted project.
* Describe the initial 1-2 milestones you plan to accomplish once accepted. This shows the Bounty Poster that you understand their problem and the technical requirements.
* If possible, provide time estimates for completing certain parts of the Bounty after you’re accepted.
Here’s an example application for a Bounty to create a space invaders game:
[](#do-the-work)
Do the work
--------------------------------
If the Bounty Poster selects your application, you’ll see the “Accepted” badge on your application:
Now it’s time to do the work! Communicate with the Bounty Poster early and often - make sure you’re both clear on requirements and expectations.
[](#deliver-the-work)
Deliver the work
------------------------------------------
When you’ve completed your work, return to the Bounty page and select “Submit Work.”
Add a description of the work (pro-tip: relate it to the acceptance criteria outlined in the Bounty) and link to the Replit App where you’ve written the code.
The Poster will review your work and may request changes. If these changes are within the scope of the original Bounty, simply make the updates in the Replit App and submit again. Once the Poster accepts your work, you’re awarded your well-earned Cycles.
Was this page helpful?
YesNo
[Previous](/category/bounties)
[Posting and awarding a BountyLearn how to post a bounty, manage applications, and review work submissions on Replit's bounty platform to get help with your projects.\
\
Next](/additional-resources/bounties/posting-a-bounty)
On this page
* [Become a Bounty Hunter](#become-a-bounty-hunter)
* [Browse Bounties](#browse-bounties)
* [Apply to work on a Bounty](#apply-to-work-on-a-bounty)
* [Tips for Applying](#tips-for-applying)
* [Do the work](#do-the-work)
* [Deliver the work](#deliver-the-work)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Bounties
Resources for Bounty Hunters
[](#templates)
Templates
----------------------------
Need some boilerplate code? Use these templates to get started on your next Bounty:
* [Bots](https://replit.com/templates/bots)
* [Graphics](https://replit.com/templates/graphics)
* [Websites](https://replit.com/templates/websites)
* [AI](https://replit.com/templates?q=AI)
[](#replit-profile-tips)
Replit Profile Tips
------------------------------------------------
Use [this template](https://replit.com/@replit/Portfolio-Site-Template?v=1#ReadMe.md)
to create a portfolio of work to pin to your profile.
Add links to previous work, Github profile, Discord, etc. in your profile that are relevant and up to date.
Make sure the Replit Apps on your profile are a good representation of your skills.
Don’t include partial pieces of work on your profile page (hide those in a folder or use Private Replit Apps).
The Replit-generated names like PuzzlingPriceyKey are cool and all, but make sure the Replit Apps on your profile have sensible names and are published with nice cover photos.
[](#build-your-portfolio)
Build your Portfolio
--------------------------------------------------
Use these tutorials and projects as inspiration to add to your portfolio:
* [Intro to JS](https://replit.com/learn#:~:text=This%20tutorial-,covers,-the%20basics%20of)
: Understand the basics of JS
* [Socket.IO](https://replit.com/learn#:~:text=Socket.IO-,Tutorial,-Learn%20how%20to)
: build a multi-player app
* [Intro to Bash](https://replit.com/learn#:~:text=Intro%20to-,Bash,-Bash%20is%20one)
: learn how to read and print files, create games, and run program files as scripts
* [Chatbot](https://replit.com/@QwertyQwerty54/Chatbot?v=1)
: browse the code used to make a chatbot with Python
* [AI Basics with Hangman](https://replit.com/@WyattGeorge/AI-Hangman?v=1)
: create your own version and add it to your portfolio to showcase your AI skills
Check out the [Bounty Hunter Feature Tutorial](https://replit.com/@replit/Bounty-Hunters-Tutorial)
to learn more.
Was this page helpful?
YesNo
[Previous](/additional-resources/bounties/posting-a-bounty)
[Bounty TemplatesLearn how to communicate effectively during bounty projects with templates for both bounty hunters and posters to use throughout the process.\
\
Next](/additional-resources/bounties/bounty-templates)
On this page
* [Templates](#templates)
* [Replit Profile Tips](#replit-profile-tips)
* [Build your Portfolio](#build-your-portfolio)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Bounties
Bounty Templates
[](#communication-expectations)
Communication Expectations
--------------------------------------------------------------
Effective communication is vital throughout the bounty posting and hunting process. To help with this, we’ve provided templates that you can use to maintain professionalism and ensure everyone’s expectations align. Keep in mind that these templates are starting points and can be adjusted to suit your specific needs.
[](#bounty-hunter)
Bounty Hunter
------------------------------------
###
[](#upon-acceptance)
Upon Acceptance
After accepting a bounty, it’s important to reach out to the Poster within 24 hours via email or Discord.
Hello there,
I'm very excited to begin working on this Bounty. I am located in . I usually work between the hours of and the best way to reach me is by email. I just wanted to take a moment to check in and outline my approach.
- -
- -
Please let me know if you have any questions. I look forward to working with you.
Best,
Your Name
###
[](#check-ins)
Check-ins
To ensure a smooth and successful Bounty experience, it is important to maintain regular communication with the Bounty Poster. This includes providing updates on progress every few days, as well as addressing any roadblocks, pain points, or questions that may arise. Lack of visibility into the progress of the project is a common cause of dissatisfaction among Bounty Posters. Keeping them informed will help to mitigate this issue and maintain a positive working relationship.
####
[](#what-to-say-when-giving-a-status-update%3A)
What to say when giving a status update:
I wanted to check-in and give you an update on my progress. Everything is going well, and I am still on target to meet by . Please reach out if you have any questions or need further information about this Bounty.
####
[](#what-to-say-when-you-need-to-change-the-timeline%3A)
What to say when you need to change the timeline:
I wanted to give you an update on my timeline. has taken longer than I expected due to reasons. I have been able to determine next steps, but wanted to let you know my date has changed to . I have solved any current roadblocks and am on track to complete the Bounty.
###
[](#upon-submission)
Upon Submission
Congratulations on successfully completing the Bounty! It is now important to promptly follow up with the bounty poster to allow them to review the completed work. This will provide an opportunity for them to provide feedback or request any necessary changes. Following up quickly will help ensure a smooth process and timely completion of the project.
Hi there,
I have submitted the completed Bounty at . Please let me know if you request changes or have any questions about the submission. It has been a pleasure working with you.
###
[](#changes-are-requested)
Changes are Requested
If the Bounty Poster requests any changes, it is important to respond within 24 hours to acknowledge receipt of their feedback. During this response, it is crucial to discuss a plan for the next steps and a timeline for implementing the suggested updates. It is important to approach any requested changes in a constructive manner. To assist with this process, the following are the two templates you can personalize
Example:
Thank you for . I value your feedback as it helps me become a better Bounty Hunter. I will have a revised version of this project ready for you to review by .
One solution to the input you mentioned is . Does this sound like an ideal solution for your Bounty? If so, I can have an updated version for you by .
Example:
I know you are concerned about . Including may be an ideal solution.
I am open to revisions and willing to make changes to improve the quality of your work. If this solution works for you, I can get you an updated version by .
[](#poster)
Poster
----------------------
###
[](#upon-acceptance-2)
Upon Acceptance
Once you accept a Bounty Hunter for your Bounty, you should reach out to them within 24 hours via email or Discord. Feel free to use this template if you are not sure how to start.
Hi ,
I am excited to work with you on this Bounty. You seem like a great fit for this project. Here is a little bit about me .
I would like to chat with you soon to review requirements and set milestones.
Please let me know if you have any questions about the Bounty as you get started.
###
[](#check-ins-2)
Check-ins
Open and consistent communication with the Bounty Hunter is crucial, especially if the project is complex or has multiple milestones. This will help ensure that the project stays on track and is completed within the agreed-upon timeframe. Here are a few examples of what you can say to stay in touch with your Bounty Hunter:
Hi,
I wanted to check in and see how the Bounty was going. Do you have any questions about the requirements? I am happy to chat if you need further guidance.
Hello,
How is the Bounty going? Do you think you are still on track to complete it by ? Do you have any part of it completed that you can send to me as a sample? Please let me know if you have any questions.
###
[](#upon-submission-2)
Upon Submission
Once your Bounty Hunter submits the Bounty, we recommend you review the submission within three days. If you’re happy with the submission, feel free to press the `Accept` button to complete the Bounty and release the Cycles to the Bounty Hunter. Send them a thank you or acknowledgment that the work has been received and the Cycles released.
Hi,
Just received your submission. It looks great. Thank you for all your hard work on this.
###
[](#changes-requested)
Changes Requested
You can request changes on your Bounty’s Discussion tab. It is important that the changes you request are within the scope of the original project. Give clear expectations of what needs to be changed and ensure the Bounty Hunter has the correct resources or access to test projects if needed.
Hello,
Thanks for your submission! Would you be up for changing the following:
.
Was this page helpful?
YesNo
[Previous](/additional-resources/bounties/hunter-resources)
[Frequently Asked Questions (FAQ)Learn how to post and complete Bounties on Replit, including pricing guidelines, payment processes, and best practices for both Bounty Posters and Hunters.\
\
Next](/additional-resources/bounties/faq)
On this page
* [Communication Expectations](#communication-expectations)
* [Bounty Hunter](#bounty-hunter)
* [Upon Acceptance](#upon-acceptance)
* [Check-ins](#check-ins)
* [What to say when giving a status update:](#what-to-say-when-giving-a-status-update%3A)
* [What to say when you need to change the timeline:](#what-to-say-when-you-need-to-change-the-timeline%3A)
* [Upon Submission](#upon-submission)
* [Changes are Requested](#changes-are-requested)
* [Poster](#poster)
* [Upon Acceptance](#upon-acceptance-2)
* [Check-ins](#check-ins-2)
* [Upon Submission](#upon-submission-2)
* [Changes Requested](#changes-requested)
---
# Replit Docs
[Replit home page](/)
Search or ask...
Search...
Navigation
Additional Resources
Add a "Made with Replit" badge to your Webview
You can add a “Made with Replit” badge in your public Replit App’s Webview. It will link back to your Replit App’s cover page so that visitors can learn more about your creations.
[](#what-is-the-webview%3F)
What is the Webview?
----------------------------------------------------
The Webview is the view of your Replit App that visitors to your Replit App see when they click “Open website.”
The Webview appears full-screen in its own browser window, and has the following URL format:
`https://UNIQUE-TOKEN.CLUSTER_NAME.replit.dev`
(Or at your custom domain if you’ve set one up)
[](#adding-the-badge)
Adding the Badge
------------------------------------------
You can add a badge to any Replit App with an index page. Any website created with the official HTML template will have this badge added by default.
1. Go to your Replit App’s file browser and find `index.html`
2. Add the following code before the closing `` tag: