Skip to content

You may encounter a variety of errors when you interact with the Vercel platform. They can reflect issues that happen with external providers such as domain services or internal problems at the level of your application's deployment or your usage of platform features.

Handling errors

If you are interacting via the Vercel dashboard, the errors you can encounter are displayed in the error list below. If you are working with the Vercel CLI through the command line, the REST API through your code or the Logs, you may encounter errors from the application or platform error codes below.

For each of the errors listed below, you can find details on how they occur and how to resolve them.

Here are some tips for handling these errors:

  • Via the CLI, Logs or dashboard, follow the link, if available, in the description of the error. If not, search for the error on this page
  • Via the API, wrap your call with a Catch exception so that any encountered error is returned. You can then search for the error code on this page

Application Error Codes

BODY_NOT_A_STRING_FROM_FUNCTION

  • Definition: The requested Serverless Function from the application did not return a string as the body.
  • Occurrence: This could happen if the Serverless Function is returning an empty response or null.
BODY_NOT_A_STRING_FROM_FUNCTION
502: Bad Gateway
Code: BODY_NOT_A_STRING_FROM_FUNCTION

Check if the application is returning an empty response, or possibly null.

You can also check the application logs, which can be found at the host URL under the /_logs path, for example: https://my-deployment-my-username.vercel.app/_logs

DEPLOYMENT_BLOCKED

  • Definition: The deployment was blocked by the platform infrastructure layer due to a problem with the application.
  • Occurrence: This could happen if you have recently downgraded to the Hobby plan.
DEPLOYMENT_BLOCKED
Code: DEPLOYMENT_BLOCKED

If you have recently downgraded to the Hobby plan, you will need to redeploy your projects to make them available once again. Contact Support to see why your deployment was blocked and how to resolve it.

EDGE_FUNCTION_INVOCATION FAILED

  • Definition: The request for an Edge Function was not completed successfully.
  • Occurrence: This could happen if the application contains an unhandled exception.
EDGE_FUNCTION_INVOCATION_FAILED
500: Internal Server Error
Code: EDGE_FUNCTION_INVOCATION_FAILED

A common cause for this issue is when the application contains an unhandled exception. Check the application logs, which can be found at the host URL under the /_logs path, for example: https://my-deployment-my-username.vercel.app/_logs

EDGE_FUNCTION_INVOCATION_TIMEOUT

  • Definition: The request to the function timed out. It needs to return a response in less than 1.5 seconds.
  • Occurrence: This could happen if the application contains an unhandled exception.
EDGE_FUNCTION_INVOCATION_TIMEOUT
504: Gateway Timeout
Code: EDGE_FUNCTION_INVOCATION_TIMEOUT

A common cause for this issue is when the application contains an unhandled exception. Check the application logs, which can be found at the host URL under the /_logs path, for example: https://my-deployment-my-username.vercel.app/_logs

FUNCTION_INVOCATION_FAILED

  • Definition: The request to a Serverless Function was not completed successfully.
  • Occurrence: This could happen if the application contains an unhandled exception.
FUNCTION_INVOCATION_FAILED
500: Internal Server Error
Code: FUNCTION_INVOCATION_FAILED

A common cause for this issue is when the application contains an unhandled exception. Check the application logs, which can be found at the host URL under the /_logs path, for example: https://my-deployment-my-username.vercel.app/_logs

FUNCTION_INVOCATION_TIMEOUT

  • Definition: The request to a Serverless Function reached the timeout threshold which is different for each plan (5 seconds for Hobby accounts, 15 seconds for Pro accounts, and 30 seconds for Enterprise accounts).
  • Occurrence: This could happen if the application contains an unhandled exception.
FUNCTION_INVOCATION_TIMEOUT
504: Gateway Timeout
Code: FUNCTION_INVOCATION_TIMEOUT

A common cause for this issue is when the application contains an unhandled exception. Check the application logs, which can be found at the host URL under the /_logs path, for example: https://my-deployment-my-username.vercel.app/_logs

FUNCTION_PAYLOAD_TOO_LARGE

  • Definition: The request to a Serverless Function has a payload that exceeds the maximum value.
  • Occurrence: This could happen when requesting a Serverless Function with a payload exceeding 6MB.
FUNCTION_PAYLOAD_TOO_LARGE
413: Request Entity Too Large
Code: FUNCTION_PAYLOAD_TOO_LARGE

