How to Build an AI Image Upscaler Pipeline in Clay Workflows

Images account for the largest payload block on mobile pages, representing roughly 900 kilobytes of the median mobile web page's total weight of 2,360 kilobytes [HTTP Archive 2025 Web Almanac]. While visual files are essential for converting web visitors, growth operations teams often struggle to serve high-definition campaign assets without introducing page bloat. Marketing campaigns require high-resolution logos, product mockups, and client screenshots to look professional on modern screens. However, low-resolution source images are frequently pixelated, especially when pulled from web scraping databases or third-party lead sources.

Traditional manual workflows rely on drag-and-drop web interfaces to enhance single files. A marketer must upload a file, wait for processing, download the output, and manually attach it to an email sequence or a CRM record. When processing creative collateral for hundreds of prospective companies, this manual approach creates a severe operational bottleneck.

To solve this, operations teams often try to save assets in temporary local directories or shared cloud storage folders on Google Drive, Dropbox, OneDrive, or Box. These standard repositories lack version control, structured metadata views, and webhook integration, making them poor choices for dynamic automated pipelines. They also lack native Model Context Protocol tools for AI agent access, meaning engineering teams must write custom API wrappers for every file interaction. An automated image upscaler pipeline resolves these bottlenecks by combining spreadsheet-integrated tables with external AI model endpoints and persistent, shared workspaces.

Traditional cloud storage drives operate on a sync-first model that attempts to replicate local file states. When several automated agents or human designers edit files concurrently, sync conflicts occur, resulting in duplicate files and broken URL paths. Standard cloud providers do not index file contents for semantic search by default. If an outbound sales representative needs a specific customer logo or screenshot, they must search by exact filename, wasting valuable hours. Object storage platforms like Amazon S3 solve the scale issue but lack a friendly user interface for non-technical reviewers, making it difficult for designers to audit upscaled graphics before campaigns launch. A dedicated image upscaler pipeline requires a storage layer that combines database structure, version control, and API access.

An AI image upscaler pipeline enhances low-resolution source images using generative neural networks to reconstruct details and produce high-definition campaign assets [Upscale.media 2026 Product Documentation]. Within Clay GTM workflows, this pipeline treats image processing as a structured data transaction. Rather than isolating image enhancement to creative departments, the pipeline executes automatically whenever new company records are enriched.

Go-to-market teams frequently use Clay to build prospective client profiles. During this enrichment phase, AI web research agents, such as Claygent, browse company websites to find logos, product screenshots, or team photos. Because these assets are optimized for web rendering, they are often low-resolution WebP or compressed JPEG files. Exporting these graphics directly into outbound email builders or high-impact sales decks leads to blurry presentation cards and pixelated attachments.

An automated Clay upscaling workflow addresses this by routing the scraped URLs directly to an external upscaling API. This integration provides several operational benefits:

• Eliminates manual drag-and-drop processing for creative teams.
• Ensures all campaign assets maintain a high resolution for high-density mobile screens.
• Standardizes batch file naming conventions using table row parameters.
• Hosts final outputs on durable URLs that resolve instantly in downstream tools.

By managing the upscaling process programmatically, sales operations desks can prepare personalized creative packages in batch, ensuring that outreach campaigns look polished and professional.

An automated pipeline also allows growth teams to run quality checks at scale. For example, if a scraper returns a low-resolution profile photo, the upscaler can apply specific face-enhancement models (such as GFPGAN or CodeFormer) to reconstruct facial details. Instead of relying on manual touch-ups in Photoshop, neural network upscaling handles the reconstruction in seconds. This programmatic approach ensures that outbound campaigns are supported by high-quality assets that build trust with prospects. The integration bridges the gap between GTM research databases and creative asset delivery, transforming raw URLs into high-impact marketing collateral.

Clay University outlines HTTP request columns to interact with AI model endpoints and retrieve enhanced image URL outputs [Clay University Course Directory]. While Clay does not have a native upscaling block, its HTTP Request enrichment column allows you to query any external REST API.

