How to automate social media posting with Codex

Codex social media automation works best as a controlled pipeline. Keep the source material in your repository, ask Codex to produce a separate draft for each channel, require human approval, then use Groniz to schedule the approved versions and verify delivery. Groniz Connectors handles OAuth, per-platform formatting, and delivery across 32+ networks. Codex works with the content and runs the publishing workflow through a Skill, the CLI, or MCP.

This division gives each part of the system a clear job. Groniz owns the channel connections, so Codex does not need to imitate browser clicks or store every social credential in a project. Your repository holds the source, drafts, review record, and delivery references.

The finished workflow

The workflow has six stages:

Repository source
      ↓
Codex creates one draft per channel
      ↓
Human reviews copy, media, destination, and time
      ↓
Groniz discovers live channel requirements and creates drafts
      ↓
Approved drafts are scheduled
      ↓
The team verifies the queue and final delivery

A SaaS release might begin as social/source/v2-release.md. Codex can turn it into an X post, a LinkedIn update, and a Reddit draft without treating the channels as interchangeable. A reviewer checks each file against the source and approves the exact integration and timestamp before the Groniz delivery commands run.

What you need before you start

Before giving Codex a publishing task, prepare:

• A Codex client on the machine where you will configure the workflow.
• A Groniz account with each intended channel connected through OAuth.
• A source file with confirmed facts, links, and the intended call to action.
• Any media files in a stable repository path.
• An owner who can approve the final copy, destination, and schedule.
• A timezone and an ISO 8601 publication timestamp for every scheduled post.

Groniz can publish or schedule to 32+ networks, but every channel differs. Required settings, content limits, media rules, and available tools can change by integration. A workflow that succeeds for LinkedIn should not assume that the same fields will work for Reddit, Instagram, or X.

Choose between the Skill, CLI, and MCP

Codex can access Groniz in three ways. Each route reaches the same connector core, but the working style differs.

Access path	What it gives Codex	Use it when
Skill	Instructions for the Groniz workflow, with the CLI installed behind it	You want Codex to follow a reusable publishing process from natural-language requests
CLI	Direct, inspectable terminal commands	You want explicit commands in scripts, runbooks, or repository tasks
MCP	Structured tools from the remote Groniz server	You want Codex to call Groniz tools without making shell commands the main interface

OpenAI describes skills as reusable workflows that package instructions, resources, and optional scripts. The Skill is the simplest default for repeated editorial work. Choose the CLI when every delivery step needs to be visible in a runbook. MCP fits a Codex setup that already uses tool servers.

You only need one path. Installing more than one will not improve the content or remove the approval requirement.

Set up Groniz for Codex

Option 1: install the Skill

Install the Groniz Skill with the standard Skills installer:

npx skills add groniz/groniz-cli

The Skill teaches Codex the Groniz command flow and installs the CLI behind it. Use this route when you want prompts such as "prepare channel-specific drafts, stop for approval, then schedule the approved versions" to map to a consistent process.

Option 2: install the CLI

The Groniz CLI is a self-contained native binary. Install it and authenticate through the browser device flow:

curl -fsSL https://groniz.com/install.sh | sh
groniz auth:login

Verify authentication before any publishing run:

groniz whoami

Treat a failed whoami check as a hard stop. Draft generation can continue locally, but delivery cannot.

Option 3: connect the remote MCP server

Create an API key in Groniz Connectors, export it before Codex launches, and add the server:

export GRONIZ_API_KEY="your-api-key"
codex mcp add groniz --url https://mcp.groniz.com/mcp \
  --bearer-token-env-var GRONIZ_API_KEY

The environment variable must exist before Codex starts. Do not put the plaintext token in config.toml; Codex rejects that configuration. The Codex MCP documentation confirms that Streamable HTTP servers support bearer-token authentication. It also explains that the desktop app, Codex CLI, and IDE extension share MCP configuration when they use the same Codex host, so you do not need to register the server separately for each of those clients on that machine.

Create a repeatable repository workflow

Keep generation, approval, and delivery state separate. A small directory structure is enough:

social/
├── source/
│   └── v2-release.md
├── drafts/
│   ├── x.md
│   ├── linkedin.md
│   └── reddit.md
├── media/
│   └── v2-dashboard.png
└── reviews/
    └── v2-release-approval.md

The source file should contain facts, URLs, product naming, and any claims that require care. Each draft file should target exactly one channel. The approval file should record the reviewer, approved draft path, integration ID, media path, publication time, and approval status.

Give Codex a bounded task such as:

Read social/source/v2-release.md.

Create channel-specific drafts for X, LinkedIn, and Reddit in social/drafts/.
Preserve factual claims and source links. Adapt structure and length for each
channel instead of copying one version across all three.

Do not publish or schedule anything. Add a checklist to
social/reviews/v2-release-approval.md with the draft path, intended channel,
media file, integration ID placeholder, ISO 8601 time placeholder, and a
PENDING approval status. Stop after writing the files.