To fix, try and reduce the size of the request payload.

INFINITE_LOOP_DETECTED

  • Definition: An infinite loop was detected.
  • Occurrence: This could happen when a redirect loop is present in the source code or inside the vercel.json redirects section.
INFINITE_LOOP_DETECTED
508: Loop Detected
Code: INFINITE_LOOP_DETECTED

Check the application's source code for a redirect loop. You can also check the application's vercel.json redirects for a redirect loop.

INTERNAL_FUNCTION_RATE_LIMIT

  • Definition: The rate at which requests are being made has reached the limit and was subsequently rate limited by our upstream provider.
  • Occurrence: This could happen if your function is receiving too many requests from real users or an artificial attack.
FUNCTION_RATE_LIMIT
429: Too Many Requests
Code: FUNCTION_RATE_LIMIT

Check this support article for advice on how to mitigate this error. If the advice found within the article does not solve this issue, Contact Support.

INVALID_REQUEST_METHOD

  • Definition: A static resource was requested with a request type other than GET or HEAD.
  • Occurrence: This could happen if you are requesting a static resource with a request type other than GET or HEAD.
INVALID_REQUEST_METHOD
405: Method Not Allowed
Code: INVALID_REQUEST_METHOD

Check your client application logic or cURL command for a request type other than a GET or HEAD.

NO_RESPONSE_FROM_FUNCTION

  • Definition: The application did not respond correctly.
  • Occurrence: This could happen due to an exception being thrown from the function handler, a global uncaught exception, a global unhandled rejection or a deployment that introduced incorrect syntax.
NO_RESPONSE_FROM_FUNCTION
502: Bad Gateway
Code: NO_RESPONSE_FROM_FUNCTION

Open the realtime request logs for the application in a separate tab - this tab must be kept open while reproducing the error.

Repeat the application behavior that led to the error being thrown and review the realtime request logs where it will now show.

Use the information contained within the error found in the logs to understand where the function is failing. If you're yet to implement a Log Drain, you can create one to persist errors from Serverless Functions.

RESOURCE_NOT_FOUND

  • Definition: The requested file or Serverless Function was not found in the application.
  • Occurrence: This could happen if you tried to access a link that does not exist or the link is not returned the correct output.
RESOURCE_NOT_FOUND
404: Not found
Code: RESOURCE_NOT_FOUND

Make sure the link you accessed is correct and check the output of your deployment. If you believe the link is correct and you were not expecting this error; Contact Support along with the ID on the error page from your deployment.

TOO_MANY_FILESYSTEM_CHECKS

  • Definition: An error occurred in the application when matching too many rewrites.
  • Occurrence: This could happen when you have too many rewrites in the request path.
TOO_MANY_FILESYSTEM_CHECKS
502: Bad Gateway
Code: TOO_MANY_FILESYSTEM_CHECKS

Reduce the number of rewrites that match the erroring request path. If you have trouble locating the rewrites causing the error, Contact Support.

TOO_MANY_FORKS

  • Definition: An error occurred in the application when matching too many conditional routes.
  • Occurrence: This could happen if you have more than 5 has routes in a single path.
TOO_MANY_FORKS
502: Bad Gateway
Code: TOO_MANY_FORKS

Reduce the number of rewrites, redirects, or headers with a has key (conditional route) that match the erroring request path. If you have trouble locating the conditional routes causing the error, Contact Support.

Platform Error Codes

DEPLOYMENT_NOT_FOUND

  • Definition: The deployment was not found in the platform infrastructure layer.
  • Occurrence: This could happen if the link you are trying to access is not correct or accessible.
DEPLOYMENT_NOT_FOUND
404: Not found
Code: DEPLOYMENT_NOT_FOUND

Make sure the link you accessed is correct. If you were expecting a deployment to be assigned to a domain that you are accessing, ensure that the domain is assigned to a project and there is a production deployment.

If the link is correct and you were not expecting this error, Contact Support.

DEPLOYMENT_NOT_READY_REDIRECTING

  • Definition: The deployment has not made it through the deployment pipeline and the request was redirected to the deployment status page.
  • Occurrence: The deployment is not ready yet.
DEPLOYMENT_NOT_READY_REDIRECTING
303: See Other
Code: DEPLOYMENT_NOT_READY_REDIRECTING

