rsconnect

https://rstudio.github.io/rsconnect
Admin
rsconnect is an R package that simplifies publishing Shiny apps, RMarkdown and Quarto documents, and...
Tokens:22,358
Snippets:229
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Examples of listing applications

Source: https://rstudio.github.io/rsconnect/reference/applications.html

Examples demonstrating how to list applications for the default account, a specific account, and viewing the results in the data viewer.

```R
if (FALSE) { # \dontrun{

# list all applications for the default account
applications()

# list all applications for a specific account
applications("myaccount")

# view the list of applications in the data viewer
View(applications())
} # }
```

--------------------------------

### Restart an Application Example

Source: https://rstudio.github.io/rsconnect/reference/restartApp.html

Example of how to call the function to restart a specific application.

```R
if (FALSE) { # \dontrun{

# restart an application
restartApp("myapp")
} # }
```

--------------------------------

### Retrieve task log examples

Source: https://rstudio.github.io/rsconnect/reference/taskLog.html

Examples showing how to write task logs to stdout or stderr. These examples are wrapped in a dontrun block.

```R
if (FALSE) { # \dontrun{

# write task log to stdout
taskLog(12345)

# write task log to stderr
taskLog(12345, output="stderr")

} # }
```

--------------------------------

### Example of listing deployments

Source: https://rstudio.github.io/rsconnect/reference/deployments.html

Demonstrates how to filter deployments for a specific directory and account.

```R
if (FALSE) { # \dontrun{

# Return all deployments of the ~/r/myapp directory made with the 'abc'
# account
deployments("~/r/myapp", accountFilter="abc")
} # }
```

--------------------------------

### setProperty Examples

Source: https://rstudio.github.io/rsconnect/reference/setProperty.html

Demonstrates setting application instance counts and disabling the package cache.

```R
if (FALSE) { # \dontrun{

# set instance size for an application
setProperty("application.instances.count", 1)

# disable application package cache
setProperty("application.package.cache", FALSE)

} # }
```

--------------------------------

### Deploying documents

Source: https://rstudio.github.io/rsconnect/reference/deployDoc.html

Examples of deploying an R Markdown file and a static HTML file.

```R
if (FALSE) { # \dontrun{
deployDoc("my-report.Rmd")
deployDoc("static-file.html")
} # }
```

--------------------------------

### Terminate Application Example

Source: https://rstudio.github.io/rsconnect/reference/terminateApp.html

Basic example showing how to call terminateApp for a specific application name.

```R
if (FALSE) { # \dontrun{

# terminate an application
terminateApp("myapp")
} # }
```

--------------------------------

### Deploying applications with deployApp

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Examples of deploying applications from the current directory, a specific path, or with custom metadata.

```r
if (FALSE) { # \dontrun{

# deploy the application in the current working dir
deployApp()

# deploy an application in another directory
deployApp("~/projects/shiny/app1")

# deploy using an alternative application name and title
deployApp("~/projects/shiny/app1", appName = "myapp",
          appTitle = "My Application")
```

--------------------------------

### Install rsconnect

Source: https://rstudio.github.io/rsconnect/index.html

Installation commands for the released version from CRAN and the development version from GitHub.

```R
install.packages("rsconnect")
```

```R
# install.packages("devtools")
devtools::install_github("rstudio/rsconnect")
```

--------------------------------

### Example: Uploading and updating a document

Source: https://rstudio.github.io/rsconnect/reference/rpubsUpload.html

Demonstrates the workflow for uploading a new document and subsequently updating it using the returned ID.

```R
if (FALSE) { # \dontrun{
# upload a document
result <- rpubsUpload("My document title", "Document.html")
if (!is.null(result$continueUrl))
   browseURL(result$continueUrl)
else
   stop(result$error)

# update the same document with a new title
updateResult <- rpubsUpload("My updated title", "Document.html",
                            id = result$id)
} # }
```

--------------------------------

### Purge Application Example

Source: https://rstudio.github.io/rsconnect/reference/purgeApp.html

Example of how to invoke the purgeApp function for a specific application name.

```R
if (FALSE) { # \dontrun{

# purge an application
purgeApp("myapp")
} # }
```

--------------------------------

### Example of unsetProperty

Source: https://rstudio.github.io/rsconnect/reference/unsetProperty.html

Demonstrates how to unset the application package cache property.

```R
if (FALSE) { # \dontrun{

# unset application package cache property to revert to default
unsetProperty("application.package.cache")

} # }
```

--------------------------------

### Set Application Instance Size

Source: https://rstudio.github.io/rsconnect/reference/configureApp.html

Example of updating the instance size for a specific application.

```R
if (FALSE) { # \dontrun{

# set instance size for an application
configureApp("myapp", size="xlarge")
} # }
```

--------------------------------

### Configure Repository Options

Source: https://rstudio.github.io/rsconnect/reference/appDependencies.html

Set custom repository URLs for package installation, which determines the source identifier used during deployment.

```r
options(
   repos = c(
     CRAN = "https://cran.rstudio.com/",
     CORPORATE = "https://corporate-packages.development.company.com"
   )
)
```

--------------------------------

### Retrieve server metadata

Source: https://rstudio.github.io/rsconnect/reference/servers.html

Functions to list all registered servers or get detailed information for a specific server.

```R
servers(local = FALSE)

serverInfo(name = NULL)
```

```R
# List all registered servers
servers()
#>                  name                                url
#> 1        shinyapps.io        https://api.shinyapps.io/v1
#> 2 connect.posit.cloud https://api.connect.posit.cloud/v1
#>            certificate
#> 1 Amazon... (redacted)
#> 2 -----B... (redacted)

# Get information about a server
serverInfo("shinyapps.io")
#> $name
#> [1] "shinyapps.io"
#> 
#> $url
#> [1] "https://api.shinyapps.io/v1"
#> 
#> $certificate
#> [1] "Amazon... (redacted)"
#>
```

