Managing Backups

WP Engine automatically backs up each environment daily. Users can also choose to take additional backups on an ad-hoc basis.

To retrieve a backup, you must first generate a zip archive which is then available for download.

Backups vs. Archives

Backups - refers to full or partial backups made either automatically or on demand. These are also referred to as checkpoints.
Archives - refers to backups which have been converted into downloadable zip files.

Backups

Backups are automatically created daily for every environment.

Create backup

Use the Create backup endpoint to create an ad-hoc backup.

# Replace 12345 with your install ID
curl -X POST "https://api.wpengineapi.com/v1/installs/12345/backups" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "description": "Manual backup before deployment",
    "notification_emails": ["admin@example.com"]
  }'

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID

  payload := map[string]interface{}{
    "description":         "Manual backup before deployment",
    "notification_emails": []string{"admin@example.com"},
  }
  body, _ := json.Marshal(payload)

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/backups", installID)
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
  req.SetBasicAuth(user, pass)
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  respBody, _ := io.ReadAll(resp.Body)
  fmt.Println(string(respBody))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID

try {
  const res = await fetch(`https://api.wpengineapi.com/v1/installs/${installId}/backups`, {
    method: "POST",
    headers: {
      Authorization: auth,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      description: "Manual backup before deployment",
      notification_emails: ["admin@example.com"]
    })
  });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/backups"
resp = requests.post(
  url,
  auth=(user, password),
  json={
    "description": "Manual backup before deployment",
    "notification_emails": ["admin@example.com"]
  },
  timeout=10
)
print(resp.json())

The length of time needed to take a backup varies by the size of the environment. Extremely large sites can take several minutes while small sites are generally backed up in a couple of minutes.

List backups

Use the List backups endpoint to get a list of available backups for a given environment.

# Replace 12345 with your install ID
curl -X GET "https://api.wpengineapi.com/v1/installs/12345/backups" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD"

package main