Wait for a few seconds and refresh. If the error does not resolve when refreshing, Contact Support along with the ID on the error page from your deployment.

INTERNAL_DEPLOYMENT_FETCH_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_DEPLOYMENT_FETCH_FAILED
500: Internal Error
Code: INTERNAL_DEPLOYMENT_FETCH_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_FUNCTION_INVOCATION_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_FUNCTION_INVOCATION_FAILED
500: Internal Error
Code: INTERNAL_FUNCTION_INVOCATION_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_FUNCTION_NOT_FOUND

  • Definition: The requested Serverless Function was not found by the platform infrastructure layer.
  • Occurrence: This could happen if the link being requested is incorrect.
FUNCTION_NOT_FOUND
500: Internal Error
Code: FUNCTION_NOT_FOUND

Make sure the link you accessed is correct. If you believe the link is correct and you were not expecting this error, Contact Support along with the ID on the error page from your deployment.

INTERNAL_HOSTNAME_RESOLVE_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_HOSTNAME_RESOLVE_FAILED
500: Internal Error
Code: INTERNAL_HOSTNAME_RESOLVE_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_INVALID_FUNCTION_ACCOUNTS

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_INVALID_FUNCTION_ACCOUNTS
500: Internal Error
Code: INTERNAL_INVALID_FUNCTION_ACCOUNTS

Contact Support along with the ID on the error page from your deployment.

INTERNAL_INVALID_FUNCTION_REGION

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_INVALID_FUNCTION_REGION
500: Internal Error
Code: INTERNAL_INVALID_FUNCTION_REGION

Contact Support along with the ID on the error page from your deployment.

INTERNAL_MISSING_RESPONSE_FROM_CACHE

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_MISSING_RESPONSE_FROM_CACHE
500: Internal Error
Code: INTERNAL_MISSING_RESPONSE_FROM_CACHE

Contact Support along with the ID on the error page from your deployment.

INTERNAL_RESOLVE_HOST_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_RESOLVE_HOST_FAILED
500: Internal Error
Code: INTERNAL_RESOLVE_HOST_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_REWRITE_RESOLVE_HOST_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_REWRITE_RESOLVE_HOST_FAILED
500: Internal Error
Code: INTERNAL_REWRITE_RESOLVE_HOST_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_STATIC_REQUEST_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_STATIC_REQUEST_FAILED
502: Bad Gateway
Code: INTERNAL_STATIC_REQUEST_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_UNARCHIVE_FAILED

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_UNARCHIVE_FAILED
503: Service Unavailable
Code: INTERNAL_UNARCHIVE_FAILED

Contact Support along with the ID on the error page from your deployment.

INTERNAL_UNEXPECTED_ERROR

  • Definition: An error occurred in the platform infrastructure layer.
  • Occurrence: N/A
INTERNAL_UNEXPECTED_ERROR
500: Internal Error
Code: INTERNAL_UNEXPECTED_ERROR

Contact Support along with the ID on the error page from your deployment.

Error List

Missing Public Directory

The build step will result in an error if the output directory is missing, empty, or invalid (for example, it is not a directory). To resolve this error, you can try the following steps:

  • Make sure the output directory is specified correctly in project settings
  • If the output directory is correct, check the build command (documentation) or the root directory)
  • Try running the build command locally and make sure that the files are correctly generated in the specified output directory

Missing Build Script

Note: This is only relevant if you’re using Vercel CLI 16.7.3 or older.

Suppose your project contains a package.json file, no api directory, and no vercel.json configuration. In that case, it is expected to provide a build script that performs a static build of your frontend and outputs it to a public directory at the root of your project.

When properly configured, your package.json file would look similar to this:

package.json
{
  "scripts": {
    "build": "[my-framework] build --output public"
  }
}

An example build script in a package.json file that specifies the output directory.

Once you have defined the build script, this error will disappear. Furthermore, it will not be displayed if you are using package.json purely to provide dependencies for your Serverless Functions located inside the api directory.

Maximum Team Member Requests

The maximum amount of open requests to join a team is 10. In order to allow for more requests, the existing requests need to be approved or declined by a Team Owner.

This ensures the list always remains manageable and protected against spam.

Inviting Users to Team Who Requested Access