--------------------------------

### Register and Connect to a Server

Source: https://rstudio.github.io/rsconnect/reference/addServer.html

Registers a local server and initiates a user connection.

```R
if (FALSE) { # \dontrun{
# register a local server
addServer("http://myrsconnect/", "myserver")

# list servers
servers(local = TRUE)

# connect to an account on the server
connectUser(server = "myserver")
} # }
```

--------------------------------

### deploySite(siteDir, siteName, siteTitle, account, server, render, launch.browser, logLevel, lint, metadata, python, recordDir, ...)

Source: https://rstudio.github.io/rsconnect/reference/deploySite.html

Deploys an R Markdown or Quarto website to a server. This function handles the directory configuration, rendering preferences, and server identification for the deployment process.

```APIDOC
## deploySite

### Description
Deploys an R Markdown or Quarto website to a server. Supported servers include Posit Connect, Posit Connect Cloud, and ShinyApps.

### Parameters
- **siteDir** (string) - Optional - Directory containing the website. Defaults to the current working directory.
- **siteName** (string) - Optional - Name for the site. Defaults to the base name of siteDir.
- **siteTitle** (string) - Optional - Title for the site.
- **account** (string) - Optional - User account name for the remote server.
- **server** (string) - Optional - Server name.
- **render** (string) - Optional - Rendering behavior: "none", "local", or "server".
- **launch.browser** (boolean/function) - Optional - Whether to launch the browser after deployment.
- **logLevel** (string) - Optional - Logging verbosity: "quiet", "normal", or "verbose".
- **lint** (boolean) - Optional - Whether to lint the project before deployment.
- **metadata** (list) - Optional - Additional metadata fields to save with the deployment record.
- **python** (string) - Optional - Full path to a python binary.
- **recordDir** (string) - Optional - Directory for the deployment record. Defaults to siteDir.
- **...** (dots) - Optional - Additional arguments passed to deployApp.
```

--------------------------------

### deployApp(appDir = getwd(), account = NULL, launch.browser = TRUE, envVars = NULL, manifestPath = NULL)

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Deploys an application to the RStudio Connect server. Users can specify the target directory, account, browser behavior, environment variables, and manifest paths.

```APIDOC
## deployApp

### Description
Deploys an application or website to the RStudio Connect server. If no arguments are provided, it defaults to the current working directory and previously used account settings.

### Parameters
- **appDir** (string) - Optional - The path to the application directory. Defaults to the current working directory.
- **account** (string) - Optional - The name of the account to use for deployment.
- **launch.browser** (boolean) - Optional - Whether to launch a browser after deployment. Defaults to TRUE.
- **envVars** (vector) - Optional - A character vector of environment variable names to include in the deployment.
- **manifestPath** (string) - Optional - The path to a pre-generated manifest.json file.

### Usage Examples

Deploy with specific account:
`deployApp(account = "jsmith")`

Deploy without launching browser:
`deployApp(launch.browser = FALSE)`

Deploy with environment variables:
`rsconnect::deployApp(envVars = c("SECRET_PASSWORD"))`

Deploy from manifest:
`deployApp("~/projects/shiny/app1", manifestPath = "manifest.json")`
```

--------------------------------

### Deploy from a manifest

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Generate a manifest file for an application and use it to perform a deployment.

```R
writeManifest("~/projects/shiny/app1")
# ...optionally customize manifest.json here...
deployApp("~/projects/shiny/app1", manifestPath = "manifest.json")
```

--------------------------------

### Deploy a Quarto website

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Deploy a Quarto project by providing the directory path, utilizing the quarto package to locate the binary.

```R
deployApp("~/projects/quarto/site1")
```

--------------------------------

### Deploy with environment variables

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Include specific environment variables in the deployment, which should be defined in your .Renviron file.

```R
rsconnect::deployApp(envVars = c("SECRET_PASSWORD"))
```

--------------------------------

### Deploy a Plumber API usage

Source: https://rstudio.github.io/rsconnect/reference/deployAPI.html

Basic syntax for deploying a Plumber API from a specified directory.

```R
deployAPI(api, ...)
```

--------------------------------

### configureApp(appName, appDir = getwd(), account = NULL, server = NULL, redeploy = TRUE, size = NULL, instances = NULL, logLevel = c("normal", "quiet", "verbose"))

Source: https://rstudio.github.io/rsconnect/reference/configureApp.html

Configures an application running on a remote ShinyApps server.

```APIDOC
## configureApp

### Description
Configure an application running on a remote server. This function is supported only for ShinyApps servers.

### Arguments
- **appName** (string) - Name of application to configure.
- **appDir** (string) - Directory containing application. Defaults to current working directory.
- **account** (string) - Optional. Uniquely identify a remote server with your user account.
- **server** (string) - Optional. Uniquely identify a remote server with the server name.
- **redeploy** (boolean) - Re-deploy application after modifying its configuration. Defaults to TRUE.
- **size** (string) - Configure application instance size.
- **instances** (integer) - Configure number of application instances.
- **logLevel** (string) - One of "quiet", "normal" or "verbose"; indicates how much logging to the console is to be performed.

### Example
```r
# set instance size for an application
configureApp("myapp", size="xlarge")
```
```

--------------------------------

### deployApp(appDir, appName, appTitle, server, account, appId)

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Deploys an application to a server. Subsequent deployments reuse settings stored in the local rsconnect directory.

