Threads Marketing

Threads (Meta) Marketing Skills

A bundle of 8 focused skills for Threads content ops in 2026. Each skill is single-purpose, follows the draft then approval then publish pattern, and uses the Publora API for posting Threads posts and threads.

Threads is the warmer, less newsy sibling of X. Same text-first shape, but the register is conversational and the heaviest ranking signal is a real reply.

When to use this bundle

• Writing a single post or a multi-post thread -> use threads-post-writer
• Removing AI tells from a draft, or auditing it before posting -> use threads-humanizer (rewrite plus --mode audit pre-publish review, which folds in the post-audit sub-tool)
• Reverse-engineering the hook from a viral Threads post or thread -> use threads-hook-extractor
• Drafting a reply, or a quote post -> use threads-reply-drafter
• Adapting content from another platform into a native Threads post or thread -> use threads-repurposer
• Planning a week of Threads content -> use threads-content-planner
• Auditing and rewriting your Threads profile (bio, name, pin, link) -> use threads-profile-optimizer
• Reading your audience and niche from real data (top posts for a query, a profile's follower count and recent posts) -> use threads-audience-insights

Core pattern

Every action-taking skill follows three steps:

1. Parse the input. If the user gives a post URL, the skill uses

lib/url_parser.py to extract the handle and post id.

1. Draft the content. The skill applies 2026 research (Threads hook formulas,

timing, voice rules, ranking heuristics) and shows the draft to the user.

1. Wait for approval. The user replies "post", "yes", or suggests edits.

Only after explicit approval does the skill call Publora to publish.

Prerequisites

Three tiers - pick one.

Tier 0 - Draft only (default, no setup)

The skills work out of the box. No API keys, no signup. Every approved draft is returned as a copy-paste block with the target Threads URL. Great for trying the skills before committing to any backend.

Tier 1 - Publora auto-post (recommended, ~2 min)

On approval, the writer skill auto-publishes to Threads via the Publora API. Pass long content and Publora auto-splits it into a connected multi-post thread at paragraph then sentence boundaries.

1. Sign up free: https://app.publora.com/signup
2. Connect your Threads account in Publora (Channels then Add Channel)
3. Copy your API key from Publora's API panel
4. Drop into .env:

`` PUBLORA_API_KEY=sk_... THREADS_PLATFORM_ID=threads-... ``

1. Run pip install -r requirements.txt

Why Publora: a thread on the native Threads API means creating a container for post 1, publishing it, then creating each next post with a reply_to_id pointing at the previous one, and handling partial failures. Publora does all of that in one create-post call and auto-splits long content. We built on top of it so we did not have to reimplement the chaining.

Tier 2 - Build your own poster (advanced)

Prefer not to SaaS it? Ask Claude Code or Codex to build a custom poster on the Threads Graph API. Set THREADS_SKILLS_CUSTOM_POSTER= and the skills invoke it on approval. Publora is the 2-minute path.

Note on replies

A reply to another user's post is a separate post on Threads, and Publora's create-post cannot target someone else's post. So threads-reply-drafter always returns its draft as a copy-paste block for you to post as the reply or quote yourself. Single posts and your own threads auto-publish through Publora normally.

Voice rules (baked into every skill)

1. No em dashes (—), en dashes, or double dashes. Biggest AI tell.
2. Use .. as a soft pause when rhythm calls for it.
3. Capitalize all personal, company, and product names. Lowercase a brand reads

as careless.

1. Sentence starts can be lowercase (native Threads voice); names inside stay capitalized.
2. Avoid AI vocabulary: leverage, fundamentally, streamline, harness,

delve, unlock, foster.

1. Specific numbers beat adjectives. 2.4x beats "way better".
2. One idea per post. Two ideas means two posts, or a thread.
3. The first line carries everything. The feed truncates long posts with a "more" cut.
4. 500 chars per post (10,000 with a text attachment), but tight beats long.
5. 0-1 hashtag (Threads allows only ONE), 0-2 emoji, and only when each earns its place.
6. Warm and conversational, not a transplanted X dunk.

(Canonical reference: references/voice-rules.md. See also references/hook-formulas.md and references/algorithm-heuristics.md.)

How Threads URLs map

| URL shape | Parsed to | |---|---| | https://www.threads.net/@HANDLE/post/CODE | handle + post_id, type post | | https://www.threads.com/@HANDLE/post/CODE | same (threads.net normalized to threads.com) | | https://www.threads.com/@HANDLE | handle, type profile |

lib/url_parser.parse_threads_url(url) returns {handle, post_id, url_type, canonical_url}. A Threads post id is a base64-style shortcode, not a numeric id. A quote post is just a post URL; reply vs quote is a user choice, not a URL distinction.

Known gotchas

• One hashtag max. Threads rejects a second hashtag at the platform level,

not just as a style preference.

• External links suppress reach in post 1. Up to 5 links per post are

allowed, but move the link to a reply or to post 2+ of a thread.

• Each post in a thread counts toward your quota (250 posts / 24h, 50 /

hour). A 5-post thread uses 5.

• Partial thread failure returns status: partially_published with the IDs

that did post. The published posts stay live.

• No (1/N) markers by default. Unlike X, Publora does not number Threads

posts. Add the markers yourself in the text if you want them.

• Multi-post nesting can be temporarily paused while Meta works through

Threads app reconnection. Single posts always publish; fall back to posting the thread as separate posts when nesting is unavailable.

Resources

• Publora API docs - endpoint reference for the publishing layer
• lib/publora_client.py - thin Python client used by the writing skill
• lib/url_parser.py - Threads URL to handle/post-id parser

Acknowledgments

Publishing powered by the Publora REST API.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: sergebulaev
• Source: sergebulaev/threads-skills
• License: MIT

Install and usage instructions live in the source repository linked above.