If a user has already requested access to a Team, it's impossible to invite them. Instead, their request must be approved by a Team Owner for the user to gain access.

This ensures no Team invites are accidentally accepted.

Request Access with the Required Git Account

When the deployment for a commit fails with the message "Team access required to deploy.", the Git account of the commit author is not connected to a Personal Account that is a member of the Team.

The link attached to the error allows someone to connect their Personal Account to the Git account of the commit author. If the Personal Account is connected to a different Git account, it will fail stating that a different Git account must be used to request access to the team.

Once the Git account is connected to the Personal Account on Vercel, it is possible to request access to the Team. A Team Owner can then approve or decline this access request. If the request was approved, the failed commit would be retried, and the following commits would not fail due to missing Team access.

Blocked Scopes

A Personal Account or Team on Vercel can be blocked if it violates our Fair Use Policy or Terms of Service.

Blocked Personal Accounts or Teams cannot create new Deployments, or be invited to new Teams. Please contact Vercel Support if you need help.

Unused Build and Development Settings

A Project has several settings that can be found in the dashboard. One of those sections, "Build & Development Settings", is used to change the way a Project is built.

However, the Build & Development Settings are only applied to zero-configuration Deployments.

If a Deployment defines the builds configuration property, the Build & Development Settings are ignored.

Unused Serverless Function Region Setting

A Project has several settings that can be found in the dashboard. One of those settings, "Serverless Function Region", is used to select the region where your Serverless Functions execute.

If a Deployment defines the regions configuration property in vercel.json, the "Serverless Function Region" setting is ignored.

If a CLI Deployment defines the --regions option, the "Serverless Function Region" setting is ignored.

Invalid Route Source Pattern

The source property follows the syntax from path-to-regexp, not the RegExp syntax.

For example, negative lookaheads must be wrapped in a group.

Before

vercel.json
{
  "source": "/feedback/(?!general)",
  "destination": "/api/feedback/general"
}

After

vercel.json
{
  "source": "/feedback/((?!general).*)",
  "destination": "/api/feedback/general"
}

Invalid Route Destination Segment

The source property follows the syntax from path-to-regexp.

A colon (:) defines the start of a named segment parameter.

A named segment parameter defined in the destination property must also be defined in the source property.

Before

vercel.json
{
  "source": "/feedback/:type",
  "destination": "/api/feedback/:id"
}

After

vercel.json
{
  "source": "/feedback/:id",
  "destination": "/api/feedback/:id"
}

Failed to Install Builder Dependencies

When running the vercel build or vercel dev commands, npm install errors can be encountered if npm was invoked to install Builders that are defined in your vercel.json file.

npm install may fail if:

  • npm is not installed
  • Your internet connection is unavailable
  • The Builder that is defined in your configuration is not published to the npm registry

Please double-check that the name and version of the Builder you are requesting is correct.

Mixed Routing Properties

If you have rewrites, redirects, headers, cleanUrls or trailingSlash defined in your configuration file, then routes cannot be defined.

This is a necessary limitation because routes is a lower-level primitive that contains all of the other types. Therefore, it cannot be merged safely with the new properties.

See the Upgrading Routes section for examples of routes compared to the new properties.

Conflicting Configuration Files

For backward compatibility purposes, there are two naming conventions for configuration files used by Vercel CLI (for example vercel.json and now.json). Both naming conventions are supported, however only one may be defined at a time. Vercel CLI will output an error message if both naming conventions are used at the same time.

These conflicting configuration errors occur if:

  • Both vercel.json and now.json exist in your project.
    Solution: Delete the now.json file.
  • Both .vercel and .now directories exist in your project.
    Solution: Delete the .now directory.
  • Both .vercelignore and .nowignore files exist in your project.
    Solution: Delete the .nowignore file.
  • Environment Variables that begin with VERCEL_ have a conflicting Environment Variable that begins with NOW_.
    Solution: Only define the VERCEL_ prefixed Environment Variable.

Conflicting functions and builds Configuration

There are two ways to configure Serverless Functions in your project: functions or builds. However, only one of them may be used at a time - they cannot be used in conjunction.

For most cases, it is recommended to use the functions property because it supports more features, such as:

  • Allows configuration of the amount of memory that the Serverless Function is provided with.
  • More reliable because it requires a specific npm package version for the runtime property.
  • Supports "clean URLs" by default, which means that the Serverless Functions are automatically accessible without their file extension in the URL.

