]`
This would be particularly useful when trying to convert a category to a tag.
First, use the following rake task to find the relevant category ID.
```ruby
rake categories:list
```
Tag all topics of the category you specify. In this example, you would be tagging all topics in the category with an ID of 6 with the “support” tag. ⚠ this will remove all other tags from each topic.
```ruby
rake tags:bulk_tag_category["support",6]
```
Append all topics of the category you specify. In this example, you would be adding the “support” tag to all topics in the category with an ID of 6, while keeping existing tags.
```ruby
rake tags:bulk_tag_category["support",6,true]
```
## Move all topics with a specific tag to a single category
When trying to restructure your Discourse site, you may find that you want to move a collection of topics without triggering any notifications. One way to do this is to create a temporary tag, apply the tag to appropriate topics, move the topics to a specific category using the code below, then finally delete the temporary tag.
Get the tag.
```ruby
rails c
tag = Tag.find_by_name("tutorial")
```
Get destination category.
- For regular categories:
```plaintext
cat_to = Category.find_by_slug('guides')
```
- For subcategories:
```plaintext
cat_to = Category.find_by_slug('child-slug','parent-slug')
```
Move the tagged topics to the destination category.
```ruby
Topic.joins(:topic_tags).where("topic_tags.tag_id = ?", tag.id).update_all(category_id: cat_to.id)
```
Update the topic counts of the affected categories.
```ruby
Category.update_stats
CategoryTagStat.update_topic_counts
```
## Move all topics from one category to another
* * *
Find the category IDs with the following rake task:
```ruby
rake categories:list
```
The first value should be the starting category ID. The second value should be the destination category ID.
```ruby
rake categories:move_topics[15,6]
```
> **Rails Console Script**
>
> ```rb
> cat_from_id = XX # Category to move topics from
> cat_to_id = XX # Category to move topics to
> Topic.where(category_id: cat_from_id).update_all(category_id: cat_to_id)
> Category.update_stats
> CategoryTagStat.update_topic_counts
>
> ```
## Change owner of all topics in categories
* * *
Find the category IDs with the following rake task:
```ruby
rake categories:list
```
Specify the new owner and categories to operate on. The categories should be an array of category ids, categories `1`, `2` and `3` in the example:
```ruby
rails c
user = User.find_by(username_lower: "lowercase-username")
categories = [1, 2, 3]
```
Get all topic ids for the given categories and change the owner of the first post in all matched topics.
```ruby
topics = Topic.where(category_id: categories).pluck(:id)
topics.each do |topic|
PostOwnerChanger.new(
post_ids: Post.where(topic_id: topic).where(post_number: 1).pluck(:id),
topic_id: topic,
new_owner: user,
acting_user: Discourse.system_user,
skip_revision: true
).change_owner!
end
```
## Grant a badge to all group members
* * *
Grant a badge to all users that belong to a specific group. The first value is the group ID and the second is the badge ID.
```ruby
rails c
Group.find_by_name("event_participants").id
Badge.find_by_name("event_badge").id
exit
rake groups:grant_badge[42,102]
```
⚠ Note that the above rake task only grants a badge, it will not revoke a previously granted badge if a user is no longer part of the specified group. If you need to bulk revoke badges for all users that are no longer part of a group, you can run the following:
```ruby
rails c
badge_id = Badge.find_by_name("Some Group Member").id
group = Group.find_by_name("Some_Group")
group_user_id = group.users.pluck("id")
userBadge = UserBadge.where.not(user_id: group_user_id).where(badge_id: badge_id)
userBadge.each do |ub|
BadgeGranter.revoke(ub, revoked_by: Discourse.system_user)
end
exit
```
## Ensure all users are at their automatic trust level
* * *
Say you set the default trust level for new or invited users to a value that isn’t working out quite the way you expected (such as TL4). Now you want to change it so your users are at the trust level they would be automatically, given their current stats. The following commands will ensure all users are at the trust level they should be according to [Understanding Discourse Trust Levels](https://blog.discourse.org/2018/06/understanding-discourse-trust-levels/). **Note** : users with locked trust-levels will not be affected.
Make sure all users are set to the correct trust level:
```ruby
rails c
User.all.find_each do |user|
Promotion.recalculate(user)
end
```
Refresh the group stats to reflect the changes:
```ruby
Group.ensure_consistency!
```
## Topic maintenance scripts
The following ruby scripts demonstrate how to perform automated maintenance on topics based on activity dates and other criteria. These scripts combine SQL queries to identify topics with Ruby code to perform actions on them, and must be run via the rails console for your site.
Each script follows a similar pattern:
1. A SQL query that identifies relevant topics
2. Ruby code that processes each topic and applies the desired actions
3. Basic error handling and logging
These scripts can be customized by:
- Adjusting time periods (e.g., ‘6 MONTH’, ‘1 YEAR’, ‘2 YEAR’)
- Changing category selections to match your forum structure
- Modifying which actions to take (close, unlist, or move)
- Adding additional conditions like post count or view thresholds
### Close, Unlist, and Move Inactive Topics
This script identifies topics that meet the following criteria:
- In a specific category
- Open
- Unsolved (using the Discourse Solved Plugin)
- No recent activity within a specific timeframe
Then performs multiple actions:
- Closes them,
- Unlists them, and
- Moves them to a designated category for outdated content
> **SQL Query**
>
> ```sql
> WITH topic_list AS (
> SELECT ua.target_topic_id, MAX(ua.created_at) "created_at"
> FROM user_actions ua
> INNER JOIN topics t ON t.id = ua.target_topic_id
> INNER JOIN categories c ON c.id = t.category_id
> LEFT JOIN discourse_solved_solved_topics solved ON solved.topic_id = t.id
> WHERE t.closed = false
> AND t.category_id = [CATEGORY_ID]
> AND solved.topic_id IS NULL
> AND t.deleted_at IS NULL
> GROUP BY ua.target_topic_id
> HAVING MAX(ua.created_at) <= (CURRENT_DATE - (INTERVAL '[TIME_PERIOD]'))
> ORDER BY "created_at" DESC
> )
>
> SELECT '' AS total, target_topic_id AS topic_id, created_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY created_at DESC
>
> ```
> **Combined SQL + Script**
>
> ```rb
> sql = "WITH topic_list AS (
> SELECT ua.target_topic_id, MAX(ua.created_at) \"created_at\"
> FROM user_actions ua
> INNER JOIN topics t ON t.id = ua.target_topic_id
> INNER JOIN categories c ON c.id = t.category_id
> LEFT JOIN discourse_solved_solved_topics solved ON solved.topic_id = t.id
> WHERE t.closed = false
> AND t.category_id = [CATEGORY_ID]
> AND solved.topic_id IS NULL
> AND t.deleted_at IS NULL
> GROUP BY ua.target_topic_id
> HAVING MAX(ua.created_at) <= (CURRENT_DATE - (INTERVAL '[TIME_PERIOD]'))
> ORDER BY \"created_at\" DESC
> )
>
> SELECT '' AS total, target_topic_id AS topic_id, created_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY created_at DESC"
>
> results = ActiveRecord::Base.connection.execute(sql)
> user = Discourse.system_user
> destination_category = Category.find([DESTINATION_CATEGORY_ID])
>
> puts "Found #{results.count} topics to process"
>
> results.each do |row|
> begin
> topic = Topic.find(row["topic_id"])
>
> # 1. Move to destination category
> topic.update!(category_id: destination_category.id)
> puts "#{topic.id} moved to destination category"
>
> # 2. Close the topic
> topic.update_status('closed', true, user, until: nil)
> puts "#{topic.id} is closed"
>
> # 3. Unlist the topic
> topic.update_status('visible', false, user, until: nil)
> puts "#{topic.id} is unlisted"
>
> # Error Handling
> rescue => e
> puts "Error processing topic #{row["topic_id"]}: #{e.message}"
> end
> end
>
> puts "Process completed"
>
> ```
### Close Solved Topics with No Recent Activity
This script closes solved topics that have been inactive for a defined period. This can help keep your forum tidy while preserving valuable solved topics.
This script identifies topics that meet the following criteria:
- In a specific category
- Open
- Solved (using the Discourse Solved Plugin)
- No recent activity within a specific timeframe
> **SQL Query**
>
> ```sql
> WITH topic_list AS (
> SELECT ua.target_topic_id, MAX(ua.created_at) "created_at"
> FROM user_actions ua
> INNER JOIN topics t ON t.id = ua.target_topic_id
> INNER JOIN categories c ON c.id = t.category_id
> INNER JOIN discourse_solved_solved_topics solved ON solved.topic_id = t.id
> WHERE t.closed = false
> AND t.category_id IN ([CATEGORY_IDS])
> AND t.deleted_at IS NULL
> GROUP BY ua.target_topic_id
> HAVING MAX(ua.created_at) <= (CURRENT_DATE - (INTERVAL '[TIME_PERIOD]'))
> ORDER BY "created_at" DESC
> )
>
> SELECT '' AS total, target_topic_id AS topic_id, created_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY created_at DESC
>
> ```
> **Combined SQL + Script**
>
> ```rb
> sql = "WITH topic_list AS (
> SELECT ua.target_topic_id, MAX(ua.created_at) \"created_at\"
> FROM user_actions ua
> INNER JOIN topics t ON t.id = ua.target_topic_id
> INNER JOIN categories c ON c.id = t.category_id
> INNER JOIN discourse_solved_solved_topics solved ON solved.topic_id = t.id
> WHERE t.closed = false
> AND t.category_id IN ([CATEGORY_IDS])
> AND t.deleted_at IS NULL
> GROUP BY ua.target_topic_id
> HAVING MAX(ua.created_at) <= (CURRENT_DATE - (INTERVAL '[TIME_PERIOD]'))
> ORDER BY \"created_at\" DESC
> )
>
> SELECT '' AS total, target_topic_id AS topic_id, created_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY created_at DESC"
>
> results = ActiveRecord::Base.connection.execute(sql)
> user = Discourse.system_user
>
> puts "Found #{results.count} topics to process"
>
> results.each do |row|
> begin
> topic = Topic.find(row["topic_id"])
>
> # Close the topic
> topic.update_status('closed', true, user, until: nil)
> puts "#{topic.id} is closed"
>
> # Error Handling
> rescue => e
> puts "Error processing topic #{row["topic_id"]}: #{e.message}"
> end
> end
>
> puts "Process completed"
>
> ```
### Archive Previously Closed Topics
This script identifies topics that were previously closed before a specific date and moves them to an archive category while unlisting them.
> **SQL Query**
>
> ```sql
> WITH topic_list AS (
> SELECT
> t.id AS topic_id,
> tt.execute_at AS closed_at
> FROM topics t
> INNER JOIN categories c ON c.id = t.category_id
> LEFT JOIN topic_timers tt ON tt.topic_id = t.id AND tt.status_type IN (1, 8)
> WHERE t.closed = true
> AND t.category_id IN ([CATEGORY_IDS])
> AND t.deleted_at IS NULL
> AND tt.execute_at IS NOT NULL
> AND tt.execute_at <= (CURRENT_DATE - INTERVAL '[TIME_PERIOD]')
> ORDER BY tt.execute_at DESC
> )
>
> SELECT '' AS total, topic_id, closed_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY closed_at DESC
>
> ```
> **Combined SQL + Script**
>
> ```rb
> sql = "WITH topic_list AS (
> SELECT
> t.id AS topic_id,
> tt.execute_at AS closed_at
> FROM topics t
> INNER JOIN categories c ON c.id = t.category_id
> LEFT JOIN topic_timers tt ON tt.topic_id = t.id AND tt.status_type IN (1, 8)
> WHERE t.closed = true
> AND t.category_id IN ([CATEGORY_IDS])
> AND t.deleted_at IS NULL
> AND tt.execute_at IS NOT NULL
> AND tt.execute_at <= (CURRENT_DATE - INTERVAL '[TIME_PERIOD]')
> ORDER BY tt.execute_at DESC
> )
>
> SELECT '' AS total, topic_id, closed_at
> FROM topic_list
> UNION
> SELECT ''||COUNT(*), 0, CURRENT_DATE
> FROM topic_list
> ORDER BY closed_at DESC"
>
> results = ActiveRecord::Base.connection.execute(sql)
> user = Discourse.system_user
> archive_category = Category.find([ARCHIVE_CATEGORY_ID])
>
> puts "Found #{results.count} topics to process"
>
> results.each do |row|
> begin
> topic = Topic.find(row["topic_id"])
>
> # 1. Move to archive category
> topic.update!(category_id: archive_category.id)
> puts "#{topic.id} moved to archive category"
>
> # 2. Unlist the topic
> topic.update_status('visible', false, user, until: nil)
> puts "#{topic.id} is unlisted"
>
> # Error Handling
> rescue => e
> puts "Error processing topic #{row["topic_id"]}: #{e.message}"
> end
> end
>
> puts "Process completed"
>
> ```
## Destructive rake tasks
* * *
**Delete entire categories**
The following will allow you to destroy multiple categories, along with any subcategories and topics that belong to those categories.
Print out a list of category IDs
```ruby
rake categories:list
```
Destroy a set of categories based on their ID
```ruby
rake destroy:categories[10,11,12,18,30]
```
**Delete all topics in a category**
> [@Bulk delete all topics in a category](https://meta.discourse.org/t/deleting-all-topics-in-a-category/97904):
>
> bookmark This guide provides instructions on how to bulk delete all topics within a category on a self-hosted Discourse instance. person_raising_hand Required user level: System Administrator warning SSH access to your server is required Removing all topics from a category can be necessary for various reasons, such as reorganizing content or clearing outdated discussions. This guide walks you through the steps to accomplish this task safely on a self-hosted Discourse server. …
**Remove all personal messages**
```ruby
rake destroy:private_messages
```
**Destroy all groups**
```ruby
rake destroy:groups
```
**Destroy all non-admin users**
```ruby
rake destroy:users
```
**Destroy site stats**
```ruby
rake destroy:stats
```
**Anonymize all users except staff**
```ruby
rake users:anonymize_all
```
**Permanently delete a set of posts**
The following rake task will hard-delete a list of posts based on their ID. **If a post is the first post in a topic, all posts in that topic will be hard-deleted.** Before you can successfully run the task, the `can_permanently_delete` site setting must be [enabled](https://meta.discourse.org/t/enable-setting-to-allow-admins-to-permanently-delete-data/206678).
⚠ Once a post is deleted by this task, it will no longer exist in the database and cannot be undeleted.
There are two possible approaches:
- _Option 1_ – Pass a comma-separated list of post IDs as an argument
- _Option 2_ – Specify a text file with a comma-separated list of post IDs (ideal for large sets of posts).
* * *
I’ve tried to include the most useful rake tasks in this topic, but there are many others packaged with Discourse. If you would like to see a comprehensive list, you can use the following:
All tasks that have descriptions
```plaintext
rake --tasks
```
All tasks, including those that do not have descriptions
```plaintext
rake -AT
```
> Last edited by @awesomerobot 2026-06-08T21:53:49Z
>
> > **Check document**
> >
> > Perform check on document:
---
### Author:  [@Ventrilo](https://meta.discourse.org/u/Ventrilo)
#### Post date: [February 9, 2024, 12:52am UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/29 "2024-02-09T00:52:30Z")
@Taylor what about bulk updating all topics with a different timestamp?
Say I wanted all topics on my discourse instance to instantly be changed to show as timestamp as if they was created Today how would I do that?
---
### Author:  [@Firepup650](https://meta.discourse.org/u/Firepup650)
#### Post date: [February 9, 2024, 12:59am UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/30 "2024-02-09T00:59:11Z")
Probably a modification of this query:
> [@tshenry](#):
>
> ## Change owner of all topics in categories
>
> * * *
>
> Find the category IDs with the following rake task:
>
> ```ruby
> rake categories:list
>
> ```
>
> Specify the new owner and categories to operate on. The categories should be an array of category ids, categories `1`, `2` and `3` in the example:
>
> ```ruby
> rails c
> user = User.find_by(username_lower: "lowercase-username")
> categories = [1, 2, 3]
>
> ```
>
> Get all topic ids for the given categories and change the owner of the first post in all matched topics.
>
> ```ruby
> topics = Topic.where(category_id: categories).pluck(:id)
>
> topics.each do |topic|
> PostOwnerChanger.new(
> post_ids: Post.where(topic_id: topic).where(post_number: 1).pluck(:id),
> topic_id: topic,
> new_owner: user,
> acting_user: Discourse.system_user,
> skip_revision: true
> ).change_owner!
> end
>
> ```
(Assuming they’re in one category)
---
### Author:  [@JammyDodger](https://meta.discourse.org/u/JammyDodger)
#### Post date: [June 7, 2024, 9:50pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/31 "2024-06-07T21:50:13Z")
4 posts were split to a new topic: [How to import category with category permissions?](https://meta.discourse.org/t/how-to-import-category-with-category-permissions/311197)
---
### Author:  [@wal](https://meta.discourse.org/u/wal)
#### Post date: [August 14, 2024, 3:55pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/32 "2024-08-14T15:55:01Z")
> [@Discourse](#):
>
> If you want to export the settings to a file:
>
> `rake site_settings:export > saved_settings.yml`
Considering that this command needs to be run inside the Docker container, and the default `pwd` inside the container when running `./launcher enter app` appears to be `/var/www/discourse`, the command described here seems a little odd for a few reasons
- the `site_settings` includes the secret access keys used for S3 and other API’s, it feels like these should not be stored in a file under `/var/www` since that is traditionally the location for files that get served to the web
- since we are inside the container at this default `pwd`, I would expect the file saved here would be lost the container stops?
From inside the container, I used this command `mount | grep ^/dev/ | grep -v /etc/` to determine that the location `/shared` inside the container appears to map back to `/var/discourse/shared/standalone` on the host system. So it seems like maybe the command should be something like this?
```plaintext
cd /var/discourse
./launcher enter app
rake site_settings:export | grep -v key | grep -v secret > /shared/site_settings_$(date "+%Y-%m-%d-%H-%M-%S").yml
```
this would leave the file in a location such as `/var/discourse/shared/standalone/site_settings_2024-08-14-15-53-11.yml` on the host system
note that the extra `grep` commands piped here will remove any lines with the word “key” or “secret” in them in order to remove API keys but would also remove lines that included those words for non-sensitive reasons
does this sound about right?
---
### Author:  [@pfaffman](https://meta.discourse.org/u/pfaffman)
#### Post date: [August 14, 2024, 4:55pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/33 "2024-08-14T16:55:09Z")
> [@wal](#):
>
> these should not be stored in a file under `/var/www` since that is traditionally the location for files that get served to the web
True, but I’m pretty sure that Discourse won’t serve the settings. You can run the command from any directory, and it’s assumed that if you’re doing this kind of stuff you understand what you’re doing.
So you could just
```plaintext
cd /shared/
mkdir -p my-settings
cd my-settings
rake ...
```
before you run the rake task.
Sure the dump has the keys in it, but lots of that is in plaintext in a bunch of places already (e.g., if you follow recommended procedures your S3 keys are in `app.yml`).
> [@wal](#):
>
> does this sound about right?
Yes.
---
### Author:  [@wal](https://meta.discourse.org/u/wal)
#### Post date: [August 19, 2024, 1:12pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/36 "2024-08-19T13:12:57Z")
oh I was not aware that the `rake` tasks would still work outside of the app’s pwd, that makes more sense then yea, thanks
---
### Author:  [@pfaffman](https://meta.discourse.org/u/pfaffman)
#### Post date: [August 19, 2024, 1:15pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/37 "2024-08-19T13:15:20Z")
> [@wal](#):
>
> I was not aware that the `rake` tasks would still work outside of the app’s pwd
It still surprises me!
But also you can put the full path of the dump when you pipe out to a file.
---
### Author:  [@happyhappy](https://meta.discourse.org/u/happyhappy)
#### Post date: [February 25, 2026, 9:41pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/38 "2026-02-25T21:41:12Z")
According to these instructions, I can use
> rake export:groups
to export the set of Groups and import new Groups using the same format. However, when I create a new Group following the exported format, the –trace complains:
> ActiveRecord::RecordInvalid: Validation failed: You cannot allow membership requests for a group without any owners. (ActiveRecord::RecordInvalid)
(I get the same error if I don’t include the user\_ids.)
Here is my import file:
> {“groups”:[{“id”:352,“name”:“NewGroup1”,“created\_at”:“2026-02-18T17:56:01.807Z”,“automatic\_membership\_email\_domains”:“”,“primary\_group”:false,“title”:null,“grant\_trust\_level”:null,“incoming\_email”:null,“bio\_raw”:“This is a NewGroup.”,“allow\_membership\_requests”:true,“full\_name”:“NewGroup1”,“default\_notification\_level”:3,“visibility\_level”:2,“public\_exit”:true,“public\_admission”:false,“membership\_request\_template”:null,“messageable\_level”:3,“mentionable\_level”:3,“members\_visibility\_level”:2,“publish\_read\_state”:false,“user\_ids”:[1,2]}]}
I don’t see any way to indicate which of the users is an owner.
I even added another record of {“group\_users”:[…} to designate an owner, but continue to get the same error.
Does this work? Has anyone imported new Groups successfully and if so, what is the secret?
---
### Author:  [@nathank](https://meta.discourse.org/u/nathank)
#### Post date: [June 9, 2026, 7:19am UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/39 "2026-06-09T07:19:49Z")
> [@happyhappy](#):
>
> “allow\_membership\_requests”:true
A bit late sorry, but this is your problem. If you make that `false` by either editing the group before export or hacking the .json you’ll be away.
The problem is that setting switched on demands that there be an owner to handle the requests.
You can then patch it up as you see fit once migrated.
---
### Author:  [@happyhappy](https://meta.discourse.org/u/happyhappy)
#### Post date: [June 12, 2026, 7:43pm UTC](https://meta.discourse.org/t/administrative-bulk-operations/118349/40 "2026-06-12T19:43:12Z")
That did it! Groups import without error now.
Thank you!