Schedule a deployment at a specific time

[lil5]

This would be an option in the "Deployments" or "Scheduled Tasks" tab.

The form would contain when you would like to redeploy, and if it is a recurring or one time task.

Scenario:

I'd like to redeploy at 04:00 local time, to have the downtime only occur during low network activity

[marwie]

I'd love to see this too! I want to push to my production branch and re-deploy at a specific time during the day instead of immediately to not negatively impact periods with lots of user activity or interrupt other running jobs

[Julhol-droid]

Yes that would be a great feature

[shageman]

In the meantime you can make another project to do this for you. Pick a dockerfile deployment and adapt this to your use-case:

services:
  cronjob:
    image: alpine
    container_name: coolify-inline-cron
    command: |
      sh -c 'apk add --no-cache curl && echo "*/FREQUENCY * * * * echo \"[CRON] Running curl at \$(date)\" && curl -i -X POST -H \"Authorization: Bearer TOKEN\" https://SERVER/api/v1/deploy?uuid=UUID&force=false&force=true" > /etc/crontabs/root && crond -f -l 2'
    restart: unless-stopped

Adapt the cron config as needed. TOKEN is a Coolify API Token with deploy permission. You can find the UUID on the web hooks page of the service to be scheduled for deploy.

If you use API access allow listing, then be sure to add your deployment server(s) that list.

[marwie]

Thanks for sharing! This would deploy every day even if nothing had changed, right?

[shageman]

Yes. In fact, given the cron config I shared it would deploy every FREQUENCY minutes.

[oliverfrost1]

Thanks for sharing this workaround, it pointed me in the right direction.

I ended up doing a slightly different version because I did not want the cron job to call /deploy every time if nothing had changed. In my setup, even when Coolify skips the build because the Git commit SHA is unchanged, it can still restart the container, which was exactly what I wanted to avoid.

So instead, I created a separate small Coolify app running Alpine + cron. Every minute it:

1. Gets the latest commit SHA for my production branch through Coolify’s GitHub App API.
2. Gets the latest deployed commit SHA for each Coolify application through the deployment history API.
3. Compares the two SHAs.
4. Only calls /deploy?uuid=...&force=false if the remote branch SHA is different from the latest deployed SHA.

This means I can push to main, but Coolify will only redeploy when the cron job detects a new commit. If there are no changes, it does nothing.

Example docker-compose.yml:

services:
  coolify-change-deployer:
    image: alpine:3.20
    container_name: coolify-change-deployer
    restart: unless-stopped

    environment:
      COOLIFY_API: "https://YOUR-COOLIFY-DOMAIN/api/v1"
      COOLIFY_TOKEN: "${COOLIFY_TOKEN}"

      GITHUB_APP_ID: "1"
      GIT_REPO_OWNER: "your-github-user-or-org"
      GIT_REPO_NAME: "your-repo"
      GIT_BRANCH: "main"

      APP_UUIDS: "your-first-app-uuid your-second-app-uuid"

    command:
      - sh
      - -c
      - |
        set -eu

        apk add --no-cache curl jq ca-certificates

        cat > /usr/local/bin/check-and-deploy <<'EOF'
        #!/bin/sh
        set -u

        COOLIFY_API="$${COOLIFY_API}"
        APP_UUIDS="$${APP_UUIDS}"
        GITHUB_APP_ID="$${GITHUB_APP_ID}"
        GIT_REPO_OWNER="$${GIT_REPO_OWNER}"
        GIT_REPO_NAME="$${GIT_REPO_NAME}"
        GIT_BRANCH="$${GIT_BRANCH}"

        log() {
          echo "[$$(date)] $$*"
        }

        if [ -z "$${COOLIFY_TOKEN:-}" ]; then
          log "ERROR: COOLIFY_TOKEN is empty."
          exit 1
        fi

        api_get() {
          curl -fsS \
            -H "Authorization: Bearer $${COOLIFY_TOKEN}" \
            "$${COOLIFY_API}$$1"
        }

        get_remote_branch_commit() {
          api_get "/github-apps/$${GITHUB_APP_ID}/repositories/$${GIT_REPO_OWNER}/$${GIT_REPO_NAME}/branches" \
            | jq -r --arg branch "$${GIT_BRANCH}" '
                .branches[]
                | select(.name == $$branch)
                | .commit.sha
              ' \
            | head -n 1
        }

        get_latest_deployed_commit() {
          APP_UUID="$$1"

          api_get "/deployments/applications/$${APP_UUID}?skip=0&take=1" \
            | jq -r ".deployments[0].commit // empty"
        }

        deploy_app() {
          APP_UUID="$$1"

          api_get "/deploy?uuid=$${APP_UUID}&force=false"
        }

        log "Checking repo $${GIT_REPO_OWNER}/$${GIT_REPO_NAME}:$${GIT_BRANCH} through Coolify GitHub App $${GITHUB_APP_ID}"

        REMOTE_SHA="$$(get_remote_branch_commit || true)"

        if [ -z "$${REMOTE_SHA}" ]; then
          log "ERROR: Could not read remote SHA from Coolify GitHub App endpoint."
          exit 1
        fi

        log "Remote SHA for $${GIT_BRANCH}: $${REMOTE_SHA}"

        for APP_UUID in $${APP_UUIDS}; do
          log "Checking app $${APP_UUID}"

          DEPLOYED_SHA="$$(get_latest_deployed_commit "$${APP_UUID}" || true)"

          if [ -z "$${DEPLOYED_SHA}" ]; then
            log "ERROR: Could not read latest deployed commit for $${APP_UUID}."
            continue
          fi

          log "App $${APP_UUID}: deployed=$${DEPLOYED_SHA}, remote=$${REMOTE_SHA}"

          if [ "$${REMOTE_SHA}" = "$${DEPLOYED_SHA}" ]; then
            log "No changes for $${APP_UUID}. Not deploying."
          else
            log "Changes found for $${APP_UUID}. Triggering Coolify deploy."
            deploy_app "$${APP_UUID}"
          fi
        done
        EOF

        chmod +x /usr/local/bin/check-and-deploy

        echo "* * * * * /usr/local/bin/check-and-deploy >> /proc/1/fd/1 2>> /proc/1/fd/2" > /etc/crontabs/root

        echo "[STARTUP] Running first check now..."
        /usr/local/bin/check-and-deploy || true

        echo "[STARTUP] Starting cron..."
        exec crond -f -l 2

And then add this as an environment variable in Coolify:

COOLIFY_TOKEN=your-coolify-api-token

A few notes:

• GITHUB_APP_ID is the numeric Coolify GitHub App ID from /api/v1/github-apps, not the UUID.
• APP_UUIDS is a space-separated list of Coolify application UUIDs.
• The double dollar signs, like $${APP_UUID}, are intentional. They prevent Docker Compose/Coolify from interpolating the variables before the script runs inside the container.
• This uses Coolify’s own GitHub App integration, so I did not need to add a separate GitHub PAT.
• You can change the cron expression from * * * * * to something like 0 4 * * * if you only want deployments to happen at 04:00.

With 0 4 * * *, the cron job will check once per day at 04:00 and only deploy if the production branch has a newer commit than the latest deployed commit.

[pygillier]

It would also be useful when using static generators like Nikola where you can set articles in the future and have them published "automagically".