How to Deploy Your Static Astro Website to Bunny.net

You built an Astro site. It’s fast, it’s static, and now you need somewhere to host it that won’t cost a fortune or require you to maintain a server.

I run my own Astro site on Bunny.net, and after months of using it in production I can say the setup is straightforward once you know the steps. Bunny gives you edge storage with global replication and a CDN with 119+ points of presence. You upload your built files, Bunny serves them from the nearest edge location to every visitor. No VPS to patch, no Nginx config to debug, no Docker container to babysit.

I wrote a full Bunny.net review covering pricing and features in detail. This guide does one thing: walk you through getting your Astro static site deployed and live on Bunny.net.

If you don’t have an Astro site yet, I covered how to build a free blog with Astro using the Bitdoze Astro Theme. The same setup applies here, just swap Cloudflare Pages for Bunny.net hosting.

What you need before starting

• An Astro site configured for static output (or fork the Bitdoze Astro Theme to follow along)
• A Bunny.net account (free 14-day trial, no credit card)
• Node.js installed on your machine
• A domain name (optional, but recommended for production)

Why Bunny.net for static sites

A quick aside on why this is worth doing before we get into the setup.

Here’s how Bunny.net stacks up against other popular static hosting options:

Cloudflare Pages has the better free tier if cost is your only concern. But if you want edge storage replication, predictable pricing at scale, or you already use Bunny for CDN or video, hosting your Astro site there keeps everything in one dashboard. I switched from Cloudflare Pages to Bunny for exactly that reason.

Step 1: Build your Astro site

Make sure your Astro project is configured for static output. Open astro.config.mjs and confirm it looks something like this:

import { defineConfig } from 'astro/config';

export default defineConfig({
  site: 'https://yourdomain.com',
  // output: 'static' is the default, so you may not see this line at all
});

Astro uses static output by default, so unless you explicitly changed it to server or hybrid, you’re already set.

Build the site:

npm run build

This generates a dist/ folder containing your complete static site — HTML files, CSS, JavaScript, images, everything. You can preview it locally to verify everything looks right:

npm run preview

The dist/ folder is what we’ll deploy to Bunny.net.

Step 2: Set up Bunny.net infrastructure

You need two things on the Bunny.net side: a storage zone (where your files live) and a pull zone (the CDN layer that serves them to visitors). Neither takes more than a couple of minutes.

Create a storage zone

1. Log into your Bunny.net dashboard
2. Go to Storage in the left sidebar
3. Click Add Storage Zone
4. Fill in the details:
   • Name: Something like my-astro-site (this becomes part of the storage URL)
   • Main Region: Pick the region closest to your primary audience (e.g., DE for Europe, NY for US East)
   • Replication Regions: Add regions where you want copies of your files (e.g., add NY and SYD if you have visitors in the US and Australia)
   • Tier: Edge tier (SSD storage) is worth the tiny price difference for better performance

Create a pull zone

The pull zone is the CDN configuration that sits in front of your storage zone and serves files to visitors.

1. In your newly created storage zone, go to Connected Pull Zones
2. Click Connect Pull Zone
3. Configure it:
   • Name: Something like my-astro-site (this becomes my-astro-site.b-cdn.net)
   • Zones: Select the geographic zones you want to serve traffic from (EU, NA, Asia, etc.)

That’s the basic infrastructure. Your pull zone hostname (my-astro-site.b-cdn.net) is already live and will serve whatever is in your storage zone. Right now that’s nothing, so let’s fix that.

Step 3: Deploy your site

The deployment uploads files from your dist/ folder to Bunny Storage via the Bunny API, then purges the CDN cache. You can do this from your local machine or automate it with GitHub Actions.

Get your credentials

You need four values from the Bunny dashboard:

1. Storage Zone Name: The name you chose when creating the storage zone (e.g., my-astro-site)
2. Storage Password: Go to Storage → your storage zone → FTP & API Access → copy the Password
3. Pull Zone ID: Go to Pull Zones → your pull zone → check the URL, it contains the pull zone ID (or find it in the pull zone settings)
4. Account API Key: Go to Account Settings → copy the API Key

# .env
BUNNY_STORAGE_ZONE=your-storage-zone-name
BUNNY_STORAGE_PASSWORD=your-storage-zone-password
BUNNY_PULL_ZONE_ID=your-pull-zone-id
BUNNY_API_KEY=your-account-api-key

#!/bin/bash
set -euo pipefail

# Load environment variables from .env
if [ ! -f .env ]; then
  echo "Error: .env file not found. Copy .env.example to .env and fill in your credentials."
  exit 1
fi

set -a
source .env
set +a

# Validate required variables
for var in BUNNY_STORAGE_ZONE BUNNY_STORAGE_PASSWORD BUNNY_PULL_ZONE_ID BUNNY_API_KEY; do
  if [ -z "${!var:-}" ]; then
    echo "Error: $var is not set in .env"
    exit 1
  fi
