channel/unarchive

Restores a previously archived Slack channel, making it active and visible again for all members. Members can resume posting after unarchiving. The channel's full history is preserved intact. Requires channels:manage scope.

When to Use

Project resumption: When previously completed work resumes (e.g., a contract is renewed, a seasonal project restarts), restore the existing channel rather than creating a new one to preserve historical context.
Regulatory review: Compliance or legal holds may require reactivating an archived channel to allow regulated review access to the channel's content and history.
Accidental archive recovery: When a channel was archived inadvertently, restore it immediately to minimize disruption to team communications.
Recurring event channels: Revive annual or recurring event channels (e.g., #conference-2025 reopened from #conference-2024 pattern) rather than creating fresh channels each time.

Configuration

Connection

Field	Type	Required	Description
`botToken`	string	Required	Bot Token starting with `xoxb-`. Requires `channels:manage` scope.

Operation Fields

Field	Type	Required	Description
`channelId`	string	Required	The archived channel to restore. Starts with `C` (public) or `G` (private). You can find archived channel IDs using `channel/getMany` with `excludeArchived: false`.

Finding Archived Channel IDs: To find the ID of an archived channel, use channel/getMany with excludeArchived: false and filter by channel name. Archived channels are not shown in the default Slack UI but are accessible via the API.

Sample Configuration

{
  "operation": "channel/unarchive",
  "connection": {
    "botToken": "{{credentials.slackBotToken}}"
  },
  "fields": {
    "channelId": "{{$json.channelId}}"
  }
}

Validation Errors

Error Code	Cause	Resolution
`not_archived`	The channel is not archived — it is already active.	Check `isArchived` with `channel/get` before unarchiving. Treat this as a warning and skip if already active.
`channel_not_found`	Invalid channel ID.	Use `channel/getMany` with `excludeArchived: false` to find the archived channel's ID by name.
`missing_scope`	Bot token lacks `channels:manage` scope.	Re-authorize the Slack app with the required scope.

Output

Success Port

Field	Type	Description
`channelId`	string	The channel that was unarchived.
`status`	string	`success` or `error`.
`errorCode`	string	Slack error code when `status` is `error`.
`payload`	object	Full raw Slack API response.

Error Port

On failure with Continue on Error enabled, routes to the error port. Treat not_archived as a safe-to-ignore warning for idempotent workflows.

Sample Output

{
  "channelId": "C08PROJECT01",
  "status": "success",
  "errorCode": "",
  "payload": {
    "ok": true
  }
}

Expression Reference

Expression	Result
`{{$node["channel-unarchive"].json.channelId}}`	Restored channel ID — pass to `channel/invite` or `message/send` to re-engage members.
`{{$node["channel-unarchive"].json.status === "success"}}`	Boolean gate — confirm restoration before sending re-open notifications.

Node Policies & GuardRails

Policy Area	Recommendation
Scope requirements	Requires `channels:manage` scope.
Rate limiting	Tier 2 (20+ req/min). Safe for individual or small-batch unarchive operations.
No hard-coded IDs	Always source `channelId` dynamically. Use `channel/getMany` with `excludeArchived: false` to resolve archived channel IDs by name.
Check before unarchiving	Use `channel/get` or IF on `isArchived` before calling this node. Calling unarchive on an active channel returns `not_archived` — safe to handle as a no-op.
Post-restore actions	After unarchiving, consider re-inviting key members who may have left, updating the topic with current status, and posting a channel re-open announcement.
Audit trail	Log unarchive events with the channel ID, timestamp, and triggering workflow to maintain a complete lifecycle record.

Examples

Example 1 — Contract Renewal Channel Restore

When a client contract is renewed in the CRM, restores the archived client channel and re-invites the account team.

// Trigger: CRM contract renewal event
// $json.clientName, $json.archivedChannelId, $json.accountTeamIds

// Node 1: channel/unarchive
{ "channelId": "{{$json.archivedChannelId}}" }

// Node 2: channel/setTopic
{ "topic": "Contract renewed {{$json.renewalDate}} — Active through {{$json.expiryDate}}" }

// Node 3: channel/invite (re-invite account team)
{ "channelId": "{{$json.archivedChannelId}}", "userIds": "{{$json.accountTeamIds.join(',')}}" }

// Node 4: message/send — welcome back message

Example 2 — Accidental Archive Recovery

Triggered by a Slack event (channel_archived) for channels matching production-critical names — auto-restores them immediately.

// Trigger: Slack event webhook — channel_archived event
// $json.channelId, $json.channelName

// IF: channelName matches critical pattern (e.g., "monitoring-", "deploy-", "alerts-")
// True → channel/unarchive immediately
// False → log for manual review

{ "operation": "channel/unarchive", "fields": { "channelId": "{{$json.channelId}}" } }
// message/send to #ops-team: "Auto-restored critical channel {{channelName}} that was accidentally archived"

Example 3 — Recurring Event Channel Reactivation

Scheduled yearly workflow that unarchives the annual conference channel, renames it for the new year, and updates its purpose.

// Finds archived channel by name pattern
// channel/getMany with excludeArchived: false
// Filter: channelName matches "conference-{{lastYear}}"

// Node 1: channel/unarchive
// Node 2: channel/rename → "conference-{{thisYear}}"
// Node 3: channel/setPurpose → updated purpose with new dates
// Node 4: message/send → announcement in #general