Once Codex writes these files, a reviewer can inspect a diff, correct a claim, replace an asset, or reject one channel without affecting the others. Generation and publishing remain separate, visible actions.

Keep the approval record easy to audit. A minimal entry can look like this:

## LinkedIn

- Draft: social/drafts/linkedin.md
- Source checked: yes
- Integration ID: [PENDING]
- Media: social/media/v2-dashboard.png
- Publish at: [PENDING_ISO_8601_TIMESTAMP]
- Copy approved by: [PENDING_REVIEWER]
- Delivery status: PENDING

Approval should cover factual accuracy, channel fit, links, tags or mentions, media, account, and timing. It should also identify anything Codex inferred from the source. Replace PENDING values only after the reviewer has seen the finished channel draft. Then a later instruction such as "schedule the approved posts" refers to concrete files and destinations instead of relying on conversational context.

Discover live channel requirements

After the content review, resolve the actual connected accounts:

groniz whoami
groniz integrations:list
groniz integrations:settings [INTEGRATION_ID]

Run groniz integrations:settings [INTEGRATION_ID] for every target, even if the team has posted there before. Its live output is the source of truth for required fields, current maximum length, available integration tools, and channel-specific settings.

Update the approval record with the selected integration ID and requirements. Then ask Codex to check each approved file against the reported limit and required fields. If an integration exposes a tool for dynamic data, fetch that data rather than inventing a setting. Reddit community fields, video metadata, reply controls, and other platform options are integration-specific.

Add media using the uploaded path

Local paths and external image URLs are not post media references. Upload every asset first:

groniz upload social/media/v2-dashboard.png

The command returns a media object. Copy its .path value into the approved delivery record and use that value in the post command. Keep the local source path as provenance, but do not pass it to post creation.

Before approval, check that the image is the intended version, has the right crop for the channel, and contains no stale interface, private data, or unsupported claims. Media approval belongs beside copy approval because changing either can change the meaning of the post.

Create a draft before scheduling

With the destination, settings, text, media path, and time approved, create a Groniz draft:

groniz posts:create \
  -c "[APPROVED_CHANNEL_COPY]" \
  -m "[RETURNED_MEDIA_PATH]" \
  -s "2026-07-23T15:00:00Z" \
  -t draft \
  -i "[INTEGRATION_ID]" \
  --settings '[REQUIRED_SETTINGS_JSON]'

Use a separate call for each channel unless the live integration settings explicitly support the same structure. Store the returned post ID in the approval record.

Creating a draft gives you a review point, but does not prove that the post is publishable. Groniz drafts skip some validation. Before promotion, recheck the current integration settings, required fields, length, media, link, destination, and timestamp. Then move the reviewed post into the schedule:

groniz posts:status [POST_ID] --status schedule

The final approval should be specific: "schedule post [POST_ID] to integration [INTEGRATION_ID] at [ISO_TIMESTAMP]." Approval to write copy does not authorize publication.

Verify the queue and delivery

Check that the post appears in the expected window:

groniz posts:list \
  --startDate "2026-07-23T00:00:00Z" \
  --endDate "2026-07-24T00:00:00Z"

Compare the returned post ID, status, integration, and scheduled time with the approval record. After the scheduled time, verify the final post on the destination platform. Record the platform URL or delivery result when available.

Do not treat a successful create command as final delivery. It confirms that Groniz accepted the request, not that a provider could not later reject it or that the rendered post matches expectations.

Failure checks worth keeping in the runbook

Most avoidable failures happen when work moves from one stage to the next. Before retrying, check the relevant case:

• If authentication fails, run groniz whoami. Confirm the CLI login or check that GRONIZ_API_KEY existed before Codex launched.
• If the wrong account is selected, compare the integration ID from groniz integrations:list with the approved destination.
• If a required setting is missing, rerun groniz integrations:settings [INTEGRATION_ID] and supply every required value.
• If content is rejected, check the live maximum length and channel-specific format. Do not rely on a limit copied into an old runbook.
• If media is rejected or absent, confirm that groniz upload succeeded and that the post uses the returned .path, not a local path or external URL.
• If a draft looked valid but scheduling failed, remember that drafts skip some validation. Recheck every required field before changing the status.
• If the post ran at the wrong time, compare the approved ISO 8601 timestamp and timezone with the queued value.
• If a retry might create a duplicate, query the relevant date window and look for the existing post ID before creating another one.
• If the queue succeeded but the post is missing, inspect the delivery result and destination rather than assuming the provider published it.

This workflow automates the repeatable handoff while keeping publication under human control. Codex turns a trusted source into channel-specific working files. A reviewer controls meaning, account, media, and time. Groniz handles the OAuth connections, per-platform formatting, schedule, and delivery.

To put the workflow into use, connect your channels in Groniz Connectors, choose the Skill, CLI, or MCP path, and run the first campaign as drafts from a reviewed repository source.