done

DIST_DIR="dist"

# Build the site
echo "Building Astro site..."
npm run build

# Collect file list into a temp file to avoid pipe subshell issues
FILE_LIST=$(mktemp)
trap 'rm -f "$FILE_LIST"' EXIT
find "$DIST_DIR" -type f > "$FILE_LIST"

total=$(wc -l < "$FILE_LIST")
echo "Uploading $total files to Bunny Storage..."

failed=0
count=0
while IFS= read -r file; do
  count=$((count + 1))
  remote_path="${file#$DIST_DIR/}"
  encoded_path=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$remote_path'))")
  printf "  [%d/%d] Uploading: %s" "$count" "$total" "$remote_path"

  http_code=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
    "https://storage.bunnycdn.com/$BUNNY_STORAGE_ZONE/$encoded_path" \
    -H "AccessKey: $BUNNY_STORAGE_PASSWORD" \
    --data-binary "@$file" || true)

  if [ "$http_code" -eq 201 ] || [ "$http_code" -eq 200 ]; then
    echo " -> OK"
  else
    echo " -> FAILED (HTTP $http_code)"
    failed=$((failed + 1))
  fi
done < "$FILE_LIST"

echo "Upload complete: $((count - failed))/$count succeeded."

if [ "$failed" -gt 0 ]; then
  echo "Warning: $failed file(s) failed to upload."
fi

# Purge CDN cache
echo "Purging CDN cache for pull zone $BUNNY_PULL_ZONE_ID..."
http_code=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
  "https://api.bunny.net/pullzone/$BUNNY_PULL_ZONE_ID/purgeCache" \
  -H "AccessKey: $BUNNY_API_KEY" || true)
if [ "$http_code" -eq 200 ] || [ "$http_code" -eq 204 ]; then
  echo "Cache purged successfully."
else
  echo "Warning: cache purge returned HTTP $http_code"
fi

echo "Deployment complete!"

chmod +x deploy.sh
./deploy.sh

name: Deploy to Bunny.net

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: lts

      - name: Install dependencies
        run: npm ci

      - name: Build site
        run: npm run build

      - name: Upload to Bunny Storage
        env:
          BUNNY_STORAGE_ZONE: ${{ secrets.BUNNY_STORAGE_ZONE }}
          BUNNY_STORAGE_PASSWORD: ${{ secrets.BUNNY_STORAGE_PASSWORD }}
        run: |
          DIST_DIR="dist"
          total=$(find "$DIST_DIR" -type f | wc -l)
          echo "Uploading $total files to Bunny Storage..."
          count=0
          failed=0
          while IFS= read -r file; do
            count=$((count + 1))
            remote_path="${file#$DIST_DIR/}"
            encoded_path=$(python3 -c "import urllib.parse; print(urllib.parse.quote('$remote_path'))")
            printf "  [%d/%d] Uploading: %s\n" "$count" "$total" "$remote_path"
            http_code=$(curl -s -o /dev/null -w "%{http_code}" -X PUT \
              "https://storage.bunnycdn.com/$BUNNY_STORAGE_ZONE/$encoded_path" \
              -H "AccessKey: $BUNNY_STORAGE_PASSWORD" \
              --data-binary "@$file" || true)
            if [ "$http_code" -ne 201 ] && [ "$http_code" -ne 200 ]; then
              echo "  -> FAILED (HTTP $http_code)"
              failed=$((failed + 1))
            fi
          done < <(find "$DIST_DIR" -type f)
          echo "Upload complete: $((count - failed))/$count succeeded."
          if [ "$failed" -gt 0 ]; then
            echo "Error: $failed file(s) failed to upload."
            exit 1
          fi

      - name: Purge CDN cache
        env:
          BUNNY_PULL_ZONE_ID: ${{ secrets.BUNNY_PULL_ZONE_ID }}
          BUNNY_API_KEY: ${{ secrets.BUNNY_API_KEY }}
        run: |
          http_code=$(curl -s -o /dev/null -w "%{http_code}" -X POST \
            "https://api.bunny.net/pullzone/$BUNNY_PULL_ZONE_ID/purgeCache" \
            -H "AccessKey: $BUNNY_API_KEY")
          if [ "$http_code" -eq 200 ] || [ "$http_code" -eq 204 ]; then
            echo "Cache purged successfully."
          else
            echo "Warning: cache purge returned HTTP $http_code"
          fi

Step 4: Configure your custom domain

Your site is already accessible at your-pull-zone.b-cdn.net, but you probably want your own domain. Here’s how.

Add the hostname in Bunny

1. Go to Pull Zones → your pull zone → General
2. Scroll to Hostnames
3. Click Add Custom Hostname
4. Enter your domain (e.g., www.yourdomain.com or yourdomain.com)
5. Click Add

