DigitalOcean

A Webflow site handles design and content on Webflow hosting. Outside Webflow Cloud, that hosting layer won't run server-side code or query a database, while multi-gigabyte media files require external storage. Forms that must reach a CRM or data warehouse require an endpoint on the other end. DigitalOcean can host that backend layer.

DigitalOcean Functions process form submissions the moment a visitor hits submit, while Spaces serves video and large files through CDN URLs. You can paste those URLs into image and video fields. They also work as a background. App Platform hosts APIs your pages call with a few lines of JavaScript. Together, these services close the gap between the platforms. The site stays on Webflow hosting while compute and storage run on DigitalOcean. Database work runs there too.

This integration suits agency developers building custom backends for client sites. It also fits freelancers adding database-backed or server-processed features without managing servers and startup teams shipping a full-stack MVP. Content teams that sync catalogs or job listings into the CMS from external systems benefit too.

How to integrate DigitalOcean with Webflow

What is DigitalOcean? DigitalOcean is a cloud computing platform. Its products include virtual machines (Droplets) and managed databases. Spaces provides S3-compatible object storage. It also offers serverless Functions and App Platform, a managed app hosting service. It operates 20 data centers across 12 global regions. Its primary users include software developers and startups. It also serves small businesses.

Files too large for the Assets panel can live in Spaces, and DigitalOcean can process form data server-side. Teams can also sync records into the Webflow CMS from an external database. Every path below uses the public APIs or combines platform features with automation tools. The Webflow Marketplace does not include a DigitalOcean app.

The DigitalOcean-Webflow integration supports three approaches:

• Code Embed elements and custom form actions connect Spaces-hosted files and DigitalOcean endpoints to your site without a build pipeline.
• Make and Zapier move form submissions and site events between the platforms without custom webhook code.
• The Webflow and DigitalOcean APIs give you full control over webhooks, CMS sync, and backend automation, but require server-side development.

Most implementations combine two or more of these methods depending on the complexity of the setup.

Embed Spaces assets and DigitalOcean endpoints with Code Embed and form actions

Public Spaces files work in any image or video field. You can also point a form at a DigitalOcean endpoint or call a Function with client-side JavaScript. You need a paid Site plan (or a Core, Growth, Agency, or Freelancer Workspace plan) to add custom code. Each code section caps at 50,000 characters.

Host large files on DigitalOcean Spaces

Image uploads in the Assets panel cap at 4 MB, and documents and audio cap at 10 MB. Spaces stores far larger files and serves them through a built-in CDN. That works well for heavy assets, including video and downloads. Once a file is public, its URL works in any image, video, or background field. A Code Embed element accepts the same URL.

To host assets on Spaces:

1. In the DigitalOcean control panel, go to Spaces Object Storage > Buckets, open your bucket, and upload files under the Files tab. Control panel uploads cap at 2 GB per file and 100 files per batch.
2. Click … next to each file, select Manage Permissions, and set the file to Public.
3. Enable the CDN under Settings > CDN > Edit > Enable CDN > Save.
4. Copy the CDN URL, which follows the pattern https://{SPACES_BUCKET}.{SPACES_REGION}.cdn.digitaloceanspaces.com/{object_name}, and paste it into an asset field in Webflow.

Public Spaces URLs don't expire. Cold Storage buckets don't support the CDN, per the Spaces CDN documentation. Keep site assets in standard buckets.

Send form submissions to a DigitalOcean endpoint

A custom form action sends submissions straight to an external service and bypasses built-in form handling. Point it at a DigitalOcean Functions URL or an App Platform route to process leads server-side. No code goes on the page. The forms overview documents the setting.

To route a form to DigitalOcean:

1. Select the form and open its settings.
2. Click the add icon next to Send to and select Custom action.
3. Enter your DigitalOcean endpoint URL and choose POST or GET.

Custom actions can't combine with in-app submission storage or email notifications. Native reCAPTCHA doesn't work with them either. Handle spam filtering and validation on the DigitalOcean side.

Call DigitalOcean Functions from custom code

Client-side JavaScript can fetch data from a DigitalOcean Function and render it on the page. Web functions get permissive CORS headers by default (Access-Control-Allow-Origin: *). Browser calls from your published domain work without extra configuration, per the Functions CORS documentation. Add the script in a Code Embed element for a single page section. For site-wide use, add it through custom code in head and body tags.

To call a Function from a page:

1. In the DigitalOcean control panel, create a function under Functions > your namespace > Actions > Create Function.
2. Get its URL with doctl serverless functions get <function-name> --url.
3. Add a fetch call under Site settings > Custom code, in the head or footer section:

fetch('https://<your-function-url>')
  .then(response => response.json())
  .then(data => console.log(data));

Never put access keys or API tokens in embedded code, because anything in the page source is public. Route authenticated calls through a Function or App Platform service that holds the credentials server-side.

Connect with Make or Zapier