```APIDOC
## deployApp(appDir, appName, appTitle, server, account, appId)

### Description
Deploys an application to a server. It saves a deployment record in the local directory to facilitate future updates. If the record is missing, it attempts to rediscover existing deployments using the provided parameters.

### Parameters
- **appDir** (string) - Optional - The directory containing the application. Defaults to the current working directory.
- **appName** (string) - Optional - The name of the application.
- **appTitle** (string) - Optional - The title of the application.
- **server** (string) - Optional - The server to deploy to.
- **account** (string) - Optional - The account to use for deployment.
- **appId** (string) - Optional - The unique identifier of the application, required when updating an app created by another user.
```

--------------------------------

### Deploy a website using deploySite

Source: https://rstudio.github.io/rsconnect/reference/deploySite.html

The primary function signature for deploying a website directory to a supported server.

```R
deploySite(
  siteDir = getwd(),
  siteName = NULL,
  siteTitle = NULL,
  account = NULL,
  server = NULL,
  render = c("none", "local", "server"),
  launch.browser = getOption("rsconnect.launch.browser", interactive()),
  logLevel = c("normal", "quiet", "verbose"),
  lint = FALSE,
  metadata = list(),
  python = NULL,
  recordDir = NULL,
  ...
)
```

--------------------------------

### Deploy with account specification

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Specify an account for the initial deployment, allowing subsequent redeployments to omit the account argument.

```R
deployApp(account = "jsmith")
deployApp()
```

--------------------------------

### showUsage(appDir, appName, account, server, usageType, from, until, interval)

Source: https://rstudio.github.io/rsconnect/reference/showUsage.html

Retrieves usage metrics for a deployed application on ShinyApps servers.

```APIDOC
## showUsage

### Description
Show application usage of a currently deployed application. This function is supported only for ShinyApps servers.

### Signature
`showUsage(appDir = getwd(), appName = NULL, account = NULL, server = NULL, usageType = "hours", from = NULL, until = NULL, interval = NULL)`

### Arguments
- **appDir** (character) - Optional - Directory containing application. Defaults to current working directory.
- **appName** (character) - Optional - Name of application.
- **account** (character) - Optional - User account name.
- **server** (character) - Optional - Server name.
- **usageType** (character) - Optional - Use metric to retrieve (e.g., "hours").
- **from** (character/numeric) - Optional - Date range starting timestamp (Unix timestamp or relative time delta such as "2d" or "3w").
- **until** (character/numeric) - Optional - Date range ending timestamp (Unix timestamp or relative time delta such as "2d" or "3w").
- **interval** (character) - Optional - Summarization interval. Data points at intervals less than this will be grouped (e.g., "120s", "1h", "30d").
```

--------------------------------

### deployApp(appDir, ...)

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Deploys an application or document to a server. This function handles the bundling of files and configuration of deployment settings.

```APIDOC
## deployApp

### Description
Deploys a shiny application, an RMarkdown document, a plumber API, or HTML content to a server.

### Parameters
- **appDir** (character) - Optional - A directory containing an application. Defaults to the current directory.
- **appFiles** (character vector) - Optional - Specifies files to bundle in the app.
- **appFileManifest** (character) - Optional - Path to a file containing a list of files to bundle.
- **manifestPath** (character) - Optional - Path to an existing manifest.json file.
- **appPrimaryDoc** (character) - Optional - Path to the primary document if the application contains more than one.
- **appName** (character) - Optional - Unique application name on the server.
- **appTitle** (character) - Optional - Descriptive title of the application.
- **envVars** (character vector) - Optional - Names of environment variables to synchronize with the server.
- **account** (character) - Optional - Account name to deploy to.
- **server** (character) - Optional - Server name to deploy to.
- **upload** (logical) - Optional - Whether to upload the bundle. Defaults to TRUE.
- **lint** (logical) - Optional - Whether to lint the application before deployment. Defaults to TRUE.
```

--------------------------------

### Inspect Application Dependencies

Source: https://rstudio.github.io/rsconnect/reference/appDependencies.html

List the dependencies for an application in the current or a specified directory.

```r
if (FALSE) { # \dontrun{

# dependencies for the app in the current working dir
appDependencies()

# dependencies for an app in another directory
appDependencies("~/projects/shiny/app1")
} # }
```

--------------------------------

### addServer(url, name = NULL, certificate = NULL, validate = TRUE, snowflakeConnectionName = NULL, quiet = FALSE)

Source: https://rstudio.github.io/rsconnect/reference/addServer.html

Registers a Posit Connect server for use with the rsconnect package.

```APIDOC
## addServer

### Description
Registers a Posit Connect server. Once registered, you can connect to an account on the server using connectUser().

### Arguments
- **url** (string) - Required - URL for the server (e.g., 'connect.mycompany.com' or 'http://posit.mycompany.com/connect').
- **name** (string) - Optional - Server name. If omitted, the server hostname is used.
- **certificate** (string) - Optional - Path to certificate file or a character vector containing the certificate's contents.
- **validate** (boolean) - Optional - Validate that the URL points to a Posit Connect server.
- **snowflakeConnectionName** (string) - Optional - Name for the Snowflake connection in connections.toml.
- **quiet** (boolean) - Optional - Suppress output and prompts.
```

--------------------------------

### deployDoc(doc, ..., logLevel)

Source: https://rstudio.github.io/rsconnect/reference/deployDoc.html

Deploys a single R Markdown, Quarto document, or other file (e.g. .html or .pdf) to a server.