Bunny generates an SSL certificate automatically (usually within a few minutes).

Configure DNS at your registrar

How you configure DNS depends on whether you’re using a subdomain or the root domain.

For a subdomain (e.g., www.yourdomain.com):

Add a CNAME record:

CNAME records are the standard approach. They route traffic through Bunny’s Anycast network efficiently.

For a root domain (e.g., yourdomain.com):

Add an ANAME (also called ALIAS) record:

Not all DNS providers support ANAME records. Cloudflare, DNSMadeEasy, and Bunny’s own DNS do. If yours doesn’t, use a subdomain like www with a CNAME instead, then set up a redirect from the root domain to www.

Verify and enforce SSL

1. Wait for the SSL certificate status to change to Active (check the Hostnames section in your pull zone)
2. Toggle Force SSL to redirect all HTTP traffic to HTTPS
3. Verify by visiting https://yourdomain.com in a browser

DNS propagation

DNS changes can take anywhere from a few minutes to 48 hours to propagate globally, though most updates show up within 15-30 minutes. You can check propagation status with tools like dig or online DNS checkers.

Step 5: Configure caching

Bunny has three caching features worth understanding for a static Astro site. They work together in layers.

Smart Cache

Smart Cache is enabled by default on pull zones accelerated by Bunny DNS. It decides what gets cached and what passes through to the origin on every request.

For static sites, Smart Cache caches everything with a recognized static file extension (images, fonts, CSS, JS, PDFs, etc.) and never caches text/html, application/json, or application/xml MIME types. This is the right behavior for most Astro sites since your HTML pages will be fetched fresh while assets get cached.

If you need to cache HTML pages (Bunny excludes them by default), create an Edge Rule with the Override Cache Time action targeting your HTML files.

Vary Cache

Vary Cache lets Bunny store different versions of the same URL based on factors like browser capabilities, device type, or location. The relevant options for a static Astro site:

Perma-Cache

Perma-Cache is a secondary permanent cache layer between the CDN and your origin. When a cache miss occurs on the CDN edge, Bunny checks Perma-Cache storage first before hitting your origin. Files that get fetched from the origin are stored permanently in Perma-Cache in the background.

This is different from regular CDN caching, which expires based on time or available space. Perma-Cache files stick around indefinitely.

To enable Perma-Cache:

1. Create a separate storage zone (different from the one holding your site files)
2. Go to Pull Zones → your pull zone → Caching → Perma-Cache
3. Select the storage zone from the dropdown
4. Save configuration

Step 6: Add security with Bunny Shield

Bunny Shield is Bunny’s WAF (Web Application Firewall) and DDoS protection service. It sits in front of your pull zone and filters malicious traffic before it reaches your site. There’s a free tier that covers the basics.

What the free tier gives you

The free Shield tier includes 71 built-in WAF rules and DDoS protection. It blocks common attacks automatically:

• SQL injection attempts in query parameters and forms
• Cross-site scripting (XSS) payloads
• Remote file inclusion (RFI) attacks
• Other OWASP Top 10 threats

For a static Astro site, Shield is mostly defense against DDoS and bot traffic since there’s no server-side code to exploit. But it still reduces noise in your logs and can block scrapers or abuse patterns.

Enable Shield

1. Go to Shield in the Bunny dashboard
2. Create a new Shield Zone
3. Connect it to your pull zone
4. The free tier activates automatically

Optional: rate limiting and custom WAF rules

The paid tiers ($9.50/month for Advanced, $99/month for Business) add:

• Custom WAF rules (10 on Advanced, 25 on Business)
• Advanced bot detection
• Rate limiting per IP or path

For a static blog, the free tier is usually enough. Rate limiting becomes relevant if you notice specific IPs hammering your site or if you want to block traffic from certain countries.

Set up Edge Rules for security headers

Edge Rules let you add custom headers to responses. Adding security headers is a quick win regardless of whether you use Shield:

1. Go to Pull Zones → your pull zone → Edge Rules
2. Create rules to add headers:

Cost breakdown

What does this actually cost? Here’s a realistic scenario for a typical Astro blog:

Under $4/year for a blog with moderate traffic, including DDoS protection and WAF. Even at 100 GB of monthly bandwidth you’re looking at roughly $1/month.

Bunny has a $1 monthly minimum, so very low-traffic sites still pay $1. But that $1 covers up to 100 GB of EU/NA bandwidth, which is more than most blogs use in a month.

Troubleshooting

Frequently asked questions

Wrapping up

Your Astro site is now running on Bunny.net’s global CDN with edge storage, caching, and DDoS protection via Shield. Storage, CDN, SSL, WAF, and global delivery for under $1/month for most blogs.

If you run into issues, the troubleshooting section above covers the common ones. The GitHub Actions workflow from Step 3 is the logical next step if you want automatic deploys on every push to main.