Make has a dedicated Webflow and DigitalOcean Spaces integration with 48 combined modules. Its modules cover DigitalOcean Spaces and exclude the rest of the DigitalOcean platform. Zapier lists both apps on a Webflow and DigitalOcean pairing page, but no pre-built Zap templates exist. You assemble multi-step Zaps yourself. Both options suit teams who want automation without deploying webhook handlers.

Useful trigger-to-action combinations include:

• A Webflow form trigger paired with the Spaces Upload a File module (Make), to archive submission exports in a bucket
• Spaces Watch Files feeding a Webflow CMS action (Make), so new bucket uploads become content
• Webflow New Form Submission → DigitalOcean Create Droplet or Create Domain (Zapier), for provisioning workflows kicked off by a site form
• DigitalOcean New Snapshot or New Backup → Webflow Create Live Item (Zapier), to log infrastructure events on a CMS-driven status page

Make's DigitalOcean support stops at Spaces. Automation involving Droplets, App Platform, or Functions still runs through the API path below.

Build with the Webflow and DigitalOcean APIs

Direct API integration gives you full control over both platforms and requires server-side development. The Webflow Data API v2 lives at https://api.webflow.com/v2 and authenticates with bearer tokens. The DigitalOcean API v2 lives at https://api.digitalocean.com/v2/ and accepts personal access tokens or OAuth tokens.

• The DigitalOcean API handles App Platform apps and deployments, plus domains. It also handles CDN endpoints
• Webflow's Data API handles CMS collections and form submissions
• Webflow webhooks trigger real-time events between systems

Data flows more easily out of Webflow than in from DigitalOcean. Webhooks cover 14 event types, including form_submission and collection_item_published, while DigitalOcean has no outbound webhooks to custom endpoints. Any DigitalOcean-to-Webflow sync therefore means polling the DigitalOcean API or triggering writes from your own application code.

Process form submissions with a Functions webhook handler

A serverless function is the lightest backend for form webhooks. You deploy the handler with the doctl CLI and register a webhook against your site. Every submission then POSTs to the function. Every delivery carries x-webflow-timestamp and x-webflow-signature headers for verification.

To build the handler:

1. Create a namespace: doctl serverless namespaces create --label "webflow-handler" --region "nyc1".
2. Initialize a project with doctl serverless init <project-name> and set web: true in project.yml.
3. Deploy with doctl serverless deploy <project-name>, then get the URL with doctl serverless functions get <function-name> --url.
4. Register the webhook with POST https://api.webflow.com/v2/sites/{site_id}/webhooks and include {"triggerType": "form_submission", "url": "<function_url>"} in the request body. This call needs a bearer token with the sites:write scope, per the webhook creation reference.
5. In the handler, compute a SHA-256 HMAC of timestamp + ":" + JSON.stringify(body), compare it to x-webflow-signature, and reject requests older than five minutes.

Return 200 OK right away; failed deliveries retry three times at 10-minute intervals, so keep handlers idempotent. The payload includes the form name, siteId, formId, the submitted data, and submittedAt.

Sync external data into the Webflow CMS

A sync worker running on a Droplet or an App Platform service can push records from a managed database into CMS collections. A scheduled Function can do the same. This fits catalogs, job listings, or any dataset that lives outside Webflow. The records still render on the site in a Collection List.

To run a sync:

1. Create staged items in bulk with POST /v2/collections/{collection_id}/items/bulk, which accepts up to 100 items per request and needs the cms:write scope.
2. Publish them with POST /v2/collections/{collection_id}/items/publish, or create and publish in one step with POST /v2/collections/{collection_id}/items/live.
3. Schedule the job with a Functions cron trigger via POST /v2/functions/namespaces/{namespace_id}/triggers.

The DigitalOcean Functions REST API currently only supports creating and managing namespaces. Function code deploys through doctl. To react to content edits instead of pushing on a schedule, register collection_item_created and collection_item_changed webhooks.

What can you build with the DigitalOcean Webflow integration?

Integrating DigitalOcean with Webflow lets you add server-side processing and databases to your site without moving off Webflow hosting. It also adds large-file storage.

• Video and large-media libraries: Store lesson videos or podcast audio in a Spaces bucket and embed the CDN URLs in CMS items. A course site can serve gigabytes of video that would never fit through the Assets panel.
• Lead capture with database storage: Route quote-request forms to a Functions handler that writes each submission to a managed PostgreSQL or MongoDB cluster and forwards qualified leads to a CRM.
• API proxies that protect credentials: Run an App Platform service that calls third-party APIs on behalf of your pages, so keys never appear in browser code. A pricing calculator on a marketing site can fetch live rates through the proxy with one fetch() call.
• Automated content pipelines: Push records from an external database into CMS collections on a nightly Function trigger. A job board can pull open roles from an applicant tracking system and publish them without manual entry.

If you need more control over webhook verification, publishing timing, or credential handling, the API integration path covers those cases with full flexibility.