However, the builds property will remain supported for backward compatibility purposes.

Unsupported Functions Configuration with Nextjs

When using Next.js, only memory and maxDuration can be configured within the functions property. Next.js automatically handles the other configuration values for you.

Deploying Serverless Functions to Multiple Regions

It's possible to deploy Serverless Functions to multiple regions. This functionality is only available to Enterprise teams.

On the Pro plan, the limitation has existed since the launch of the current pricing model but was applied on July 10, 2020. For Projects created on or after the date, it's no longer possible to deploy to multiple regions.

To select the region closest to you, read our guide on choosing deployment regions for Serverless Functions.

Unmatched Function Pattern

The functions property uses a glob pattern for each key. This pattern must match Serverless Function source files within the api directory.

If you are using Next.js, Serverless Functions source files can be created in the following:

Additionally, if you'd like to use a Serverless Function that isn't written with Node.js, and in combination with Next.js, you can place it in the api directory (provided by the platform), since pages/api (provided by Next.js) only supports JavaScript.

Not Allowed

vercel.json
{
  "functions": {
    "users/**/*.js": {
      "maxDuration": 30
    }
  }
}

Allowed

vercel.json
{
  "functions": {
    "api/users/**/*.js": {
      "maxDuration": 30
    }
  }
}

Allowed (Next.js)

vercel.json
{
  "functions": {
    "pages/api/users/**/*.js": {
      "maxDuration": 30
    }
  }
}

Cannot Load Project Settings

If the Project configuration in .vercel belongs to a Team you are not a member of, attempting to deploy the Project will result in an error.

This can occur if you clone a Git repository that includes the .vercel directory, or you are logged in to the wrong Vercel Account.

To fix, remove the .vercel directory and redeploy to link the Project again by running these commands.

On macOS and Linux:

rm -rf .vercel
vercel

On Windows:

rmdir /s /q .vercel
vercel

Project Name Validation

Project names can only consist of up to 100 alphanumeric lowercase characters. Hyphens can be used in between words in the name, but never at the start or end.

Repository Connection Limitation

The amount of Vercel Projects that can be connected with the same Git repository is limited depending on your plan.

If you have reached the limitation and would like to connect a new Project to the repository, you will need to disconnect an existing Project from the same Git repository.

To increase this limit, please contact our Sales Team.

Domain Verification via CLI

To verify your domain, point the Domain to Vercel by configuring our nameservers or a DNS Record. You can learn more about what to do for your Domain by running vercel domains inspect <domain>, where <domain> is the Domain you're interested in.

Alternatively, if you already added the domain to a Project, read the configuring a domain section of the custom domain documentation.

Leaving The Team

You cannot leave a Team if you are the last remaining Owner or the last confirmed Member. In order to leave the Team, first designate a different confirmed Member to be an Team Owner.

If you are the only remaining Member, you should instead delete the Team.

Git Default Ignore List

Deployments created using Vercel CLI will automatically ignore several files for security and performance reasons.

However, these files are not ignored for deployments created using Git and a warning is printed instead. This is because .gitignore determines which files should be ignored.

If the file was intentionally committed to Git, you can ignore the warning.

If the file was accidentally committed to Git, you can remove it using the following commands:

terminal
git rm file.txt                   # remove the file
echo 'file.txt' >> .gitignore     # append file to .gitignore
git add .gitignore                # stage the change
git commit -m "Removed file.txt"  # commit the change
git push                          # deploy the change

GitHub App Installation Not Found

In some cases, signing up with GitHub fails due to GitHub's database inconsistencies.

When you connected your Personal Vercel Account with your GitHub account, the Vercel GitHub App was installed on your GitHub account and then GitHub notified Vercel that the app was successfully installed.

However, Vercel was unable to retrieve the app installation from GitHub, which made it appear as if the Vercel GitHub App was never installed.

In order to solve this issue, wait a couple of minutes and try connecting to GitHub again. If you are still unable to connect, please contact GitHub Support to determine why the Vercel GitHub App was not able to be installed.

Preview Branch Used as Production Branch

If you have configured a custom Git branch for a Domain or an Environment Variable, it is considered a Preview Domain and a Preview Environment Variable. Because of this, the Git branch configured for it is considered a Preview Branch.

