---
title: "Create deploys"
description: "Discover different methods of deploying a site using our platform. Take advantage of continuous deployment, manual deployment, or integration options."
---
This page covers features and tools you can use to create deploys with or without continuous deployment.
### Note - Note
When you create a deploy manually without continuous deployment, Netlify does not run a build command.
## Deploy with Git
> **Video**: [Watch video](https://www.youtube.com/embed/4h8B080Mv4U)
Continuous deployment works by connecting a Git repository to a Netlify site and keeping the two in sync. This is done using the Git provider's OAuth2 authentication or the Netlify GitHub App.
After you set up [Git provider permissions]( /build/git-workflows/repo-permissions-linking#git-provider-permissions) and link a repository, Netlify will run your build command and deploy the result whenever you push to your Git repo. The benefits of Netlify's continuous deployment include:
- No deploying without committing and pushing first
- Easy collaboration through pull/merge requests
- Fix a typo through your Git provider's web UI from your mobile
- Edit content without code by using a CMS
## Netlify CLI
You can use the CLI to [set up continuous deployment](/api-and-cli-guides/cli-guides/get-started-with-cli#continuous-deployment) for a Git repository. Once continuous deployment is configured, you can update your Production site, staging site, or Deploy Preview with `git push`.
You can also use the CLI to [create manual deploys](/api-and-cli-guides/cli-guides/get-started-with-cli#manual-deploys) without continuous deployment. For example, you can deploy directly to your production site from the command line with `netlify deploy --prod`.
## Drag and drop
> **Video**: [Watch video](https://www.youtube.com/embed/etZ9HSUoTPU)
### Note - Tip
For easiest deployment and management, make sure you're already logged in to the team where you want your site project to be on Netlify.
You can create a new site by dragging a project folder containing your site files (like .html files) to
### NavigationPath Component:
Netlify Drop
. You can also find a drag and drop section at the bottom of your
### NavigationPath Component:
team's Projects page
.
If you need to update a site that you created using drag and drop, update and rebuild your project locally. Then, drag the project's updated output folder to the deploy dropzone at the bottom of the site's **Deploys** page. This will start a new site deploy with the updated files. You can also use this functionality to manually update any site that is not connected to a Git repository.
## API endpoints
You can use the [API](/api-and-cli-guides/api-guides/get-started-with-api#deploy-with-the-api) to create deploys manually using a file digest or a ZIP file.
## Deploy to Netlify button
The **Deploy to Netlify** button helps users deploy new sites from templates with one single click. Web developers can use the button to give their users a one-click way to deploy those applications on Netlify.
It's designed to be used in README files, documentation sites, and probably anything that renders as an HTML file.
You can find examples of the button in use in the READMEs on our [templates](https://github.com/netlify-templates).
The template code must be available in a public repository stored on GitHub.com or GitLab.com.
### Markup
You can use any markup language that renders as HTML to display the button. There are two very important URLs that you'll need:
- The SVG URL for the button: `https://www.netlify.com/img/deploy/button.svg`.
- The URL the button takes users to: `https://app.netlify.com/start/deploy`. This link requires the public Git repository as a parameter, for example:
```txt
https://app.netlify.com/start/deploy?repository=https://github.com/netlify/netlify-statuskit
```
You can make the button clone a whole repository or just a [portion of a repository](#clone-a-subdirectory-of-a-repo). Both are good options for monorepos but you may need to [set a base directory](#set-a-base-directory-for-monorepos) if the button clones the whole repository.
Here is an example of the full Markdown or HTML code for a Deploy to Netlify button that deploys the [Netlify StatusKit template](https://github.com/netlify/netlify-statuskit):
### Tabs Component:
```md title="Markdown"
[](https://app.netlify.com/start/deploy?repository=https://github.com/netlify/netlify-statuskit)
```
```html title="HTML"
```
If your repository uses extensions built with [Netlify's SDK](https://developers.netlify.com/sdk/get-started/introduction), you can add the URL parameter `fullConfiguration=true` to make users go through an extra step where they'll be able to install required extensions, choose a site name, and configure their new repository before deploying the site.
### File-based template configuration
You can control some aspects of template configuration directly in the template's Git repository.
Create a `netlify.toml` file in the root of the repository, if you don't have it already. Netlify will read the information from there. If your Deploy to Netlify button [clones just a subdirectory of the repository](#clone-a-subdirectory-of-a-repo), create the `netlify.toml` file in that subdirectory so that the file ends up in the root of the cloned repository. This file can also be used to set options for continuous deployment, you can read more about it in the [file-based configuration documentation](/build/configure-builds/file-based-configuration).
Within the `[template]` section of the `netlify.toml`, you can set three directives:
- A list of incoming hooks for the users site. This is very useful if you want to allow a third party service to control when to deploy the site. This is what headless CMS services like Contentful and DatoCMS do. Users can give those providers the address Netlify generates for their specific incoming requests.
```toml
[template]
incoming-hooks = ["Contentful"]
```
- A list of required environment variables. This is one way to let users set specific configuration options upon deployment. It also enables customization without having to change the code of the base template. If you don't want to use a `netlify.toml` file, you can instead use the [URL hash](#require-or-set-environment-variables) to require or even pre-fill environment variables.
```toml
[template.environment]
SECRET_TOKEN = "change me for your secret token"
CUSTOM_LOGO = "set the url to your custom logo here"
```
The placeholder strings you set in `netlify.toml` are used as labels in the UI to provide guidance to users deploying your template.
- A list of required extension slugs. [Extensions](/extend/install-and-use/extensions-and-integrations/) expand the capabilities of a site deployed on Netlify. This is useful if you wish to specify your template depends on specific Netlify extensions to work as expected. If you define `required-extensions`, users will be prompted to install the extensions, to allow them to get up and running faster. This can be combined with the optional parameter `fullConfiguration=true` if you wish to force users to install the extension(s) prior to the first deploy of their site.
```toml
[template]
required-extensions = ["supabase"]
```
Note that you can't do the following in this `[template]` section:
- Set values for environment variables. To pre-fill environment variable values, use [URL-based template configuration](#require-or-set-environment-variables).
- Set a base directory for the Deploy to Netlify button. To set a base directory for sites deployed with the button, use the [`base` query parameter](#set-a-base-directory-for-monorepos) instead.
### URL-based template configuration
You can control the following aspects of how the template repo is cloned and how the resulting site is configured by passing values in the Deploy to Netlify URL:
- [require or set environment variables](#require-or-set-environment-variables)
- [set a base directory](#set-a-base-directory-for-monorepos)
- [clone a subdirectory](#clone-a-subdirectory-of-a-repo)
- [deploy a specific branch](#deploy-a-specific-branch)
#### Require or set environment variables
You can require or set environment variables for the site template in the hash of the template's Deploy to Netlify URL with key/value pairs. Values can be null.
```txt
https://app.netlify.com/start/deploy?repository=https://github.com/myworkspace/sweetkittentemplate#SECRET_TOKEN=specialuniquevalue&CUSTOM_LOGO=
```
Passing environment variable values in the hash ensures that they're processed on the client side only. You can create custom Deploy to Netlify buttons for your users with tokens and other secure data, and they won't appear in Netlify logs.
#### Set a base directory for monorepos
If your Deploy to Netlify button clones a whole monorepo rather than [a single subdirectory](#clone-a-subdirectory-of-a-repo), you can use the `base` query parameter to set an alternate directory as the [base directory](/build/configure-builds/monorepos#definitions) for deployments. The format is `&base=your-base-directory`. Note that while Netlify uses the specified base directory for the build and deploy, the entire repo is still cloned to the user's Git provider account.
For example, here's a URL with a base directory of `blog`:
```txt
https://app.netlify.com/start/deploy?repository=https://github.com/myworkspace/sweetkittentemplate&base=blog
```
When someone uses this Deploy to Netlify button, Netlify clones the whole `sweetkittentemplate` repository to the user's Git provider account and then builds and deploys from the `blog` subdirectory.
Note the following limitations:
- [Template configuration](#template-configuration) to set incoming hooks and environment variables can only be used at root level and can't be used for sites with a different base directory. When you set an alternate base directory, the `netlify.toml` in the base directory will take precedence over the root level configuration for that site's builds.
#### Clone a subdirectory of a repo
To make a Deploy to Netlify button clone just a part of a repo, use the `create_from_path` query parameter to specify a subdirectory to clone. The format is `&create_from_path=your-subdirectory`.
For example, here's a URL with a creation path of `examples/hello`:
```txt
https://app.netlify.com/start/deploy?repository=https://github.com/myworkspace/demos&create_from_path=examples/hello
```
When someone uses this Deploy to Netlify button, Netlify clones just the subdirectory `examples/hello` from the `demos` repo to the user's Git provider account and then builds and deploys from the root of the cloned repository.
#### Deploy a specific branch
To make a Deploy to Netlify button deploy a branch other than the default branch, use the `branch` query parameter. The format is `&branch=your-branch`.
For example, here's a URL that will deploy the `beta-feature` branch:
```txt
https://app.netlify.com/start/deploy?repository=https://github.com/myworkspace/app&branch=beta-feature
```
When someone uses this Deploy to Netlify button, Netlify sets the new site's [production branch](/deploy/deploy-overview#definitions) to `beta-feature` and then builds and deploys from that branch of the cloned repository.
### Define additional instructions
You can define additional configuration instructions in the `USAGE.md` file, which should be saved in the root of your repository. This can be useful to include guidance on setting up any required third-party service accounts (such as databases, content sources, analytics platforms, or APIs) and provisioning those services. Be sure to mention any necessary extensions or tools that need to be pre-installed to ensure a smooth setup.
When a `USAGE.md` file is included in the root of the repository, Netlify's app will prompt users to read the additional instructions included in it during the `fullConfiguration` flow and, after the site has been deployed, in the site overview.
## Build hooks
[Build hooks](/build/configure-builds/build-hooks) give you unique URLs you can use to trigger new builds and deploys.
## Zapier integrations
Netlify is available on Zapier, where you can connect Netlify with over 1,000 other applications. You can use Zapier "Zaps" to start a new deploy of your site in response to a trigger from another service. You can [find out more on our blog](https://www.netlify.com/blog/2018/11/07/automate-your-netlify-sites-with-zapier/), or use one of the templates below to get started:
### Integration: zapier-create
- **ID**: zapier-create
- **Description**: Start deploys of Netlify sites daily
- **Subtext**: Netlify + Schedule by Zapier
- **Link**: https://zapier.com/webintent/create-zap?template
- **CTA Text**: Use this Zap
### Integration: zapier-create
- **ID**: zapier-create
- **Description**: Start Netlify deploys when you send new Tweets
- **Subtext**: Netlify + Twitter
- **Link**: https://zapier.com/webintent/create-zap?template
- **CTA Text**: Use this Zap
### Integration: zapier-create
- **ID**: zapier-create
- **Description**: Start Netlify site deploys with the push of a Flic button
- **Subtext**: Flic + Netlify
- **Link**: https://zapier.com/webintent/create-zap?template
- **CTA Text**: Use this Zap
## n8n integrations
Netlify is available on n8n, an open source tool that allows you to connect Netlify with other applications. By using one of n8n's Netlify nodes, you can create your own automated workflow. To get started, you can use the [Netlify node](https://n8n.io/integrations/netlify/), [Netlify Trigger node](https://n8n.io/integrations/netlify-trigger/), or you can use the existing workflow below:
### Integration: n8n-create
- **ID**: n8n-create
- **Description**: Deploy site when new content gets added
- **Subtext**: Netlify node
- **Link**: https://n8n.io/workflows/1254-deploy-site-when-new-content-gets-added/
- **CTA Text**: Use workflow