```APIDOC
## deployDoc(doc, ..., logLevel)

### Description
Deploys a single R Markdown, Quarto document, or other file (e.g. .html or .pdf). It automatically discovers dependencies for .Rmd, .Qmd, or .html files.

### Usage
`deployDoc(doc, ..., logLevel = c("normal", "quiet", "verbose"))`

### Arguments
- **doc** (string) - Path to the document to deploy.
- **...** (dots) - Additional arguments to deployApp(). Do not supply appDir, appFiles, or appPrimaryDoc.
- **logLevel** (string) - One of "quiet", "normal" or "verbose"; indicates how much logging to the console is to be performed.

### Examples
```r
deployDoc("my-report.Rmd")
deployDoc("static-file.html")
```
```

--------------------------------

### writeManifest()

Source: https://rstudio.github.io/rsconnect/reference/writeManifest.html

Generates a manifest.json file for an application directory. This file lists all application files and their dependencies, which is required for Git-Backed content deployment.

```APIDOC
## writeManifest()

### Description
Generates a `manifest.json` file for an application. This file contains a list of all files in the app along with their dependencies.

### Usage
writeManifest(appDir = getwd(), appFiles = NULL, appFileManifest = NULL, appPrimaryDoc = NULL, appMode = NULL, contentCategory = NULL, python = NULL, forceGeneratePythonEnvironment = FALSE, quarto = NA, image = NULL, envManagement = NULL, envManagementR = NULL, envManagementPy = NULL, envManagementNodejs = NULL, packageRepositoryResolutionR = NULL, dependencyResolution = c("strict", "library"), verbose = FALSE, quiet = FALSE)

### Arguments
- **appDir** (character) - Optional - A directory containing an application. Defaults to the current directory.
- **appFiles** (character) - Optional - A character vector of files to bundle in the app.
- **appFileManifest** (character) - Optional - Path to a file containing a list of files to bundle.
- **appPrimaryDoc** (character) - Optional - Path to the primary document relative to appDir.
- **appMode** (character) - Optional - The type of content being deployed (e.g., "shiny", "api", "static").
- **contentCategory** (character) - Optional - Set to "site" if deploying with deploySite().
- **python** (character) - Optional - Full path to a python binary.
- **forceGeneratePythonEnvironment** (logical) - Optional - If TRUE, overwrites existing requirements.txt.
- **quarto** (logical/NA) - Optional - Whether the content should be built by quarto.
- **image** (character) - Optional - The name of the image to use for building and executing content.
- **envManagement** (logical) - Optional - Whether Posit Connect should install packages for this content.
- **envManagementR** (logical) - Optional - Whether Posit Connect should install R packages.
- **envManagementPy** (logical) - Optional - Whether Posit Connect should install Python packages.
```

--------------------------------

### servers()

Source: https://rstudio.github.io/rsconnect/reference/servers.html

Lists all known servers registered in the system.

```APIDOC
## servers(local = FALSE)

### Description
Lists all known servers. Cloud server 'shinyapps.io' is always automatically registered and available.

### Arguments
- **local** (logical) - Optional - Return only local servers (i.e., not automatically registered cloud servers).

### Value
A data frame with registered server names and URLs.
```

--------------------------------

### listDeploymentFiles(appDir, appFiles = NULL, appFileManifest = NULL, error_call = caller_env())

Source: https://rstudio.github.io/rsconnect/reference/listDeploymentFiles.html

Returns a vector of file paths to be bundled in an application deployment based on the provided directory and optional file filters.

```APIDOC
## listDeploymentFiles

### Description
Given an app directory, and optional `appFiles` and `appFileManifest` arguments, returns a vector of paths to bundle in the app. It automatically excludes version control directories, internal config files, and RStudio state, and respects exclusions defined in a `.rscignore` file.

### Usage
`listDeploymentFiles(appDir, appFiles = NULL, appFileManifest = NULL, error_call = caller_env())`

### Arguments
- **appDir** (character) - A directory containing an application (e.g. a Shiny app or plumber API). Defaults to the current directory.
- **appFiles** (character vector) - Optional. A character vector of files to bundle in the app.
- **appFileManifest** (character) - Optional. A path to a file containing a list of files to bundle.
- **error_call** (environment) - The call or environment for error reporting; expert use only.

### Value
Returns a character vector of paths to bundle, relative to `appDir`.
```

--------------------------------

### deployAPI(api, ...)

Source: https://rstudio.github.io/rsconnect/reference/deployAPI.html

Deploys an application consisting of plumber API routes from a specified directory.

```APIDOC
## deployAPI(api, ...)

### Description
Deploys an application consisting of plumber API routes. The given directory must contain a script returning a plumb object or a plumber API definition.

### Usage
```R
deployAPI(api, ...)
```

### Arguments
- **api** (string) - Required - Path to the API project directory. Must contain either entrypoint.R or plumber.R (for plumber APIs) or _server.yml (for plumber2 APIs).
- **...** (dots) - Optional - Additional arguments to deployApp().

### Details
Deploy a plumber API definition by either supplying a directory containing plumber.R (an API definition) or entrypoint.R that returns a plumb object created by plumber::plumb(). Alternatively, deploy a plumber2 API by supplying a directory containing _server.yml.
```

--------------------------------

### Load rsconnect library

Source: https://rstudio.github.io/rsconnect/articles/custom-http.html

Initializes the rsconnect package for use in R scripts.

```R
library(rsconnect)
```

--------------------------------

### Usage of listAccountEnvVars and updateAccountEnvVars

Source: https://rstudio.github.io/rsconnect/reference/listAccountEnvVars.html

Functions for managing environment variables on Posit Connect servers. Requires specifying the server or account context.