To configure this pipeline, add a new enrichment column to your Clay table and select the HTTP Request option. Configure the column with the following request parameters:

Method: POST

Endpoint: https://api.replicate.com/v1/predictions

Headers: Authorization: Bearer [Your Replicate API Token] Content-Type: application/json

JSON Request Body:

{
  "version": "f121d6403862b407a1290e377d02c9d326a9d5613e0076b5c5b21e10ef61ec77",
  "input": {
    "image": "{{row.source_image_url}}",
    "scale": 4,
    "face_enhance": false
  }
}

Because image upscaling is computationally heavy, AI upscaling APIs resolve pixelation in under 3 seconds per asset but operate asynchronously [Upscale.media 2026 Product Documentation]. When you send the POST request, Replicate returns a payload containing a prediction ID and a status of starting or processing. Polling this endpoint directly inside Clay's table columns is inefficient and consumes unnecessary enrichment credits.

To build a reliable batch workflow, route the request through a serverless middleware function. This function handles the asynchronous polling, downloads the output binary, writes the file to persistent storage, and returns a clean URL to Clay.

// Middleware to manage asynchronous upscaling and storage
import axios from 'axios';

export async function handleUpscaling(req, res) {
  const { sourceImageUrl, targetPath, orgId, workspaceId } = req.body;
  
  try {
    // 1. Trigger Replicate prediction
    const startResponse = await axios.post(
      'https://api.replicate.com/v1/predictions',
      {
        version: 'f121d6403862b407a1290e377d02c9d326a9d5613e0076b5c5b21e10ef61ec77',
        input: {
          image: sourceImageUrl,
          scale: 4,
          face_enhance: true
        }
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.REPLICATE_API_TOKEN}`,
          'Content-Type': 'application/json'
        }
      }
    );
    
    const predictionId = startResponse.data.id;
    let status = startResponse.data.status;
    let upscaledUrl = null;
    
    // 2. Poll for completion
    while (status === 'starting' || status === 'processing') {
      await new Promise(resolve => setTimeout(resolve, 500));
      const pollResponse = await axios.get(
        `https://api.replicate.com/v1/predictions/${predictionId}`,
        {
          headers: { Authorization: `Bearer ${process.env.REPLICATE_API_TOKEN}` }
        }
      );
      status = pollResponse.data.status;
      if (status === 'succeeded') {
        upscaledUrl = pollResponse.data.output;
        break;
      }
      if (status === 'failed') {
        throw new Error('AI model upscaling failed');
      }
    }
    
    // 3. Download the upscaled binary image
    const imageResponse = await axios.get(upscaledUrl, { responseType: 'arraybuffer' });
    
    // 4. Upload binary to Fastio shared workspace
    const fastioMcp = 'https://mcp.fast.io/mcp/key'; const fastioAuth = { Authorization: 'Bearer ' + process.env.FASTIO_API_KEY };
    const uploadResult = await axios.post('https://mcp.fast.io/mcp/key', { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: 'upload', arguments: { action: 'stream-upload', profile_type: 'workspace' } } }, { headers: { Authorization: 'Bearer ' + process.env.FASTIO_API_KEY } }); // legacy call removed: ({
      orgId,
      workspaceId,
      path: targetPath,
      fileBuffer: imageResponse.data,
      contentType: 'image/jpeg'
    });
    
    return res.json({ success: true, url: uploadResult.url });
  } catch (error) { 
    console.error('Upscaling pipeline error:', error.message);
    return res.status(500).json({ error: 'Failed to upscale and store image' });
  }
}

When implementing this middleware, add retry logic to handle transient network issues or API rate limits. Since Clay runs batch requests concurrently, your middleware could receive dozens of requests per second. Using queue management or rate-limiting libraries like p-limit in your Node.js script ensures you do not exceed the rate limits of your upscaler API. Caching prediction outputs based on a hash of the source image URL prevents reprocessing identical assets when rebuilding lists or running duplicate campaigns.

Securely store and share upscaled campaign images