import (
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/backups", installID)
  req, _ := http.NewRequest("GET", url, nil)
  req.SetBasicAuth(user, pass)

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID

try {
  const res = await fetch(`https://api.wpengineapi.com/v1/installs/${installId}/backups`, {
    headers: { Authorization: auth }
  });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/backups"
resp = requests.get(url, auth=(user, password), timeout=10)
print(resp.json())

Get backup

Use the Get backup endpoint to check the status of an ad-hoc backup.

# Replace 12345 with your install ID and the UUID with your backup ID
curl -X GET "https://api.wpengineapi.com/v1/installs/12345/backups/11a77ee6-e069-4d7a-a6a0-a87e990ed07d" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD"

package main

import (
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID
  backupID := "11a77ee6-e069-4d7a-a6a0-a87e990ed07d"  // replace with your backup ID

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/backups/%s", installID, backupID)
  req, _ := http.NewRequest("GET", url, nil)
  req.SetBasicAuth(user, pass)

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID
const backupId = "11a77ee6-e069-4d7a-a6a0-a87e990ed07d";  // replace with your backup ID

try {
  const res = await fetch(
    `https://api.wpengineapi.com/v1/installs/${installId}/backups/${backupId}`,
    { headers: { Authorization: auth } }
  );
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID
backup_id = "11a77ee6-e069-4d7a-a6a0-a87e990ed07d"   # replace with your backup ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/backups/{backup_id}"
resp = requests.get(url, auth=(user, password), timeout=10)
print(resp.json())

Restore backup

Use the Restore backup endpoint to restore an environment from a backup.

# Replace 12345 with your install ID and the UUID with your backup ID
curl -X POST "https://api.wpengineapi.com/v1/installs/12345/backups/11a77ee6-e069-4d7a-a6a0-a87e990ed07d/restore" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "notification_emails": ["admin@example.com"]
  }'

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID
  backupID := "11a77ee6-e069-4d7a-a6a0-a87e990ed07d"  // replace with your backup ID

  payload := map[string]interface{}{
    "notification_emails": []string{"admin@example.com"},
  }
  body, _ := json.Marshal(payload)

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/backups/%s/restore", installID, backupID)
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
  req.SetBasicAuth(user, pass)
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  respBody, _ := io.ReadAll(resp.Body)
  fmt.Println(string(respBody))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID
const backupId = "11a77ee6-e069-4d7a-a6a0-a87e990ed07d";  // replace with your backup ID

try {
  const res = await fetch(
    `https://api.wpengineapi.com/v1/installs/${installId}/backups/${backupId}/restore`,
    {
      method: "POST",
      headers: {
        Authorization: auth,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        notification_emails: ["admin@example.com"]
      })
    }
  );
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID
backup_id = "11a77ee6-e069-4d7a-a6a0-a87e990ed07d"   # replace with your backup ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/backups/{backup_id}/restore"
resp = requests.post(
  url,
  auth=(user, password),
  json={"notification_emails": ["admin@example.com"]},
  timeout=10
)
print(resp.json())

Archives

Once a backup has completed, it can then be converted into an archive for download as a zip file.

Create archive

Use the Create archive endpoint to create an archive.

# Replace 12345 with your install ID and the UUID with your backup ID
curl -X POST "https://api.wpengineapi.com/v1/installs/12345/archives" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD" \
  -H "Content-Type: application/json" \
  -d '{
    "backup_id": "11a77ee6-e069-4d7a-a6a0-a87e990ed07d",
    "notification_emails": ["admin@example.com"]
  }'

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID

  payload := map[string]interface{}{
    "backup_id":           "11a77ee6-e069-4d7a-a6a0-a87e990ed07d",
    "notification_emails": []string{"admin@example.com"},
  }
  body, _ := json.Marshal(payload)

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/archives", installID)
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
  req.SetBasicAuth(user, pass)
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  respBody, _ := io.ReadAll(resp.Body)
  fmt.Println(string(respBody))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID

try {
  const res = await fetch(`https://api.wpengineapi.com/v1/installs/${installId}/archives`, {
    method: "POST",
    headers: {
      Authorization: auth,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      backup_id: "11a77ee6-e069-4d7a-a6a0-a87e990ed07d",
      notification_emails: ["admin@example.com"]
    })
  });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/archives"
resp = requests.post(
  url,
  auth=(user, password),
  json={
    "backup_id": "11a77ee6-e069-4d7a-a6a0-a87e990ed07d",
    "notification_emails": ["admin@example.com"]
  },
  timeout=10
)
print(resp.json())

List archives

Use the List archives endpoint to fetch a list of available archives and their urls for download.

# Replace 12345 with your install ID
curl -X GET "https://api.wpengineapi.com/v1/installs/12345/archives" \
  -u "$WPE_API_USER_ID:$WPE_API_PASSWORD"

package main

import (
  "fmt"
  "io"
  "net/http"
  "os"
)

func main() {
  user := os.Getenv("WPE_API_USER_ID")
  pass := os.Getenv("WPE_API_PASSWORD")
  installID := "12345" // replace with your install ID

  url := fmt.Sprintf("https://api.wpengineapi.com/v1/installs/%s/archives", installID)
  req, _ := http.NewRequest("GET", url, nil)
  req.SetBasicAuth(user, pass)

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer resp.Body.Close()

  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

const user = process.env.WPE_API_USER_ID;
const pass = process.env.WPE_API_PASSWORD;
const auth = "Basic " + Buffer.from(`${user}:${pass}`).toString("base64");
const installId = 12345; // replace with your install ID

try {
  const res = await fetch(`https://api.wpengineapi.com/v1/installs/${installId}/archives`, {
    headers: { Authorization: auth }
  });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  console.log(await res.json());
} catch (e) { console.error(e); }

import os, requests

user = os.getenv("WPE_API_USER_ID")
password = os.getenv("WPE_API_PASSWORD")
install_id = 12345  # replace with your install ID

url = f"https://api.wpengineapi.com/v1/installs/{install_id}/archives"
resp = requests.get(url, auth=(user, password), timeout=10)
print(resp.json())

The response from the List archives endpoint includes the uri for a signed url of the archive which can be downloaded.

Example response:

{
  "previous": null,
  "next": null,
  "count": 1,
  "results": [
    {
      "id": "9f3610d6-9133-471e-bcc9-b255c8dbdcc9",
      "backup": {
        "id": "11a77ee6-e069-4d7a-a6a0-a87e990ed07d"
      },
      "notification_emails": ["rick.love@wpengine.com"],
      "state": "completed",
      "create_time": "2026-06-22T08:55:14.347Z",
      "start_time": "2026-06-22T08:55:14.909Z",
      "complete_time": "2026-06-22T08:55:45.001Z",
      "abort_time": "0001-01-01T00:00:00.000Z",
      "download_uri": "https://snappyshot-wpengine-download.s3.amazonaws.com/zip-archives/site-archive-rickloveeu2prd-live-1782102047-Uv3x1jfiEf5Wgkdyy4e32gYfeRwmXox5H446.zip"
    }
  ]
}

Platforms

Product Extensions

Plugins

Tools