```R
listAccountEnvVars(server = NULL, account = NULL)

updateAccountEnvVars(envVars, server = NULL, account = NULL)
```

--------------------------------

### Show Application Properties in R

Source: https://rstudio.github.io/rsconnect/reference/showProperties.html

Retrieves properties for a deployed application. Requires specifying the application path or name, and optionally the account or server.

```R
showProperties(
  appPath = getwd(),
  appName = NULL,
  account = NULL,
  server = NULL
)
```

--------------------------------

### Generate a manifest.json file

Source: https://rstudio.github.io/rsconnect/reference/writeManifest.html

Use this function to generate the manifest.json file required for Posit Connect deployments.

```R
writeManifest(
  appDir = getwd(),
  appFiles = NULL,
  appFileManifest = NULL,
  appPrimaryDoc = NULL,
  appMode = NULL,
  contentCategory = NULL,
  python = NULL,
  forceGeneratePythonEnvironment = FALSE,
  quarto = NA,
  image = NULL,
  envManagement = NULL,
  envManagementR = NULL,
  envManagementPy = NULL,
  envManagementNodejs = NULL,
  packageRepositoryResolutionR = NULL,
  dependencyResolution = c("strict", "library"),
  verbose = FALSE,
  quiet = FALSE
)
```

--------------------------------

### Usage of deployDoc

Source: https://rstudio.github.io/rsconnect/reference/deployDoc.html

Standard function signature for deploying a document with optional logging levels.

```R
deployDoc(doc, ..., logLevel = c("normal", "quiet", "verbose"))
```

--------------------------------

### listAccountEnvVars()

Source: https://rstudio.github.io/rsconnect/reference/listAccountEnvVars.html

Lists the environment variables used by every application published to the specified account.

```APIDOC
## listAccountEnvVars()

### Description
Lists the environment variables used by every application published to the specified account.

### Arguments
- **server** (string) - Optional - The name of the remote server.
- **account** (string) - Optional - The user account name.

### Value
Returns a data frame with one row for each application, containing columns: `id`, `guid`, `name`, and `envVars` (a list-column).
```

--------------------------------

### applications(account = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/applications.html

Retrieves a data frame of all applications deployed for a given account or server.

```APIDOC
## applications(account = NULL, server = NULL)

### Description
List all applications currently deployed for a given account. Supported on all servers.

### Arguments
- **account** (string) - Optional - The user account name to identify the remote server.
- **server** (string) - Optional - The server name to identify the remote server.

### Value
Returns a data frame with the following columns:
- **id** (string) - Application unique id
- **name** (string) - Name of application
- **title** (string) - Application title
- **url** (string) - URL where application can be accessed
- **status** (string) - Current status of application (pending, deploying, running, terminating, terminated)
- **size** (string) - Instance size (on ShinyApps.io)
- **instances** (integer) - Number of instances (on ShinyApps.io)
- **config_url** (string) - URL where application can be configured

### Examples
# list all applications for the default account
applications()

# list all applications for a specific account
applications("myaccount")
```

--------------------------------

### showLogs()

Source: https://rstudio.github.io/rsconnect/reference/showLogs.html

Displays the logs for a deployed ShinyApps application.

```APIDOC
## showLogs()

### Description
Displays the logs for a deployed ShinyApps application.

### Arguments
- **appPath** (character) - Optional - The path to the directory or file that was deployed. Defaults to getwd().
- **appFile** (character) - Optional - The path to the R source file that contains the application (for single file applications).
- **appName** (character) - Optional - The name of the application to show logs for.
- **account** (character) - Optional - The account under which the application was deployed.
- **server** (character) - Optional - Server name. Required only if you use the same account name on multiple servers.
- **entries** (numeric) - Optional - The number of log entries to show. Defaults to 50.
- **streaming** (logical) - Optional - Deprecated. Defaults to FALSE.
```

--------------------------------

### addServerCertificate(name, certificate, quiet = FALSE)

Source: https://rstudio.github.io/rsconnect/reference/addServer.html

Adds a certificate to a registered server.

```APIDOC
## addServerCertificate

### Description
Adds a certificate to an existing server registration.

### Arguments
- **name** (string) - Required - The name of the server.
- **certificate** (string) - Required - Path to certificate file or a character vector containing the certificate's contents.
- **quiet** (boolean) - Optional - Suppress output and prompts.
```

--------------------------------

### Restart an Application Usage

Source: https://rstudio.github.io/rsconnect/reference/restartApp.html

Basic syntax for invoking the restartApp function with the required application name.

```R
restartApp(appName, account = NULL, server = NULL, quiet = FALSE)
```

--------------------------------

### migrateToConnectCloud(appPath = ".", contentId, cloudAccount = NULL, appName = NULL, account = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/migrateToConnectCloud.html

Rewrites a local deployment record to point at an existing Posit Connect Cloud content item. This allows subsequent deployApp() calls to route to Connect Cloud.

```APIDOC
## migrateToConnectCloud

### Description
Rewrites a local deployment record to point at an existing Posit Connect Cloud content item so that subsequent `deployApp()` calls route to Connect Cloud instead of the original server. This function updates only the local `.dcf` file on disk.

### Usage
`migrateToConnectCloud(appPath = ".", contentId, cloudAccount = NULL, appName = NULL, account = NULL, server = NULL)`

### Arguments
- **appPath** (string) - Optional - Path to the content directory. Defaults to the current working directory.
- **contentId** (string) - Required - The Connect Cloud content ID found in the content URL.
- **cloudAccount** (string) - Optional - Local name of the Connect Cloud account to write the new record under.
- **appName** (string) - Optional - Name for the reconstructed record if no source record exists.
- **account** (string) - Optional - Filter to disambiguate the source deployment record.
- **server** (string) - Optional - Filter to disambiguate the source deployment record.

### Value
The path to the new deployment record file, invisibly.
```

