> For the complete documentation index, see [llms.txt](https://docs.keeper.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.keeper.io/keeperpam/commander-sdk/keeper-commander-sdks/sdk-command-reference/enterprise-management-commands/enterprise-push-command.md).

# Enterprise Push Command

Populate enterprise user vaults with templated records. Records can be assigned directly to users or to all users in selected teams.

## enterprise-push command

Populate user vaults with a set of template records.

<details>

<summary>DotNet CLI</summary>

**Command:** `enterprise-push`

**Usage:**

```bash
enterprise-push [options] [file_name]
```

**Parameter:**

* `--syntax-help` show example file format and template parameters
* `--team <TEAM NAME OR UID>` team to assign records to
* `--email <USER EMAIL, DISPLAY NAME OR UID>` user to assign records to
* `--users <USER1,USER2>` comma-separated users to assign records to
* `--teams <TEAM1,TEAM2>` comma-separated teams to assign records to
* `--dry-run` show planned record transfers without changing the vault
* `--format <table|csv|json>` dry-run output format
* `--output <FILE NAME>` output file for CSV or JSON dry-run results
*

**Example:**

```zsh
enterprise-push --team "Chicago Office" office-codes.json
enterprise-push --email Jane.Doe@gmail.com default.json
enterprise-push --syntax-help
```

</details>

<details>

<summary>DotNet SDK</summary>

**Function:** `PushEnterpriseRecords`

```csharp
public async Task<EnterprisePushResult> PushEnterpriseRecords(VaultOnline vault,ImportRecord[] templateRecords,EnterprisePushOptions options = null)
```

**Parameters:**

* `vault` vault used to create and transfer the records.
* `templateRecords` template records to create.
* `options` target users, target teams, dry-run setting, and warning callback.

**Options:**

* `Users` target user email, display name, or enterprise user ID.
* `Teams` target team name or team UID.
* `DryRun` show planned transfers without changing the vault.

**Example:**

```csharp
var result = await enterpriseData.PushEnterpriseRecords(
    vault,
    templateRecords,
    new EnterprisePushOptions
    {
        Users = new[] { "user@company.com" },
        Teams = new[] { "Chicago Office" },
        DryRun = false
    });
```

</details>

<details>

<summary>PowerCommander</summary>

**Command:** `Invoke-KeeperEnterprisePush`

**Alias: kep**

**Flags:**

| Parameters  | Description                                                |
| ----------- | ---------------------------------------------------------- |
| `-FileName` | JSON file containing template records. Required.           |
| `-Email`    | one target user email, display name, or enterprise user ID |
| `-Users`    | additional target users.                                   |
| `-Teams`    | target team name or UID.                                   |
| `-DryRun`   | show planned transfers without changing the vault          |

**Example:**

```powershell
# Send records to a user
PS> Invoke-KeeperEnterprisePush `
       -FileName default.json `
       -Email Jane.Doe@gmail.com

# Send records to all users in a team
PS> kep `
       -FileName office-codes.json `
       -Team "Chicago Office"

# Send records to multiple users and teams
PS> kep `
       -FileName default.json `
       -Users user1@company.com,user2@company.com `
       -Teams "Chicago Office,Support"

# Preview the transfers
PS> kep `
       -FileName default.json `
       -Team "Chicago Office" `
       -DryRun
```

</details>

### File Format

The `enterprise-push` command uses Keeper JSON record import format.

The template file can be either:

* An array of records
* An object containing a `records` array

Example JSON file:

```json
[
  {
    "title": "Google",
    "login": "${user_email}",
    "password": "${generate_password}",
    "login_url": "https://google.com",
    "notes": "",
    "custom_fields": {
      "Name 1": "Value 1",
      "Name 2": "Value 2"
    }
  },
  {
    "title": "Admin Tool",
    "login": "${user_email}",
    "password": "",
    "login_url": "https://192.168.1.1",
    "notes": "",
    "custom_fields": {}
  }
]
```

**Supported template parameters:**

```
${user_email}          Target user's email address
${user_name}           Target user's full name
${generate_password}   Generate a random password
```

To export JSON data for a template:

1. Create an empty folder for storing templates, such as `Templates`.
2. Add the required records to that folder.
3. Export the folder as JSON:

```
export --format=json --folder=Templates templates.json
```

The `uid` and `folders` properties are not used by `enterprise-push` because new records are generated and transferred for each target user.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.keeper.io/keeperpam/commander-sdk/keeper-commander-sdks/sdk-command-reference/enterprise-management-commands/enterprise-push-command.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.