You paste a URL into Slack and nothing happens — no preview card, no image, just a plain hyperlink. Or the preview appears but shows the wrong title and a missing image. Slack's link unfurling is powerful when it works, but it has a specific set of requirements that differ from other platforms. This guide covers exactly what Slack reads, why unfurls fail, and how to configure your meta tags to get a rich preview every time.

How Slack Unfurling Works

When a user posts a URL in a Slack channel or DM, Slack automatically fetches the page and generates a link preview called an unfurl. The Slackbot crawler (user-agent: Slackbot-LinkExpanding) visits your URL, parses the HTML, extracts Open Graph tags, and renders a preview card inline in the message.

This happens server-side — Slack does not execute JavaScript. All Open Graph tags must be present in the server-rendered HTML that Slack receives when it makes the HTTP request. Tags injected by client-side JavaScript will not appear in the unfurl.

Slack caches unfurls aggressively. Once a URL has been unfurled, Slack stores the result for a period and may not re-fetch the page immediately if the meta tags change. Expect a delay of hours to a day before updated tags appear in new unfurls.

Which Meta Tags Slack Reads

Slack reads standard Open Graph (og:) tags. It does not have a proprietary tag namespace like Twitter Cards. The tags that control your Slack unfurl are:

—og:title — the bold headline of the unfurl card (required)
—og:description — the body text below the title (recommended)
—og:image — the preview image shown in the card (recommended)
—og:image:width and og:image:height — used by Slack to determine image layout
—og:url — the canonical URL; Slack may use this instead of the shared URL in the card header
—og:site_name — the provider name shown at the top of the unfurl card in smaller text
—og:type — Slack reads this but it has minimal effect on rendering; use "website" or "article"

The Minimum Tag Set for Slack

<meta property="og:title" content="Your Page Title" />
<meta property="og:description" content="A concise 1–2 sentence description of the page." />
<meta property="og:image" content="https://example.com/og-image.jpg" />
<meta property="og:image:width" content="1200" />
<meta property="og:image:height" content="630" />
<meta property="og:url" content="https://example.com/your-page" />
<meta property="og:site_name" content="Your Brand Name" />

With these seven tags, Slack will render a full unfurl card showing your brand name as the provider, the title as the headline, the description as body text, and the image in the card. Missing any of them can cause the unfurl to be incomplete or fall back to a plain link.

Slack Image Requirements

Slack is more strict about images than most platforms. Getting this wrong is the most common reason a Slack unfurl shows no image:

—Recommended size: 1200×630px (1.91:1 ratio) — same as the standard OG image size
—Minimum size: Slack requires the image to be at least 500×262px to display in the card. Below this, the image is silently dropped.
—Maximum file size: 5MB. Larger images will not load.
—Format: JPEG, PNG, GIF (first frame only), and WebP are supported
—URL must be HTTPS — HTTP image URLs are blocked by Slack
—URL must be publicly accessible — Slack cannot fetch images behind authentication or IP restrictions
—Always include og:image:width and og:image:height — without dimensions, Slack may download the full image to determine size, which can cause slow or failed unfurls

What a Slack Unfurl Card Looks Like

A Slack unfurl renders as a vertical card attached below the message. The layout from top to bottom is:

1.Provider name (og:site_name) — small grey text at the top, links to og:url domain
2.Title (og:title) — bold blue-ish link text
3.Description (og:description) — regular grey text, truncated around 150 characters
4.Image (og:image) — displayed below the text, full width of the card

If og:site_name is missing, Slack shows the domain (e.g., example.com) instead. If og:description is missing, that row is skipped entirely. If og:image is missing or fails to load, the card renders as text-only.

Why Slack Unfurls Fail Silently

Slack does not give users or developers any feedback when an unfurl fails. The URL simply appears as a plain link. Common causes:

1.OG tags injected by JavaScript — Slackbot does not execute JavaScript. Tags must be in the initial HTML response.
2.HTTP (not HTTPS) page URL — Slack will not unfurl HTTP URLs shared in channels. The page itself must be HTTPS.
3.HTTP og:image URL — even if the page is HTTPS, an HTTP image URL will be blocked.
4.Image too small — below 500×262px, the image is dropped without explanation.
5.Firewall or CDN blocking Slackbot — check that your CDN or WAF does not block the Slackbot user-agent.
6.Cloudflare or bot protection challenge — if your server returns a challenge page to Slackbot, Slack receives no OG tags.
7.Unfurl disabled by workspace admins — some Slack workspaces have link unfurling disabled at the admin level.
8.URL cached with old (missing) OG tags — Slack may be serving a cached unfurl from before your tags were added.

Checking If Your Server Blocks Slackbot

You can simulate exactly what Slackbot receives by making a request with the Slackbot user-agent:

# Fetch your page as Slackbot and extract OG tags
curl -s -A "Slackbot-LinkExpanding 1.0 (+https://api.slack.com/robots)" \
  "https://example.com/your-page" | grep -iE '(og:|twitter:)'

# Expected output for a well-configured page:
# <meta property="og:title" content="Your Page Title" />
# <meta property="og:description" content="A concise description." />
# <meta property="og:image" content="https://example.com/og.jpg" />
# <meta property="og:image:width" content="1200" />
# <meta property="og:image:height" content="630" />
# <meta property="og:url" content="https://example.com/your-page" />
# <meta property="og:site_name" content="Your Brand" />