When configuring the Production Branch in the Project Settings, it is not possible to use a Preview Branch.

If you still want to use this particular Git branch as a Production Branch, please follow these steps:

  1. Assign your affected Domains to the Production Environment (clear out the Git branch you've defined for them)
  2. Assign your affected Environment Variables to the Production Environment (clear out the Git branch you've defined for them)

Afterwards, you can use the Git branch you originally wanted to use as a Production Branch.

Lost Git Repository Access

In order for Vercel to be able to deploy commits to your Git repository, a Project on Vercel has to be connected to it.

This connection is interrupted if the Git repository is deleted, archived, or if the Vercel App was uninstalled from the corresponding Git account or Git organization. Make sure none of these things apply.

Additionally, when using GitHub, the connection is also interrupted if you or a Team Member modifies the access permissions of the Vercel GitHub App installed on the respective personal GitHub account or GitHub organization.

To verify the access permissions of the Vercel GitHub App installed on your personal GitHub account, navigate to the "Applications" page and select "Vercel" under "Installed GitHub Apps". You will see a list of Git repositories that the GitHub App has access to. Make sure that the Git repository you're looking to connect to a Vercel Project is listed there.

To verify the access permissions of the Vercel GitHub App installed on your GitHub organization, select "Vercel" under "Installed GitHub Apps" in the organization settings. You will see a list of Git repositories that the GitHub App has access to. Make sure that the Git repository you're looking to connect to a Vercel Project is listed there.

Production Deployment cannot be redeployed

You cannot redeploy a Production Deployment if a more recent one exists.

The reason is that redeploying an old Production Deployment would result in overwriting the most recent source code you have deployed to Production.

To force an explicit overwrite of the current Production Deployment, click "Promote to Production" instead.

Non Git Deployment Cannot Be Redeployed from Dashboard

You cannot redeploy a Deployment from the Dashboard if it hasn't been created via Git.

To redeploy a Deployment that was created via Vercel CLI, run vercel within the directory in which the original Deployment was created.

Non Git Deployment Cannot Be Promoted to Production from Dashboard

You cannot promote a Deployment to Production from the Dashboard if it wasn't created via Git.

To promote a Deployment to Production that was created via Vercel CLI, run vercel --prod within the directory in which the original Deployment was created.

SSL Certificate Deletion Denied

Certain SSL Certificates associated with your Personal Account or Team (i.e. Wildcard SSL Certificates for your Vercel Project's staging Domains) are automatically generated by the Vercel platform.

Because these SSL Certificates are managed by the Vercel platform, they cannot be manually deleted on the Vercel Dashboard – nor via Vercel CLI.

Custom SSL Certificates may be uploaded to Teams on the Enteprise plan, which are allowed to be manually deleted.

Production Branch Used as Preview Branch

The Git branch that is configured using the Production Branch field in the Project Settings, is considered the branch that contains the code served to your visitors.

If you'd like to assign a Domain or Environment Variable to that particular Git branch, there's no need to manually fill it in.

By default, if no custom Git branch is defined for them, Domains are already assigned to the Production Branch. The same is true for Environment Variables: If no custom Git branch is defined for them and "Production" is selected as an Environment, they're already assigned to the Production Branch.

If you still want to enter a specific Git branch for a Domain or an Environment Variable, it has to be a Preview Branch.

Command Not Found in vercel dev

The "Command not found" error message happens when a sub-process that vercel dev is attempting to create is not installed on your local machine. You need to install the particular program onto your operating system before vercel dev will work correctly.

For example, you may see the error "Command not found: go" if you are writing a Serverless Function in Go, but do not have the go binary installed. In this case you need to install go first, and then try invoking your Serverless Function again.

Recursive Invocation of Commands

Why This Error Occurred

You have configured one of the following for your Project:

Because the Build Command is invoked by vercel build when deploying, it cannot invoke vercel build itself, as that would cause an infinite recursion.

The same applies to the Development Command: When developing locally, vercel dev invokes the Development Command, so it cannot invoke vercel dev itself.

Possible Ways to Fix It

Adjust the Build and Development Commands defined for your Project to not invoke vercel build or vercel dev.

Instead, they should invoke the Build Command provided by your framework.

If you are unsure about which value to provide, disable the "Override" option in order to default to the preferred settings for the Framework Preset you have selected.