---
product: Chilkat
product_version: 11.7.0
language: delphidll
language_label: Delphi DLL
class: Scp
license: bundle
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/dd_CkScpRef.html
---
# Chilkat Scp — Delphi DLL — v11.7.0

> Chilkat 11.7.0 · language=delphidll · class=Scp
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/Scp.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/guide.md`.

## Purpose

**Transfer files, text, and binary data over SCP using an existing SSH connection.**

`Chilkat.Scp` is the Chilkat class for SCP file transfer over an already-established `Chilkat.Ssh` connection. It supports local-file upload and download, in-memory binary transfer, encoded binary transfer, text transfer with explicit character sets, `BinData` transfer, directory-tree synchronization, sync filtering, remote UNIX permission overrides, environment variables, progress scaling, abort support, and asynchronous task integration.

**Uses an SSH connection**

Attach `Scp` to an authenticated `Chilkat.Ssh` session rather than opening a separate network connection.

**Upload and download files**

Transfer local files to remote paths or download remote files to the local filesystem using SCP.

**Memory-based transfers**

Upload or download binary data, encoded data, text, or `Chilkat.BinData` without requiring temporary files.

**Directory synchronization**

Synchronize directory trees and use filtering options to include or exclude selected files.

**Remote file options**

Set remote UNIX permissions, pass environment variables, and control transfer-related behavior required by the remote server.

**Progress and async support**

Monitor progress, scale progress percentages, abort active transfers, and run supported operations as asynchronous tasks.

**Common pattern:** Connect and authenticate with `Chilkat.Ssh`, initialize `Chilkat.Scp` with that SSH connection, then upload, download, or synchronize the desired files or in-memory data. Use `Scp` for SCP-style transfers over SSH; use `Chilkat.SFtp` when the remote server expects the SFTP protocol instead.

For an extended overview, see [Scp Class Overview](https://www.chilkatsoft.com/scp_class_overview.asp).

## Object creation, unlocking and error handling

**Create/Dispose**

```pascal
var
myObject: HCkScp;

begin
myObject := CkScp_Create();

// ...