Provide your GTM agents and image upscaler pipeline with an intelligent workspace featuring version control, Metadata Views, and a consolidated MCP toolset. Start your 14-day free trial.

Start 14-Day Trial

Automated design pipelines require a secure, shared destination. Saving outputs to individual hard drives or isolated servers prevents GTM collaboration. Fastio provides shared workspaces where both human designers and automated enrichment agents read, write, and manage assets in a single interface.

If an AI upscaler agent runs a batch job and accidentally overwrites critical campaign collateral, manual recovery is time-consuming. Fastio addresses this risk by maintaining a full file version history. Teammates can view and restore prior versions of any asset, making automated pipelines auditable and safe.

Security is managed through granular permissions at the organization, workspace, folder, and file levels. You can restrict your automated upscaler's API token to a single target folder, keeping sensitive company documents isolated. Connected agents access Fastio using a consolidated MCP toolset that supports Streamable HTTP at the /mcp endpoint and legacy SSE at the /sse endpoint. Learn more by reviewing our guide on storage for agents.

Unlike consumer cloud drives that require seat-based licensing, Fastio organizations run on a paid subscription model with a 14-day free trial that requires a credit card [Fastio Pricing]. Teams can choose from three plans: Starter at $29/mo, Business at $99/mo, and Growth at $299/mo. For details on these tiers, visit the Fastio pricing directory. Workspaces created by agents have Intelligence enabled by default, auto-indexing all uploaded assets for semantic search, summarization, and citation-backed Q&A.

For example, a representative can search for 'find the high-resolution logo for Acme Corp' using natural language. Fastio's hybrid search combines exact full-text matching with semantic meaning retrieval to surface the file and its preview instantly, eliminating the need to browse folders manually. This search capability reads filenames and metadata, ensuring that team members can locate assets even if filenames are inconsistent. By placing Fastio at the core of your GTM creative stack, you ensure that high-resolution outputs are immediately accessible to sales, marketing, and creative departments, bridging the gap between automation and human execution.

To execute this pipeline, operations teams must coordinate file ingestion, metadata extraction, upscaling execution, and final asset handoff. The entire workflow runs through a series of connected steps.

First, the team imports low-resolution source files into Fastio. Using Cloud Import, operators pull assets from OneDrive, Box, Google Drive, or Dropbox via OAuth, preserving original folder hierarchies. Cloud Import keeps file transfers explicit, avoiding continuous sync background tasks that trigger accidental API runs.

Second, the team configures Metadata Views to turn the unstructured uploads folder into a queryable data grid. Using plain English, you instruct the built-in AI to extract key details from your source images. The AI designs a typed schema (supporting Text, Integer, Decimal, Boolean, URL, JSON, and Date & Time) and populates the view. Incremental extraction allows you to add new metadata columns without reprocessing existing rows, saving time and API credits. You can read more about data extraction on the Fastio Metadata Views page.

Third, when a new source URL is populated in the Metadata View, a Fastio Webhook fires, notifying your middleware function. Webhooks eliminate the need for constant polling, reducing credit consumption. The middleware runs the upscaling loop, downloads the high-resolution JPEG, and writes the output back to the Fastio workspace.

Fourth, the team uses Metadata Views to audit upscaled files. By adding columns for image width and height, the AI automatically verifies that assets meet campaign resolution standards. You can build automation workflows in plain language as a directed acyclic graph (DAG) of steps on the Fastio workflows page.

Finally, the upscaler agent transfers ownership of the output folder to the human design manager. The designer receives a claim link, taking full admin control of the assets, while the agent retains scoped API access for future batch updates, establishing a clean handoff boundary.

Using this automated structure, creative directors can inspect upscaled outputs inside their Fastio dashboard, reviewing approvals and leaving feedback directly on file selections. Because all comments can be anchored to specific image regions, communication remains contextual and fast. If an image requires manual retouching, a designer can upload a revised version, and Fastio's version history will preserve both the automated upscaled output and the human edit. This dual-workflow structure ensures that GTM pipelines remain automated while human designers retain final creative control over the assets sent to prospects.