# If this returns a Cloudflare challenge or empty output:
# Your server is blocking Slackbot — OG tags are inaccessible

If the curl command returns a challenge page or empty output, your server or CDN is blocking the Slackbot user-agent. Add Slackbot to your allowlist or configure your WAF to pass through requests with that user-agent string.

Clearing the Slack Unfurl Cache

Slack caches unfurls. If you have updated your meta tags and the old preview still appears, there are a few options:

—Wait — Slack caches typically expire within 24–48 hours for most URLs.
—Use a cache-busting query parameter — sharing ?v=2 or a similar parameter creates a new cache entry. This works but clutters the URL.
—Slack API: chat.unfurl — if you have a Slack app installed in the workspace, you can use the chat.unfurl API method to programmatically update an unfurl for a specific message.
—Re-share the URL in a new message — Slack may re-fetch the URL if it is shared in a different context.

Implementing Slack-Ready OG Tags in Next.js

The Next.js Metadata API generates all the OG tags Slack needs. Use the openGraph field with all required properties:

// app/blog/[slug]/page.tsx
import type { Metadata } from 'next'

export async function generateMetadata(
  { params }: { params: Promise<{ slug: string }> }
): Promise<Metadata> {
  const { slug } = await params
  const post = await getPost(slug)

  return {
    title: post.title,
    description: post.description,
    openGraph: {
      title: post.title,
      description: post.description,
      url: `https://example.com/blog/${slug}`,
      siteName: 'Your Brand',
      type: 'article',
      publishedTime: post.publishedAt,
      images: [
        {
          url: `https://example.com/blog/${slug}/og-image.jpg`,
          width: 1200,
          height: 630,
          alt: post.title,
        },
      ],
    },
  }
}

The siteName property maps to og:site_name — this is the provider label at the top of the Slack unfurl card. The images array generates both og:image and the og:image:width / og:image:height dimension tags. Next.js handles the mapping automatically.

Slack Unfurling for Slack Apps (Programmatic Control)

If you are building a Slack app, you can control unfurls programmatically using the link_shared event and the chat.unfurl API. This gives you full control over the unfurl content — including custom Block Kit attachments — regardless of the page's meta tags:

// Handle link_shared event in your Slack app
app.event('link_shared', async ({ event, client }) => {
  const unfurls: Record<string, object> = {}

  for (const link of event.links) {
    unfurls[link.url] = {
      blocks: [
        {
          type: 'section',
          text: {
            type: 'mrkdwn',
            text: `*<${link.url}|Your Page Title>*\nA description of the linked page.`,
          },
          accessory: {
            type: 'image',
            image_url: 'https://example.com/og-image.jpg',
            alt_text: 'Preview image',
          },
        },
      ],
    }
  }

  await client.chat.unfurl({
    channel: event.channel,
    ts: event.message_ts,
    unfurls,
  })
})

Programmatic unfurls let you display dynamic data (live pricing, status indicators, user-specific content) in the Slack preview — things that are impossible to express through static meta tags. This approach requires a Slack app with the links:read and links:write OAuth scopes, and you must register your domain in the app's Event Subscriptions settings.

How to Validate What Slack Sees

Unlike Twitter (Cards Validator) and Facebook (Sharing Debugger), Slack has no official unfurl debugging tool. Your options are:

—Curl with Slackbot user-agent — manually verify which tags are in the server HTML (see command above)
—Share in a test channel — post the URL in a private Slack channel and observe the unfurl directly
—OGProof — simulates the Slackbot crawl automatically, parses the returned HTML, and renders an accurate preview of the Slack unfurl card including the provider name, title, description, and image. It flags missing tags, non-HTTPS image URLs, and images below the minimum size.

TipOGProof sends requests to your page using the Slackbot-LinkExpanding user-agent, so it reveals exactly what Slack sees — including whether your server blocks the crawl or returns a bot challenge page.

Common Slack Unfurl Mistakes

1.OG tags rendered by JavaScript — Slackbot ignores client-side rendering. All tags must be in server HTML.
2.HTTP og:image — Slack blocks non-HTTPS image URLs. Always use HTTPS.
3.Image below 500×262px — images smaller than the minimum are silently dropped.
4.Missing og:site_name — the provider line shows only the domain instead of your brand name.
5.No og:image:width and og:image:height — Slack may fail to display the image or render it incorrectly.
6.Blocking Slackbot via WAF — Cloudflare and similar proxies may challenge bot user-agents; allowlist Slackbot.
7.Sharing HTTP URLs — Slack does not unfurl HTTP (non-HTTPS) page URLs at all.
8.Expecting instant cache updates — Slack caches unfurls for up to 24–48 hours; updated tags do not appear immediately.

Slack OG Tag Checklist

—og:title — present, concise (under 200 characters)
—og:description — present, under 150 characters for full visibility without truncation
—og:image — absolute HTTPS URL, 1200×630px recommended, minimum 500×262px
—og:image:width and og:image:height — always include for correct image rendering
—og:url — set to the canonical HTTPS URL
—og:site_name — your brand name (appears as the provider label)
—Page URL is HTTPS — Slack does not unfurl HTTP URLs
—OG tags are in server-rendered HTML (not injected by JavaScript)
—Slackbot user-agent is not blocked by your server or CDN
—Validate with OGProof to confirm Slackbot sees correct tags and the unfurl preview is accurate

Slack Open Graph Tags: How Slack Unfurls URLs and What Controls the Preview