The API Media-Draft Bottleneck: Automating LinkedIn Carousel Prep with Make and Claude

If you have ever tried to automate your B2B publishing pipeline, you have likely run headfirst into a silent, frustrating wall: the LinkedIn API does not support native organic document uploads.

While the LinkedIn algorithm heavily rewards the swipeable PDF carousel format with up to 39% more reach than static text posts [(AuthoredUp/Contentdrips)], the platform’s official /rest/posts API refuses to accept document assets for organic personal profiles or company page publishing. You cannot simply pass a PDF URN and expect an in-feed document viewer.

The industry standard workaround is to construct a “multi-image” post using the API’s multiImage schema, where you submit up to 20 individual image assets sequentially. But this introduces its own crop of failures. In the feed, a multi-image API payload doesn’t render as a swipeable carousel with neat arrows; instead, it dumps those images into a cluttered, unpredictable grid that frequently crops your carefully designed square or portrait slides right through the middle.

To bypass this bottleneck, we designed a custom workflow using Make and Claude. Instead of forcing an unsupported PDF format or settling for a mangled image grid, this system dynamically prepares a high-converting, multi-slide draft with exact formatting parameters, placing it directly into a team queue for one-click manual publishing. Here is how the API restrictions break down and the step-by-step blueprint to automate the pipeline.

The API Schema Constraints We Uncovered

When building on the versioned LinkedIn Posts API (https://api.linkedin.com/rest/posts), we analyzed the behavior of the content payload.

For organic posts, the API exposes two primary routes for media: 1. content.media: Used for single image or video attachments. 2. content.multiImage.images: An array of individual image objects, each requiring a pre-registered image URN (urn:li:image:{id}).

{
  "author": "urn:li:person:12345",
  "commentary": "Our slide deck summary.",
  "visibility": "PUBLIC",
  "lifecycleState": "PUBLISHED",
  "distribution": {
    "feedDistribution": "MAIN_FEED"
  },
  "content": {
    "multiImage": {
      "images": [
        { "id": "urn:li:image:A1" },
        { "id": "urn:li:image:A2" }
      ]
    }
  }
}

The issue is structural. While third-party enterprise tools like Sprinklr or SocialPilot can occasionally handle direct PDF document posts under specific partner program permissions, standard developer apps are locked out. If you attempt to send a PDF or PPTX asset under a standard API app using a NATIVE_DOCUMENT schema, the endpoint typically rejects the payload.

Furthermore, if you use the standard multiImage API route shown above, the LinkedIn feed does not display a swipeable slide deck. Instead, it formats the images as a grid (two side-by-side squares, or a main square with smaller thumbnails). This means any slide containing sequential text or data visualizations becomes instantly unreadable because the algorithm crops the outer margins of your second and third slides to fit the grid.

The only way to preserve the high-retention, swipeable slide experience on personal profiles is to upload a multi-page PDF manually as a document.

Our workflow solves this by using Claude to ingest raw B2B assets (like long-form articles or newsletters) and convert them into beautifully structured, slide-by-slide copy. Then, Make coordinates the generation of the asset slides and formats them into a ready-to-publish queue, saving hours of manual layout work.

The Automation Blueprint: Step-by-Step

Our automated pipeline uses a simple three-tier architecture: Make (the orchestrator), Claude (the copywriter and layout designer), and a queue manager (like Airtable or a scheduler’s draft folder).

Step 1: Ingesting and Structuring the Content

The workflow begins when a webhook is triggered by a new asset—such as a completed Google Doc or a published WordPress post.

The first Make module passes this text to Claude via the Anthropic API. We use a highly specific system prompt to prevent Claude from writing generic, high-level summaries. The goal is to output an explicit, slide-by-slide script.

You are a senior B2B content strategist. Break the provided article into a 7-slide carousel structure. 
Format your output strictly in JSON. Do not include introductory text or explanations.

For each slide, output:
1. Slide_Number (integer)
2. Slide_Header (max 40 characters, high-contrast hook)
3. Slide_Body (max 120 characters, concise, tactical point)
4. Slide_Visual_Prompt (a clear directive for what image or graphic should accompany this slide)

By constraining the character limits in the API call, we ensure that the text remains large and readable on mobile devices—the environment where the vast majority of your target audience will actually swipe through the carousel.

Step 2: Generating and Rendering the Slides

Once Make receives the JSON payload from Claude, it iterates through the slides.

To convert this structured copy into actual visual assets without opening a design tool like Canva, you can route the text from each slide object to a programmatic image-rendering API (such as Bannerbear, Placid, or PostNitro’s template rendering endpoint). Make sends a POST request with the slide title, body, and page count (e.g., “Slide 3 of 7”) to overlay onto a pre-branded background template.

The rendering tool returns a unique image URL for each slide.

Step 3: Compiling the Draft and Circumventing the API

Instead of trying to push these raw images directly to LinkedIn via the limited multiImage API—which, as we established, would result in a cropped feed grid—Make routes the final compiled assets into an internal review folder or a scheduling tool’s draft queue.

For our workflow, Make takes: 1. The raw commentary drafted by Claude for the main post body. 2. The folder of rendered PNG slide images. 3. A auto-generated PDF compiled from those sequential PNGs (using a PDF conversion module in Make, such as PDF.co or Cloudmersive).

This entire package is deposited into a Slack notification or an Airtable row labeled “Ready for Review.”

The content operator simply downloads the generated PDF, opens their LinkedIn queue, clicks “Add a Document,” and drops the PDF directly into their draft. Because the template rendering tool was locked to portrait dimensions (1080 × 1350 pixels), the resulting PDF converts perfectly into a highly visible, swipeable carousel with massive vertical real estate in the feed.

The Results and Trade-offs

By transitioning from manual carousel design to this hybrid Make/Claude pipeline, we cut our production time down significantly. What used to take a designer and copywriter roughly 90 minutes of back-and-forth in Figma can now be reviewed, adjusted, and published in under 5 minutes.

However, operating this workflow requires accepting a clear technical trade-off: you cannot achieve 100% hands-off automation.

If you want the maximum reach and dwell time that comes with native LinkedIn document carousels, you must keep a human in the loop to handle the final upload step. Attempting to fully automate the process by scheduling the multi-image payload via the standard API will ruin your branding, as the platform crops the sides of your slides to force them into a static image preview grid.

For team leaders and operators managing personal brands or corporate pages, this semi-automated approach is the sweet spot. It eliminates the friction of copy editing and slide formatting, leaving you with a single, high-leverage task: dragging and dropping a perfectly formatted PDF into your queue.

This article was generated with the help of AI.