--------------------------------

### accountInfo(name = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/accounts.html

Returns a list containing detailed information for a specific registered account.

```APIDOC
## accountInfo(name = NULL, server = NULL)

### Description
Returns a list with account details for the specified account.

### Parameters
- **name** (string) - Optional - Name of account.
- **server** (string) - Optional - Name of the server on which the account is registered.
```

--------------------------------

### Deploy an Application with deployApp

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

The primary function for deploying applications, accepting parameters for directory, file management, environment variables, and server configuration.

```R
deployApp(
  appDir = getwd(),
  appFiles = NULL,
  appFileManifest = NULL,
  manifestPath = NULL,
  appPrimaryDoc = NULL,
  appSourceDoc = NULL,
  appName = NULL,
  appTitle = NULL,
  envVars = NULL,
  appId = NULL,
  appMode = NULL,
  contentCategory = NULL,
  account = NULL,
  server = NULL,
  upload = TRUE,
  recordDir = NULL,
  launch.browser = getOption("rsconnect.launch.browser", is_interactive()),
  on.failure = NULL,
  logLevel = c("normal", "quiet", "verbose"),
  lint = TRUE,
  metadata = list(),
  forceUpdate = NULL,
  python = NULL,
  forceGeneratePythonEnvironment = FALSE,
  quarto = NA,
  appVisibility = NULL,
  image = NULL,
  envManagement = NULL,
  envManagementR = NULL,
  envManagementPy = NULL,
  envManagementNodejs = NULL,
  packageRepositoryResolutionR = NULL,
  dependencyResolution = c("strict", "library")
)
```

--------------------------------

### deployTFModel()

Source: https://rstudio.github.io/rsconnect/reference/deployTFModel.html

Deploys a directory containing a TensorFlow saved model to Posit Connect or ShinyApps servers.

```APIDOC
## deployTFModel()

### Description
Deploys a directory containing a TensorFlow saved model. This function is compatible with Posit Connect and ShinyApps servers.

### Usage
`deployTFModel(...)`

### Arguments
- **...** - Additional arguments passed to `deployApp()`.
```

--------------------------------

### syncAppMetadata(appPath = ".")

Source: https://rstudio.github.io/rsconnect/reference/syncAppMetadata.html

Updates the deployment records for applications published to Posit Connect.

```APIDOC
## syncAppMetadata

### Description
Update the deployment records for applications published to Posit Connect. This updates application title and URL, and deletes records for deployments where the application has been deleted on the server.

### Usage
`syncAppMetadata(appPath = ".")`

### Arguments
- **appPath** (string) - Optional - The path to the directory or file that was deployed. Defaults to ".".
```

--------------------------------

### rpubsUpload(title, contentFile, originalDoc, id = NULL, properties = list())

Source: https://rstudio.github.io/rsconnect/reference/rpubsUpload.html

Publishes a file to rpubs.com. Returns a list containing an 'id' and 'continueUrl' upon success, or an 'error' element upon failure.

```APIDOC
## rpubsUpload

### Description
Publishes a file to rpubs.com. If the upload succeeds, a list containing an `id` and `continueUrl` is returned. A browser should be opened to the `continueUrl` to complete the publishing process. If an error occurs, the returned list contains an `error` element.

### Arguments
- **title** (string) - The title of the document.
- **contentFile** (string) - The path to the content file to upload.
- **originalDoc** (string) - The document that was rendered to produce the contentFile. May be NULL if unknown.
- **id** (string) - Optional. The document ID to update if this is an update to an existing document.
- **properties** (list) - Optional. A named list containing additional document properties.

### Value
A named list. On success, contains `id` and `continueUrl`. On failure, contains `error`.
```

--------------------------------

### connectUser()

Source: https://rstudio.github.io/rsconnect/reference/connectApiUser.html

Connects a Posit Connect account using browser-based authentication.

```APIDOC
## connectUser(account = NULL, server = NULL, quiet = FALSE, launch.browser = getOption("rsconnect.launch.browser", interactive()))

### Description
Connects your Posit Connect account to the rsconnect package using an interactive browser-based authentication flow.

### Arguments
- **account** (string) - Optional - A name for the account to connect.
- **server** (string) - Optional - The server to connect to.
- **quiet** (boolean) - Optional - Whether or not to show messages and prompts while connecting the account.
- **launch.browser** (boolean/function) - Optional - If true, the system's default web browser will be launched automatically. Defaults to TRUE in interactive sessions.
```

--------------------------------

### setProperty Usage

Source: https://rstudio.github.io/rsconnect/reference/setProperty.html

Defines the function signature for setting application properties.

```R
setProperty(
  propertyName,
  propertyValue,
  appPath = getwd(),
  appName = NULL,
  account = NULL,
  server = NULL,
  force = FALSE
)
```

--------------------------------

### accounts(server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/accounts.html

Returns a data frame with the names of all accounts registered on the system and the servers on which they reside.

```APIDOC
## accounts(server = NULL)

### Description
Returns a data frame with the names of all accounts registered on the system and the servers on which they reside.

### Parameters
- **server** (string) - Optional - Name of the server on which the account is registered.
```

--------------------------------

### listBundleFiles(appDir)

Source: https://rstudio.github.io/rsconnect/reference/listBundleFiles.html

Returns the names of files that will be bundled in an application directory. Note that this function has been superseded by listDeploymentFiles().