CkScp_Dispose(myObject);
end;
```

`function CkScp_Create: HCkScp; stdcall;`

Creates an instance of the HCkScp object and returns a handle (i.e. a Pointer). The handle is passed in the 1st argument for the functions listed on this page.

`procedure CkScp_Dispose(handle: HCkScp); stdcall;`

Objects created by calling CkScp_Create must be freed by calling this method. A memory leak occurs if a handle is not disposed by calling this function.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Delphi DLL.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `procedure CkScp_getDebugLogFilePath(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putDebugLogFilePath(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__debugLogFilePath(objHandle: HCkScp): PWideChar; stdcall;` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastErrorHtml` | `procedure CkScp_getLastErrorHtml(objHandle: HCkScp; outPropVal: HCkString); stdcall; function CkScp__lastErrorHtml(objHandle: HCkScp): PWideChar; stdcall;` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `procedure CkScp_getLastErrorText(objHandle: HCkScp; outPropVal: HCkString); stdcall; function CkScp__lastErrorText(objHandle: HCkScp): PWideChar; stdcall;` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `procedure CkScp_getLastErrorXml(objHandle: HCkScp; outPropVal: HCkString); stdcall; function CkScp__lastErrorXml(objHandle: HCkScp): PWideChar; stdcall;` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `function CkScp_getLastMethodSuccess(objHandle: HCkScp): wordbool; stdcall; procedure CkScp_putLastMethodSuccess(objHandle: HCkScp; newPropVal: wordbool); stdcall;` | read/write | Indicates the success or failure of the most recent method call: `True` means success, `False` means failure. |
| `VerboseLogging` | `function CkScp_getVerboseLogging(objHandle: HCkScp): wordbool; stdcall; procedure CkScp_putVerboseLogging(objHandle: HCkScp; newPropVal: wordbool); stdcall;` | read/write | If set to `True`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `procedure CkScp_getVersion(objHandle: HCkScp; outPropVal: HCkString); stdcall; function CkScp__version(objHandle: HCkScp): PWideChar; stdcall;` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `AbortCurrent` | property, read/write | `function CkScp_getAbortCurrent(objHandle: HCkScp): wordbool; stdcall; procedure CkScp_putAbortCurrent(objHandle: HCkScp; newPropVal: wordbool); stdcall;` |
| `HeartbeatMs` | property, read/write | `function CkScp_getHeartbeatMs(objHandle: HCkScp): Integer; stdcall; procedure CkScp_putHeartbeatMs(objHandle: HCkScp; newPropVal: Integer); stdcall;` |
| `PercentDoneScale` | property, read/write | `function CkScp_getPercentDoneScale(objHandle: HCkScp): Integer; stdcall; procedure CkScp_putPercentDoneScale(objHandle: HCkScp; newPropVal: Integer); stdcall;` |
| `SendEnv` | property, read/write | `procedure CkScp_getSendEnv(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSendEnv(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__sendEnv(objHandle: HCkScp): PWideChar; stdcall;` |
| `SyncedFiles` | property, read/write | `procedure CkScp_getSyncedFiles(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSyncedFiles(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__syncedFiles(objHandle: HCkScp): PWideChar; stdcall;` |
| `SyncMustMatch` | property, read/write | `procedure CkScp_getSyncMustMatch(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSyncMustMatch(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__syncMustMatch(objHandle: HCkScp): PWideChar; stdcall;` |
| `SyncMustMatchDir` | property, read/write | `procedure CkScp_getSyncMustMatchDir(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSyncMustMatchDir(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__syncMustMatchDir(objHandle: HCkScp): PWideChar; stdcall;` |
| `SyncMustNotMatch` | property, read/write | `procedure CkScp_getSyncMustNotMatch(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSyncMustNotMatch(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__syncMustNotMatch(objHandle: HCkScp): PWideChar; stdcall;` |
| `SyncMustNotMatchDir` | property, read/write | `procedure CkScp_getSyncMustNotMatchDir(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putSyncMustNotMatchDir(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__syncMustNotMatchDir(objHandle: HCkScp): PWideChar; stdcall;` |
| `UncommonOptions` | property, read/write | `procedure CkScp_getUncommonOptions(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putUncommonOptions(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__uncommonOptions(objHandle: HCkScp): PWideChar; stdcall;` |
| `UnixPermOverride` | property, read/write | `procedure CkScp_getUnixPermOverride(objHandle: HCkScp; outPropVal: HCkString); stdcall; procedure CkScp_putUnixPermOverride(objHandle: HCkScp; newPropVal: PWideChar); stdcall; function CkScp__unixPermOverride(objHandle: HCkScp): PWideChar; stdcall;` |
| `DownloadBd` | method | `function CkScp_DownloadBd(objHandle: HCkScp;     remotePath: PWideChar;     bd: HCkBinData): wordbool; stdcall;` |
| `DownloadBinaryEncoded` | method | `function CkScp_DownloadBinaryEncoded(objHandle: HCkScp;     remotePath: PWideChar;     encoding: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkScp__downloadBinaryEncoded(objHandle: HCkScp;     remotePath: PWideChar;     encoding: PWideChar): PWideChar; stdcall;` |
| `DownloadFile` | method | `function CkScp_DownloadFile(objHandle: HCkScp;     remotePath: PWideChar;     localPath: PWideChar): wordbool; stdcall;` |
| `DownloadString` | method | `function CkScp_DownloadString(objHandle: HCkScp;     remotePath: PWideChar;     charset: PWideChar;     outStr: HCkString): wordbool; stdcall; function CkScp__downloadString(objHandle: HCkScp;     remotePath: PWideChar;     charset: PWideChar): PWideChar; stdcall;` |
| `LoadTaskCaller` | method | `function CkScp_LoadTaskCaller(objHandle: HCkScp;     task: HCkTask): wordbool; stdcall;` |
| `SyncTreeDownload` | method | `function CkScp_SyncTreeDownload(objHandle: HCkScp;     remoteRoot: PWideChar;     localRoot: PWideChar;     mode: Integer;     bRecurse: wordbool): wordbool; stdcall;` |
| `SyncTreeUpload` | method | `function CkScp_SyncTreeUpload(objHandle: HCkScp;     localBaseDir: PWideChar;     remoteBaseDir: PWideChar;     mode: Integer;     bRecurse: wordbool): wordbool; stdcall;` |
| `UploadBd` | method | `function CkScp_UploadBd(objHandle: HCkScp;     remotePath: PWideChar;     bd: HCkBinData): wordbool; stdcall;` |
| `UploadBinaryEncoded` | method | `function CkScp_UploadBinaryEncoded(objHandle: HCkScp;     remotePath: PWideChar;     encodedData: PWideChar;     encoding: PWideChar): wordbool; stdcall;` |
| `UploadFile` | method | `function CkScp_UploadFile(objHandle: HCkScp;     localPath: PWideChar;     remotePath: PWideChar): wordbool; stdcall;` |
| `UploadString` | method | `function CkScp_UploadString(objHandle: HCkScp;     remotePath: PWideChar;     textData: PWideChar;     charset: PWideChar): wordbool; stdcall;` |
| `UseSsh` | method | `function CkScp_UseSsh(objHandle: HCkScp;     sshConnection: HCkSsh): wordbool; stdcall;` |

Deprecated members are listed at the end of this file with their replacements; do not use them in new code.

## Properties

### Scp.AbortCurrent

`Chilkat 11.7.0 · delphidll · Scp · AbortCurrent · property · read/write · since 9.5.0.58`

```pascal
function CkScp_getAbortCurrent(objHandle: HCkScp): wordbool; stdcall;
procedure CkScp_putAbortCurrent(objHandle: HCkScp; newPropVal: wordbool); stdcall;
```

Set to `True` to request cancellation of the method currently executing on this object. Long-running network and file-transfer operations check this property periodically; a method that completes quickly may finish before the request is observed.

Both synchronous and asynchronous operations can be cancelled. To cancel a synchronous call, set this property from another thread on the same `Scp` object. Chilkat resets the property to `False` after the cancellation is processed. If no method is running, a previously set value is cleared when the next method begins.

**Cooperative cancellation:** This property requests an abort; it does not forcibly terminate a thread. Use the method return value, `LastMethodSuccess` where applicable, and `LastErrorText` to determine the final outcome.

### Scp.HeartbeatMs

`Chilkat 11.7.0 · delphidll · Scp · HeartbeatMs · property · read/write`

```pascal
function CkScp_getHeartbeatMs(objHandle: HCkScp): Integer; stdcall;
procedure CkScp_putHeartbeatMs(objHandle: HCkScp; newPropVal: Integer); stdcall;
```

**Full documentation for this property (same in every language):** [Event Callback Examples](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/event_callback_examples.md)

Specifies the interval, in milliseconds, between `AbortCheck` event callbacks during supported long-running operations. The callback allows the application to report activity or request cancellation before the operation completes.

The default value is `0`, which disables periodic `AbortCheck` callbacks.

**Event-callback setting:** This property is useful only in programming environments that support Chilkat event callbacks. It is not an SSH keep-alive interval and does not change connection or read timeouts.

### Scp.PercentDoneScale

`Chilkat 11.7.0 · delphidll · Scp · PercentDoneScale · property · read/write · since 9.5.0.51`

```pascal
function CkScp_getPercentDoneScale(objHandle: HCkScp): Integer; stdcall;
procedure CkScp_putPercentDoneScale(objHandle: HCkScp; newPropVal: Integer); stdcall;
```

Specifies the value that represents 100% completion in `PercentDone` event callbacks. The default is `100`, which reports progress in whole-percent units. For example, when the scale is `1000`, a callback value of `453` represents 45.3% completion.

The value is limited to the range `10` through `100000`. Increasing the scale provides finer numeric granularity for operations whose progress can be measured.

**Event-callback setting:** This property applies only in programming environments that support Chilkat event callbacks. A larger scale changes the meaning and possible granularity of callback values; it does not guarantee that every intermediate value will be reported.

### Scp.SendEnv

`Chilkat 11.7.0 · delphidll · Scp · SendEnv · property · read/write · since 9.5.0.79`

```pascal
procedure CkScp_getSendEnv(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSendEnv(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__sendEnv(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies environment variables to send for each SCP upload or download. Set the property to a JSON object whose member names are environment-variable names and whose values are strings.

```
{
  "LCS_PASSWORD": "myPassword",
  "SOME_ENV_VAR": "some_value"
}
```

**Server policy controls acceptance:** SCP transfers run through SSH channels. The SSH server may accept, reject, or ignore requested environment variables according to its configuration. Do not assume that setting this property guarantees that the remote SCP process receives every variable.

**Sensitive values:** Environment variables can contain secrets, but they are not a substitute for SSH authentication. Avoid exposing sensitive values in application logs or diagnostic output.

### Scp.SyncedFiles

`Chilkat 11.7.0 · delphidll · Scp · SyncedFiles · property · read/write · since 9.5.0.51`

```pascal
procedure CkScp_getSyncedFiles(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSyncedFiles(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__syncedFiles(objHandle: HCkScp): PWideChar; stdcall;
```

Contains the local paths of the files transferred by the most recent call to `SyncTreeUpload` or `SyncTreeDownload`. Paths are listed one per line.

- After an upload, each line is the full local path of a source file that was uploaded.
- After a download, each line is the full local path of a destination file that was downloaded.

**Local paths only:** This property reports local filesystem paths, not remote paths. It lists files actually transferred by the last synchronization operation, rather than every file examined during comparison.

### Scp.SyncMustMatch

`Chilkat 11.7.0 · delphidll · Scp · SyncMustMatch · property · read/write · since 9.5.0.51`

```pascal
procedure CkScp_getSyncMustMatch(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSyncMustMatch(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__syncMustMatch(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies a semicolon-separated list of wildcard patterns for filenames that are eligible for transfer by `SyncTreeUpload` and `SyncTreeDownload`. A file is considered only when its filename matches at least one pattern.

For example, `*.xml;*.txt;*.csv` limits synchronization to XML, text, and CSV files. The default empty string imposes no include restriction.

**Pattern scope:** Patterns are matched against the final filename, not the full local or remote path. Directory traversal is controlled separately by `SyncMustMatchDir` and `SyncMustNotMatchDir`.

### Scp.SyncMustMatchDir

`Chilkat 11.7.0 · delphidll · Scp · SyncMustMatchDir · property · read/write · since 9.5.0.58`

```pascal
procedure CkScp_getSyncMustMatchDir(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSyncMustMatchDir(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__syncMustMatchDir(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies a semicolon-separated list of wildcard patterns for directory names that may be traversed by `SyncTreeUpload` and `SyncTreeDownload`. When this property is nonempty, synchronization descends only into directories whose names match at least one pattern.

For example, `a*;b*;c*` permits traversal into directories whose names begin with `a`, `b`, or `c`. The default empty string permits traversal into all directories, subject to `SyncMustNotMatchDir`.

**Pattern scope:** Each pattern is matched against the directory name itself, not its complete path. This property affects traversal; it does not directly select individual files.

### Scp.SyncMustNotMatch

`Chilkat 11.7.0 · delphidll · Scp · SyncMustNotMatch · property · read/write · since 9.5.0.51`

```pascal
procedure CkScp_getSyncMustNotMatch(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSyncMustNotMatch(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__syncMustNotMatch(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies a semicolon-separated list of wildcard patterns for filenames that must be skipped by `SyncTreeUpload` and `SyncTreeDownload`.

For example, `*.tmp;*.bak;*.log` excludes temporary, backup, and log files. The default empty string excludes no files.

**Pattern scope:** Patterns are matched against the final filename, not the full path. Use `SyncMustNotMatchDir` to prevent synchronization from entering selected directories and their subtrees.

### Scp.SyncMustNotMatchDir

`Chilkat 11.7.0 · delphidll · Scp · SyncMustNotMatchDir · property · read/write · since 9.5.0.58`

```pascal
procedure CkScp_getSyncMustNotMatchDir(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putSyncMustNotMatchDir(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__syncMustNotMatchDir(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies a semicolon-separated list of wildcard patterns for directory names that must not be traversed by `SyncTreeUpload` and `SyncTreeDownload`. A matching directory and everything below it are skipped.

For example, `temp*;cache*;.git` prevents traversal into temporary, cache, and Git metadata directories. The default empty string excludes no directories.

**Pattern scope:** Each pattern is matched against the directory name itself, not its complete path. This setting is especially useful during recursive synchronization because excluding a directory avoids scanning its entire subtree.

### Scp.UncommonOptions

`Chilkat 11.7.0 · delphidll · Scp · UncommonOptions · property · read/write · since 9.5.0.77`

```pascal
procedure CkScp_getUncommonOptions(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putUncommonOptions(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__uncommonOptions(objHandle: HCkScp): PWideChar; stdcall;
```

Provides a comma-separated list of specialized compatibility options. The default is the empty string, which is appropriate for normal SCP transfers.

| Keyword | Behavior |
| :--- | :--- |
| `FilenameOnly` | Uses only the filename, rather than the complete target path, in the remote `scp -t` command. This option exists for compatibility with systems such as certain LANCOM routers. |
| `ProtectFromVpn` | On Android, attempts to route the SCP connection outside an installed or active VPN. |

**Leave empty unless needed:** These options alter uncommon platform or server compatibility behavior. Enable a keyword only when a Chilkat example, release note, or support response identifies it as necessary for the target environment.

### Scp.UnixPermOverride

`Chilkat 11.7.0 · delphidll · Scp · UnixPermOverride · property · read/write · since 9.5.0.77`

```pascal
procedure CkScp_getUnixPermOverride(objHandle: HCkScp; outPropVal: HCkString); stdcall;
procedure CkScp_putUnixPermOverride(objHandle: HCkScp; newPropVal: PWideChar); stdcall;
function CkScp__unixPermOverride(objHandle: HCkScp): PWideChar; stdcall;
```

Specifies an octal UNIX permission mode to apply to files uploaded by SCP, overriding the permissions derived from the local source file. For example, set this property to `0644` to grant read/write permission to the owner and read-only permission to the group and others.

The default is the empty string, which causes the uploaded file's remote permissions to be based on the local file's permissions.

**UNIX permission notation:** Supply the mode as a string containing octal digits, such as `0600`, `0644`, or `0755`. The remote SSH account must still have permission to create or replace the file, and server-side policy may restrict the final mode.

## Methods

### Scp.DownloadBd

`Chilkat 11.7.0 · delphidll · Scp · DownloadBd · method · since 9.5.0.77`

```pascal
function CkScp_DownloadBd(objHandle: HCkScp;
    remotePath: PWideChar;
    bd: HCkBinData): wordbool; stdcall;
```

Downloads the file at `remotePath` and appends its exact bytes to the existing contents of the `BinData` object in `bd`.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory.

**Append behavior:** This method does not clear `bd` before downloading. Clear the `BinData` object first when the downloaded file should replace, rather than follow, its current contents.

Returns True for success, False for failure.

Async variant: `DownloadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.DownloadBinaryEncoded

`Chilkat 11.7.0 · delphidll · Scp · DownloadBinaryEncoded · method · since 9.5.0.51`

```pascal
function CkScp_DownloadBinaryEncoded(objHandle: HCkScp;
    remotePath: PWideChar;
    encoding: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkScp__downloadBinaryEncoded(objHandle: HCkScp;
    remotePath: PWideChar;
    encoding: PWideChar): PWideChar; stdcall;
```

**Full documentation for this method (same in every language):** [List of Supported Encodings (Base64, Hex, etc.)](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Downloads the file at `remotePath` and returns its bytes encoded as text using the binary encoding named by `encoding`, such as `base64` or `hex`.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory.

**Binary encoding versus charset:** `encoding` selects a text representation of arbitrary bytes; it is not a character set and does not decode the remote file as text. Use `DownloadString` when the remote file contains text that must be decoded with a charset.

**Memory use:** The complete file and its encoded representation are held in memory. Encodings such as Base64 also increase the amount of data returned.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

Async variant: `DownloadBinaryEncodedAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.DownloadFile

`Chilkat 11.7.0 · delphidll · Scp · DownloadFile · method · since 9.5.0.51`

```pascal
function CkScp_DownloadFile(objHandle: HCkScp;
    remotePath: PWideChar;
    localPath: PWideChar): wordbool; stdcall;
```

Downloads the file at `remotePath` from the SSH server and writes its bytes to the local filesystem path in `localPath`.

An absolute remote path begins with `/`. A relative remote path is interpreted relative to the authenticated SSH user's home directory. The application must have permission to create or replace the local destination file.

**Streaming transfer:** This method is the preferred download method for large files because the data is written to disk rather than returned as one in-memory byte array or string.

Returns True for success, False for failure.

Async variant: `DownloadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.DownloadString

`Chilkat 11.7.0 · delphidll · Scp · DownloadString · method · since 9.5.0.51`

```pascal
function CkScp_DownloadString(objHandle: HCkScp;
    remotePath: PWideChar;
    charset: PWideChar;
    outStr: HCkString): wordbool; stdcall;
function CkScp__downloadString(objHandle: HCkScp;
    remotePath: PWideChar;
    charset: PWideChar): PWideChar; stdcall;
```

Downloads the file at `remotePath`, decodes its bytes using the character encoding named by `charset`, and returns the resulting text.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory.

**Charset matters:** `charset` describes how the remote file’s bytes represent characters, for example `utf-8`, `windows-1252`, or `iso-8859-1`. Using the wrong charset can produce incorrect characters. Use a binary download method for files that are not text.

Returns True for success, False for failure.

See the notes about [PWideChar memory ownership and validity](https://www.chilkatsoft.com/delphi_pwidechar.asp).

Async variant: `DownloadStringAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.LoadTaskCaller

`Chilkat 11.7.0 · delphidll · Scp · LoadTaskCaller · method · since 9.5.0.80`

```pascal
function CkScp_LoadTaskCaller(objHandle: HCkScp;
    task: HCkTask): wordbool; stdcall;
```

Loads the original caller object associated with the asynchronous `Task` in `task`. `task` must be a task created by a compatible asynchronous method of this class.

**Normally not application-facing:** This is a support method for Chilkat async-task infrastructure and generated language wrappers. It does not load arbitrary task results or transfer data.

Returns True for success, False for failure.

### Scp.SyncTreeDownload

`Chilkat 11.7.0 · delphidll · Scp · SyncTreeDownload · method · since 9.5.0.51`

```pascal
function CkScp_SyncTreeDownload(objHandle: HCkScp;
    remoteRoot: PWideChar;
    localRoot: PWideChar;
    mode: Integer;
    bRecurse: wordbool): wordbool; stdcall;
```

Synchronizes files from the remote directory tree rooted at `remoteRoot` to the local directory rooted at `localRoot`. `bRecurse` controls recursion: set it to `True` to descend into subdirectories, or `False` to process only files directly in the root directory.

An absolute remote root begins with `/`; a relative remote root is interpreted relative to the authenticated SSH user's home directory. A relative local root is interpreted relative to the application's current working directory.

| Mode | Files transferred |
| :--- | :--- |
| `0` | Download every eligible file. |
| `1` | Download files that do not already exist locally. |
| `2` | Download files that are missing locally or whose remote last-modified time is newer than the local file. |
| `3` | Download only files whose remote last-modified time is newer. A remote file that has no local counterpart is not downloaded. |
| `5` | Download files that are missing locally or whose size differs from the local file. |
| `6` | Download files that are missing locally, differ in size, or have a newer remote last-modified time. |

The filename and directory filters in `SyncMustMatch`, `SyncMustNotMatch`, `SyncMustMatchDir`, and `SyncMustNotMatchDir` are applied during traversal. After completion, `SyncedFiles` lists the full local paths of files actually downloaded.

**Timestamp-based modes:** Modes `2`, `3`, and `6` compare last-modified times. Incorrect server timestamps or clock differences between systems can affect which file is considered newer.

Returns True for success, False for failure.

Async variant: `SyncTreeDownloadAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.SyncTreeUpload

`Chilkat 11.7.0 · delphidll · Scp · SyncTreeUpload · method · since 9.5.0.51`

```pascal
function CkScp_SyncTreeUpload(objHandle: HCkScp;
    localBaseDir: PWideChar;
    remoteBaseDir: PWideChar;
    mode: Integer;
    bRecurse: wordbool): wordbool; stdcall;
```

Synchronizes files from the local directory tree rooted at `localBaseDir` to the remote directory rooted at `remoteBaseDir`. `bRecurse` controls recursion: set it to `True` to descend into subdirectories, or `False` to process only files directly in the local base directory.

A relative local base directory is interpreted relative to the application's current working directory. An absolute remote base directory begins with `/`; a relative remote base directory is interpreted relative to the authenticated SSH user's home directory.

| Mode | Files transferred |
| :--- | :--- |
| `0` | Upload every eligible file. |
| `1` | Upload files that do not already exist on the remote server. |
| `2` | Upload files that are missing remotely or whose local last-modified time is newer than the remote file. |
| `3` | Upload only files whose local last-modified time is newer. A local file that has no remote counterpart is not uploaded. |
| `4` | Upload files that are missing remotely or whose size differs from the remote file. |
| `5` | Upload files that are missing remotely, differ in size, or have a newer local last-modified time. |

The filename and directory filters in `SyncMustMatch`, `SyncMustNotMatch`, `SyncMustMatchDir`, and `SyncMustNotMatchDir` are applied during traversal. After completion, `SyncedFiles` lists the full local paths of files actually uploaded.

**Timestamp-based modes:** Modes `2`, `3`, and `5` compare last-modified times. Incorrect server timestamps or clock differences between systems can affect which file is considered newer.

Returns True for success, False for failure.

Async variant: `SyncTreeUploadAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.UploadBd

`Chilkat 11.7.0 · delphidll · Scp · UploadBd · method · since 9.5.0.77`

```pascal
function CkScp_UploadBd(objHandle: HCkScp;
    remotePath: PWideChar;
    bd: HCkBinData): wordbool; stdcall;
```

Uploads all bytes currently contained in the `BinData` object in `bd` to the remote file at `remotePath`. The data is transferred without character decoding or other transformation.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.

**Source object:** The upload reads the current contents of `bd` and does not remove or modify those bytes.

Returns True for success, False for failure.

Async variant: `UploadBdAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.UploadBinaryEncoded

`Chilkat 11.7.0 · delphidll · Scp · UploadBinaryEncoded · method · since 9.5.0.51`

```pascal
function CkScp_UploadBinaryEncoded(objHandle: HCkScp;
    remotePath: PWideChar;
    encodedData: PWideChar;
    encoding: PWideChar): wordbool; stdcall;
```

**Full documentation for this method (same in every language):** [List of Supported Encodings (Base64, Hex, etc.)](https://www.chilkatsoft.com/ai-docs/v/11.7.0/articles/binary_encodings.md)

Decodes the text in `encodedData` using the binary encoding named by `encoding`, then uploads the resulting bytes to the remote file at `remotePath`. Typical encoding names include `base64` and `hex`.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.

**The encoded text is not uploaded literally:** For example, when `encoding` is `base64`, Chilkat Base64-decodes `encodedData` and transfers the decoded binary bytes. This method is for encoded binary representations, not character-set conversion.

Returns True for success, False for failure.

Async variant: `UploadBinaryEncodedAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.UploadFile

`Chilkat 11.7.0 · delphidll · Scp · UploadFile · method · since 9.5.0.51`

```pascal
function CkScp_UploadFile(objHandle: HCkScp;
    localPath: PWideChar;
    remotePath: PWideChar): wordbool; stdcall;
```

Uploads the local filesystem file at `localPath` to the remote path in `remotePath`. The file is transferred as raw bytes.

An absolute remote path begins with `/`. A relative remote path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist, and the SSH account must have permission to create or replace the destination file.

Remote permissions are normally derived from the local file. Set `UnixPermOverride` when a specific remote UNIX mode is required.

**SCP is not FTP:** There is no ASCII or binary transfer mode. `UploadFile` copies the file bytes without line-ending or character-set conversion.

Returns True for success, False for failure.

Async variant: `UploadFileAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.UploadString

`Chilkat 11.7.0 · delphidll · Scp · UploadString · method · since 9.5.0.51`

```pascal
function CkScp_UploadString(objHandle: HCkScp;
    remotePath: PWideChar;
    textData: PWideChar;
    charset: PWideChar): wordbool; stdcall;
```

Encodes the text in `textData` using the character encoding named by `charset`, then uploads the resulting bytes to the remote file at `remotePath`.

An absolute remote path begins with `/`. A relative path is interpreted relative to the authenticated SSH user's home directory. The remote parent directory must already exist.

**Text encoding:** `charset` controls how characters are converted to bytes, for example `utf-8`, `windows-1252`, or `iso-8859-1`. SCP itself has no text mode; any line-ending characters already present in `textData` are encoded and transferred as part of the text.

Returns True for success, False for failure.

Async variant: `UploadStringAsync` — same arguments, returns a `Task` (see Async variants below).

### Scp.UseSsh

`Chilkat 11.7.0 · delphidll · Scp · UseSsh · method · since 9.5.0.51`

```pascal
function CkScp_UseSsh(objHandle: HCkScp;
    sshConnection: HCkSsh): wordbool; stdcall;
```

Associates this `Scp` object with the connected and authenticated `Ssh` object in `sshConnection`. Subsequent SCP operations use that existing SSH session rather than opening a separate network connection.

Connection, proxy, timeout, host-key verification, algorithm, logging, and other transport-related settings belong to the `Ssh` object and therefore apply to the SCP operations performed through it. Keep the SSH object connected and available for as long as the `Scp` object is using it.

**SCP and SFTP are different protocols:** `Scp` performs SCP-style transfers over SSH and requires compatible SCP support on the remote system. Use `Chilkat.SFtp` when the server expects the SSH File Transfer Protocol subsystem or when directory listing and remote file-management features are needed.

Returns True for success, False for failure.

## Events and callbacks

### Scp.AbortCheck (event)

`Chilkat 11.7.0 · delphidll · Scp · AbortCheck · event`

```pascal
function MyAbortCheck(): Integer; cdecl;
```

Enables a method call to be aborted by triggering the AbortCheck event at intervals defined by the `HeartbeatMs` property. If HeartbeatMs is set to its default value of 0, no events will occur. For instance, set HeartbeatMs to 200 to trigger 5 AbortCheck events per second. Return `True` to abort; return `False` to continue (not abort)

### Scp.PercentDone (event)

`Chilkat 11.7.0 · delphidll · Scp · PercentDone · event`

```pascal
function MyPercentDone(pctDone: Integer): Integer; cdecl;
```

This provides the percentage completion for any method involving network communications or time-consuming processing, assuming the progress can be measured as a percentage. This event is triggered only when it's possible and logical to express the operation's progress as a percentage. The `pctDone` argument will range from 1 to 100. For methods that finish quickly, the number of PercentDone callbacks may vary, but the final callback will have `pctDone` equal to 100. For longer operations, callbacks will not exceed one per percentage point (e.g., 1, 2, 3, ..., 98, 99, 100).

The PercentDone callback also acts as an `AbortCheck` event. For fast methods where PercentDone fires, an AbortCheck event may not trigger since the PercentDone callback already provides an opportunity to abort. For longer operations, where time between PercentDone callbacks is extended, AbortCheck callbacks enable more responsive operation termination.

Return `True` to abort; return `False` to continue (not abort)

### Scp.ProgressInfo (event)

`Chilkat 11.7.0 · delphidll · Scp · ProgressInfo · event`

```pascal
procedure MyProgressInfo(name: PWideChar; value: PWideChar) cdecl;
```

This event callback provides `tag name`/value pairs that detail what occurs during a method call. To discover existing tag names, create code to handle the event, emit the pairs, and review them. Most tag names are self-explanatory.

Note: Some Chilkat methods don't fire any ProgressInfo events.

### Scp.TaskCompleted (event)

`Chilkat 11.7.0 · delphidll · Scp · TaskCompleted · event`

```pascal
procedure MyTaskCompleted(task: HCkTask) cdecl;
```

Called from the background thread when an asynchronous task completes.

## Async variants

Each returns a `Task` instead of the result and takes the same arguments as the synchronous method; run the task, wait for `Finished`, then read the result from the task. No new Async methods are added from 11.7.0 on.

```pascal
function CkScp_DownloadBdAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    bd: HCkBinData): HCkTask; stdcall;
function CkScp_DownloadBinaryEncodedAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    encoding: PWideChar): HCkTask; stdcall;
function CkScp_DownloadFileAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    localPath: PWideChar): HCkTask; stdcall;
function CkScp_DownloadStringAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    charset: PWideChar): HCkTask; stdcall;
function CkScp_SyncTreeDownloadAsync(objHandle: HCkScp;
    remoteRoot: PWideChar;
    localRoot: PWideChar;
    mode: Integer;
    bRecurse: wordbool): HCkTask; stdcall;
function CkScp_SyncTreeUploadAsync(objHandle: HCkScp;
    localBaseDir: PWideChar;
    remoteBaseDir: PWideChar;
    mode: Integer;
    bRecurse: wordbool): HCkTask; stdcall;
function CkScp_UploadBdAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    bd: HCkBinData): HCkTask; stdcall;
function CkScp_UploadBinaryEncodedAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    encodedData: PWideChar;
    encoding: PWideChar): HCkTask; stdcall;
function CkScp_UploadFileAsync(objHandle: HCkScp;
    localPath: PWideChar;
    remotePath: PWideChar): HCkTask; stdcall;
function CkScp_UploadStringAsync(objHandle: HCkScp;
    remotePath: PWideChar;
    textData: PWideChar;
    charset: PWideChar): HCkTask; stdcall;
```

## Deprecated members — do not use in new code

| Member | Kind | Deprecated in | Use instead |
|---|---|---|---|
| `DownloadBinary` | method | before 11.6.1 | — |
| `UploadBinary` | method | before 11.6.1 | — |

## Related classes

[`BinData`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/BinData.md), [`Ssh`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Ssh.md), [`Task`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/delphidll/classes/Task.md)