```APIDOC
## listBundleFiles(appDir)

### Description
Given a directory containing an application, returns the names of the files that by default will be bundled in the application. It works similarly to a recursive directory listing but enforces bundle size constraints.

### Usage
listBundleFiles(appDir)

### Arguments
- **appDir** (string) - Required - Directory containing the application.

### Value
Returns a list containing the following elements:
- **totalFiles** (integer) - Total number of files.
- **totalSize** (integer) - Total size of the files in bytes.
- **contents** (array) - Paths to bundle, relative to appDir.
```

--------------------------------

### Usage of applications function

Source: https://rstudio.github.io/rsconnect/reference/applications.html

Basic syntax for calling the applications function to list deployed applications.

```R
applications(account = NULL, server = NULL)
```

--------------------------------

### Connect Posit Connect Cloud account

Source: https://rstudio.github.io/rsconnect/reference/connectCloudUser.html

Initiates the authentication flow to link a Posit Connect Cloud account. By default, it launches the system browser to complete the process.

```R
connectCloudUser(launch.browser = TRUE)
```

--------------------------------

### showInvited(appDir = getwd(), appName = NULL, account = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/showInvited.html

Lists invited users for an application on ShinyApps servers.

```APIDOC
## showInvited

### Description
Lists invited users for an application. This function is supported only for ShinyApps servers.

### Usage
`showInvited(appDir = getwd(), appName = NULL, account = NULL, server = NULL)`

### Arguments
- **appDir** (string) - Optional - Directory containing the application. Defaults to the current working directory.
- **appName** (string) - Optional - Name of the application.
- **account** (string) - Optional - The user account name to identify the remote server.
- **server** (string) - Optional - The server name to identify the remote server.

### Note
This function works only for ShinyApps servers.
```

--------------------------------

### showProperties(appPath = getwd(), appName = NULL, account = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/showProperties.html

Displays the properties of an application deployed to ShinyApps. This function is specific to ShinyApps servers.

```APIDOC
## showProperties

### Description
Show properties of an application deployed to ShinyApps. This function works only for ShinyApps servers.

### Usage
showProperties(appPath = getwd(), appName = NULL, account = NULL, server = NULL)

### Arguments
- **appPath** (character) - Optional - Directory or file that was deployed. Defaults to current working directory.
- **appName** (character) - Optional - Name of application.
- **account** (character) - Optional - Account name to identify the remote server.
- **server** (character) - Optional - Server name to identify the remote server.
```

--------------------------------

### Usage of listBundleFiles

Source: https://rstudio.github.io/rsconnect/reference/listBundleFiles.html

Call this function with the directory path containing the application to retrieve bundle information.

```R
listBundleFiles(appDir)
```

--------------------------------

### connectCloudUser()

Source: https://rstudio.github.io/rsconnect/reference/connectCloudUser.html

Connects a Posit Connect Cloud account to the rsconnect package by opening a browser for authentication.

```APIDOC
## connectCloudUser()

### Description
Connects your Posit Connect Cloud account to the rsconnect package so that it can deploy and manage applications on your behalf. It opens a browser window to authenticate and prompts you to select or create an account.

### Usage
connectCloudUser(launch.browser = TRUE)

### Arguments
- **launch.browser** (logical or function) - Optional - If TRUE, the system's default web browser is launched automatically. If a function is provided, it is called after the app starts with the app URL as a parameter. Defaults to TRUE in interactive sessions.
```

--------------------------------

### deployApp

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Deploys an application to a remote server. This function handles the upload, configuration, and deployment process for various content types.

```APIDOC
## deployApp

### Description
Deploys an application to a remote server. This function manages the deployment lifecycle, including content identification, environment configuration, and server communication.

### Parameters
- **appId** (string) - Optional - The unique identifier for an existing application on the server.
- **appMode** (string) - Optional - The type of content being deployed (e.g., "shiny", "api", "static").
- **contentCategory** (string) - Optional - Classifies the kind of content (e.g., "plot", "site").
- **account** (string) - Optional - The user account name on the remote server.
- **server** (string) - Optional - The name of the remote server.
- **upload** (boolean) - Optional - Whether to upload the application from the local system (default: TRUE).
- **recordDir** (string) - Optional - Directory where the deployment record is written.
- **launch.browser** (boolean/function) - Optional - Whether to launch the browser after deployment.
- **on.failure** (function) - Optional - Callback function executed if deployment fails.
- **logLevel** (string) - Optional - Logging verbosity: "quiet", "normal", or "verbose".
- **lint** (boolean) - Optional - Whether to lint the project before deployment.
- **metadata** (list) - Optional - Additional metadata fields to save with the deployment record.
- **forceUpdate** (boolean) - Optional - Whether to force an update if an app with the same name exists.
- **python** (string) - Optional - Path to a python binary for reticulate dependencies.
- **forceGeneratePythonEnvironment** (boolean) - Optional - Whether to overwrite existing requirements.txt.
- **quarto** (boolean/NA) - Optional - Whether to use Quarto for building the content.
- **appVisibility** (string) - Optional - Visibility setting: "private" or "public" (shinyapps.io only).
```

--------------------------------

### setAccountInfo(name, token, secret, server = "shinyapps.io")

Source: https://rstudio.github.io/rsconnect/reference/setAccountInfo.html

Configures a ShinyApps account for publishing from the system.

```APIDOC
## setAccountInfo

### Description
Configure a ShinyApps account for publishing from this system.

### Usage
setAccountInfo(name, token, secret, server = "shinyapps.io")

### Arguments
- **name** - Name of account to save or remove
- **token** - User token for the account
- **secret** - User secret for the account
- **server** - Server to associate account with (default: "shinyapps.io")

### Example
```r
# register an account
setAccountInfo("user", "token", "secret")
```
```

--------------------------------

### Register and remove a ShinyApps account

Source: https://rstudio.github.io/rsconnect/reference/setAccountInfo.html

Demonstrates the registration of an account and its subsequent removal.

```R
if (FALSE) { # \dontrun{

# register an account
setAccountInfo("user", "token", "secret")

# remove the same account
removeAccount("user")
} # }
```

--------------------------------

### listDeploymentFiles Usage

Source: https://rstudio.github.io/rsconnect/reference/listDeploymentFiles.html

The primary function for gathering files to be bundled with an application directory.

```R
listDeploymentFiles(
  appDir,
  appFiles = NULL,
  appFileManifest = NULL,
  error_call = caller_env()
)
```

--------------------------------

### showUsers(appDir = getwd(), appName = NULL, account = NULL, server = NULL)

Source: https://rstudio.github.io/rsconnect/reference/showUsers.html

Lists authorized users for an application on ShinyApps servers.

```APIDOC
## showUsers

### Description
List authorized users for an application. This function is supported only for ShinyApps servers.

### Usage
`showUsers(appDir = getwd(), appName = NULL, account = NULL, server = NULL)`

### Arguments
- **appDir** (string) - Optional - Directory containing application. Defaults to current working directory.
- **appName** (string) - Optional - Name of application.
- **account** (string) - Optional - User account name to identify the remote server.
- **server** (string) - Optional - Server name to identify the remote server.

### Note
This function works only for ShinyApps servers.
```

--------------------------------

### Usage of deployments function

Source: https://rstudio.github.io/rsconnect/reference/deployments.html

Defines the parameters for listing deployment records, including path and optional filters.

```R
deployments(
  appPath = ".",
  nameFilter = NULL,
  accountFilter = NULL,
  serverFilter = NULL,
  excludeOrphaned = TRUE
)
```

--------------------------------

### lint(project, files = NULL, appPrimaryDoc = NULL)

Source: https://rstudio.github.io/rsconnect/reference/lint.html

Applies the set of active linters to all files within a project directory.

```APIDOC
## lint(project, files = NULL, appPrimaryDoc = NULL)

### Description
Takes the set of active linters and applies them to all files within a project.

### Arguments
- **project** (string) - Required - Path to a project directory.
- **files** (vector) - Optional - Specific files to lint. If NULL, all files in the directory are linted.
- **appPrimaryDoc** (string) - Optional - The primary file in the project directory. If NULL, it is inferred from directory contents.
```

--------------------------------

### Configure rsconnect global options

Source: https://rstudio.github.io/rsconnect/reference/options.html

Set various diagnostic and behavioral options for rsconnect deployments using the standard R options function.

```r
if (FALSE) { # \dontrun{

# trace http requests
options(rsconnect.http.trace = TRUE)

# print verbose output for http requests
options(rsconnect.http.verbose = TRUE)

# print JSON content
options(rsconnect.http.trace.json = TRUE)

# don't automatically launch a browser after deployment
options(rsconnect.launch.browser = FALSE)
} # }
```

--------------------------------

### Configure ShinyApps account usage

Source: https://rstudio.github.io/rsconnect/reference/setAccountInfo.html

Defines the function signature for registering a ShinyApps account.

```R
setAccountInfo(name, token, secret, server = "shinyapps.io")
```

--------------------------------

### serverInfo()

Source: https://rstudio.github.io/rsconnect/reference/servers.html

Retrieves metadata about a specific server.

```APIDOC
## serverInfo(name = NULL)

### Description
Gets metadata about a specific server. If the name is omitted, the user will be prompted to pick a server.

### Arguments
- **name** (character) - Optional - The server name.

### Value
A list with details for a particular server, including name, url, and certificate.
```

--------------------------------

### Usage of rpubsUpload

Source: https://rstudio.github.io/rsconnect/reference/rpubsUpload.html

Standard function signature for initiating an RPubs upload.

```R
rpubsUpload(title, contentFile, originalDoc, id = NULL, properties = list())
```

--------------------------------

### Set HTTPS proxy environment variable

Source: https://rstudio.github.io/rsconnect/articles/custom-http.html

Configures the HTTPS proxy for network requests within an .rsconnect_profile file.

```R
Sys.setenv(https_proxy = "https://proxy.example.com")
```

--------------------------------

### restartApp(appName, account = NULL, server = NULL, quiet = FALSE)

Source: https://rstudio.github.io/rsconnect/reference/restartApp.html

Restarts an application currently running on a remote ShinyApps server.

```APIDOC
## restartApp

### Description
Restart an application currently running on a remote server. This function is supported only for ShinyApps servers.

### Usage
restartApp(appName, account = NULL, server = NULL, quiet = FALSE)

### Arguments
- **appName** (string) - Name of application to restart.
- **account** (string) - Account name. If a single account is registered on the system then this parameter can be omitted.
- **server** (string) - Server name. Required only if you use the same account name on multiple servers.
- **quiet** (boolean) - Request that no status information be printed to the console during the operation.

### Examples
```r
# restart an application
restartApp("myapp")
```
```

--------------------------------

### Deploy without browser launch

Source: https://rstudio.github.io/rsconnect/reference/deployApp.html

Prevent the automatic opening of a browser window upon successful deployment.

```R
deployApp(launch.browser = FALSE)
```

--------------------------------

### Purge Application Usage

Source: https://rstudio.github.io/rsconnect/reference/purgeApp.html

Basic syntax for calling the purgeApp function with required and optional parameters.

```R
purgeApp(appName, account = NULL, server = NULL, quiet = FALSE)
```
Tokens:
Raw