Discord Timestamps

Last updated: Apr 24, 2026View as Markdown

import DiscordTimestampTester from ‘../../../components/DiscordTimestampTester.astro’; import DiscordTimestampPill from ‘../../../components/DiscordTimestampPill.astro’; import DiscordTimezoneComparison from ‘../../../components/DiscordTimezoneComparison.astro’; import DiscordMessage from ‘../../../components/DiscordMessage.astro’; import { Tabs, TabItem, Card, CardGrid, Badge, Steps } from ‘@astrojs/starlight/components’;

Discord Timestamps

Discord timestamps allow you to display dates and times that automatically adapt to each user’s local time zone.

They are particularly useful for international communities, announcements, events, moderation actions, deadlines, meetings, schedules, and any situation where multiple people need to understand the exact same point in time.

What is a Discord timestamp?

A timestamp is a representation of a specific point in time that Discord can automatically convert into a human-readable format.

For example:

<t:1789495200:F>

Discord will render this as a date and time similar to:

Tuesday, September 15, 2026 4:20 PM

Live Discord render:

The important part is that users do not need to manually convert the time.

Discord uses the timestamp to determine the exact point in time and then displays it according to the user’s local settings.

This is particularly useful for communities with members from different countries and time zones.

A practical example

Imagine that you have an international event scheduled for 20:00 UTC.

If you simply write:

🗓️ The event starts at 20:00 UTC.

some users will have to manually convert that time.

Instead, you can use a timestamp:

🗓️ The event starts <t:1789495200:F>.

Each user will see the same moment converted to their local time.

🗓️ The event starts . Everyone sees this in their own local time automatically!

How Discord timestamps work

Discord timestamps are based on a system known as Unix Time, or Unix Timestamp.

Instead of representing a date like this:

September 15, 2026, 4:20 PM

the date is represented using a number:

1789495200

This number identifies a specific point in time.

Discord receives this value and converts it into a human-readable date.

This is why a Discord timestamp follows this structure:

<t:UNIX_TIMESTAMP:FORMAT>

For example:

<t:1789495200:F>

The syntax consists of three main parts:

Part	Purpose
`<t:`	Tells Discord that this is a timestamp
`1789495200`	The Unix timestamp
`:F>`	Determines how the timestamp should be displayed

Understanding the syntax

The complete syntax is:

<t:UNIX_TIMESTAMP:FORMAT>

`<t:`

This indicates the beginning of a Discord timestamp.

<t:

`UNIX_TIMESTAMP`

This is the number representing the exact point in time.

For example:

1789495200

`FORMAT`

This determines how Discord displays the date.

For example:

requests the full date and time format.

`>`

This closes the timestamp expression.

Therefore:

<t:1789495200:F>

is a complete and valid Discord timestamp.

Timestamp formats

Discord supports several formats for displaying the same point in time.

The format is determined by the flag placed after the timestamp.

Flag	Name	Example
`t`	Short time	`4:20 PM`
`T`	Long time	`4:20:30 PM`
`d`	Short date	`09/15/2026`
`D`	Long date	`September 15, 2026`
`f`	Short date and time	`September 15, 2026 4:20 PM`
`F`	Long date and time	`Tuesday, September 15, 2026 4:20 PM`
`R`	Relative time	`in 2 hours`

Note: The exact language, date ordering, and time representation can vary depending on the user’s Discord language and regional settings.

`t` — Short Time

The t format displays only the time.

Syntax

<t:1789495200:t>

Example

4:20 PM

Live Discord pill:

This format is useful when the date is already specified elsewhere.

Example

📅 September 15
⏰ <t:1789495200:t>

📅 September 15
⏰

`T` — Long Time

The T format includes seconds.

Syntax

<t:1789495200:T>

Example

4:20:30 PM

Live Discord pill:

Seconds are generally unnecessary for normal announcements, but this format can be useful for:

synchronized events;
technical processes;
testing;
documentation;
precise schedules;
automated systems.

`d` — Short Date

The d format displays only the date in a compact format.

Syntax

<t:1789495200:d>

Example

09/15/2026

Live Discord pill:

This is useful when you want to keep a message short.

Example

📅 Next review: <t:1789495200:d>

`D` — Long Date

The D format displays the date in a more readable format.

Syntax

<t:1789495200:D>

Example

September 15, 2026

Live Discord pill:

This format is useful for announcements, schedules, and documentation where readability is more important than compactness.

`f` — Short Date and Time

The f format combines the date and time.

Syntax

<t:1789495200:f>

Example

September 15, 2026 4:20 PM

Live Discord pill:

This is one of the most useful formats for:

events;
meetings;
moderation sessions;
deadlines;
announcements;
community activities.

`F` — Long Date and Time

The F format includes the day of the week in addition to the date and time.

Syntax

<t:1789495200:F>

Example

Tuesday, September 15, 2026 4:20 PM

Live Discord pill:

This format is particularly useful when you want the day of the week to be immediately obvious.

For example:

🎉 Our next community event will take place <t:1789495200:F>.

`R` — Relative Time

The R format displays the time relative to the current moment.

Instead of showing a specific date, Discord tells the user how far away the timestamp is.

Syntax

<t:1789495200:R>

Depending on when it is viewed, Discord may display something like:

in 2 hours

or:

5 minutes ago

Live Discord pill:

The displayed value automatically changes as time passes.

Why relative timestamps are useful for moderation

Relative timestamps are particularly useful when communicating:

timeout expiration;
moderation deadlines;
appeal deadlines;
event start times;
maintenance windows;
staff schedules;
temporary restrictions;
review periods.

For example:

⏱️ The timeout expires <t:1789495200:R>.

Instead of forcing the user to calculate the remaining time, Discord handles the calculation automatically.

⏱️ The timeout expires .

Using multiple formats for the same timestamp

A single Unix timestamp can be displayed using any of Discord’s supported formats.

For example:

1789495200

can be used as:

<t:1789495200:t>
<t:1789495200:T>
<t:1789495200:d>
<t:1789495200:D>
<t:1789495200:f>
<t:1789495200:F>
<t:1789495200:R>

Each expression represents the exact same point in time.

Only the presentation changes.

Code	Recommended use
`<t:TIMESTAMP:t>`	Displaying a time
`<t:TIMESTAMP:T>`	Displaying a precise time
`<t:TIMESTAMP:d>`	Compact dates
`<t:TIMESTAMP:D>`	Readable dates
`<t:TIMESTAMP:f>`	Date and time
`<t:TIMESTAMP:F>`	Full date and time
`<t:TIMESTAMP:R>`	Relative countdowns and expiration times

What is a Unix timestamp?

To create a Discord timestamp, you need a Unix timestamp.

Unix time represents a point in time as the number of seconds elapsed since:

January 1, 1970, 00:00:00 UTC

This moment is known as the Unix epoch.

For example:

1789495200

is not a date that is easy for humans to read.

It is a numerical representation of a specific point in time.

Discord converts that number into the appropriate display format.

Why does Discord use Unix timestamps?

Unix timestamps have an important advantage:

the represented point in time is independent of the user’s time zone.

For example, the same moment might be:

4:20 PM in Spain
3:20 PM in the United Kingdom
10:20 AM in New York
7:20 AM in Los Angeles

These are different local representations of the same moment.

The timestamp allows Discord to store and communicate that moment as a single value.

Time zones

One of the biggest advantages of Discord timestamps is that you do not need to create a separate timestamp for every country.

Imagine you are organizing an international meeting.

Instead of writing:

🇪🇸 Spain: 8:00 PM
🇬🇧 United Kingdom: 7:00 PM
🇺🇸 New York: 2:00 PM
🇺🇸 Los Angeles: 11:00 AM

you can use a single timestamp:

<t:1789495200:F>

Each user will see the corresponding local time.

Creating a Discord timestamp

There are several ways to obtain the Unix timestamp required by Discord.

Method 1 — Use a timestamp generator

The easiest method is to use a timestamp generator.

Choose:

The date.
The time.
The appropriate time zone.
The desired display format.

The generator will produce a Discord timestamp that you can copy.

For example:

<t:1789495200:F>

You can then paste the generated code directly into Discord.

Method 2 — Convert a date into Unix time

You can also convert a normal date into a Unix timestamp using a Unix time converter.

For example:

September 15, 2026 — 4:20 PM UTC

could be converted into:

1789495200

You can then wrap the number using Discord’s syntax:

<t:1789495200:F>

Method 3 — Generate timestamps with code

If you are developing a Discord bot or another application, you can generate Unix timestamps programmatically across different programming languages:

```js // Current Unix timestamp (in seconds) const timestamp = Math.floor(Date.now() / 1000); console.log(timestamp);

// Construct a Discord relative timestamp const discordTimestamp = <t:${timestamp}:R>; console.log(discordTimestamp);

  </TabItem>

  <TabItem label="TypeScript" icon="seti:typescript">
```ts
type TimestampFlag = 't' | 'T' | 'd' | 'D' | 'f' | 'F' | 'R';

export function createTimestamp(date: Date = new Date(), flag: TimestampFlag = 'R'): string {
  const epochSeconds = Math.floor(date.getTime() / 1000);
  return `<t:${epochSeconds}:${flag}>`;
}

// In 2 hours:
const future = new Date(Date.now() + 2 * 60 * 60 * 1000);
console.log(createTimestamp(future, 'R')); // <t:...:R>
console.log(createTimestamp(future, 'F')); // <t:...:F>

```js const { EmbedBuilder, time, TimestampStyles } = require('discord.js');

// Using discord.js built-in time() helper: const date = new Date(Date.now() + 3600 * 1000);

const relativeTime = time(date, TimestampStyles.RelativeTime); // <t:timestamp:R> const fullTime = time(date, TimestampStyles.LongDateTime); // <t:timestamp:F>

const embed = new EmbedBuilder() .setTitle(‘🛡️ Moderation Sanction’) .setColor(0xED4245) .setDescription(Timeout expires ${relativeTime} (${fullTime})) .setTimestamp();

await interaction.reply({ embeds: [embed] });

  </TabItem>

  <TabItem label="Python" icon="seti:python">
```python
import time
from datetime import datetime, timedelta

# Current Unix timestamp in seconds
now_epoch = int(time.time())
print(f"Current: <t:{now_epoch}:F>")

# In 2 hours
future_time = datetime.now() + timedelta(hours=2)
future_epoch = int(future_time.timestamp())

discord_code = f"<t:{future_epoch}:R>"
print(f"Sanction expires: {discord_code}")

```python import discord from discord.utils import format_dt from datetime import datetime, timezone, timedelta

Native discord.py helper:

future_date = datetime.now(timezone.utc) + timedelta(days=1)

Format styles: ‘R’ (relative), ‘F’ (long date/time), ‘t’ (short time)

relative_str = format_dt(future_date, style=‘R’) full_str = format_dt(future_date, style=‘F’)

embed = discord.Embed( title=“Appeal Filing Deadline”, description=f“Submit your appeal before {relative_str} ({full_str}).”, color=discord.Color.blue() ) await channel.send(embed=embed)

  </TabItem>

  <TabItem label="Go" icon="seti:go">
```go
package main

import (
  "fmt"
  "time"
)

func main() {
  now := time.Now().Unix()
  fmt.Printf("Current: <t:%d:F>\n", now)

  in2Hours := time.Now().Add(2 * time.Hour).Unix()
  fmt.Printf("Timeout expires: <t:%d:R>\n", in2Hours)
}

```rust use std::time::{SystemTime, UNIX_EPOCH};

fn main() { let now = SystemTime::now() .duration_since(UNIX_EPOCH) .expect(“Time went backwards”) .as_secs();

let future = now + 7200; // +2 hours

println!("Expires: <t:{}:R>", future);
println!("Exact:   <t:{}:F>", future);

}

  </TabItem>

  <TabItem label="C# / .NET" icon="seti:c-sharp">
```csharp
using System;

long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
Console.WriteLine($"Now: <t:{now}:F>");

long expires = DateTimeOffset.UtcNow.AddHours(2).ToUnixTimeSeconds();
Console.WriteLine($"Expires: <t:{expires}:R>");

```php \n";

$timeout = time() + 3600; echo “Timeout expires: <t:{$timeout}:R> (<t:{$timeout}:f>)\n”; ?>

  </TabItem>
</Tabs>

---

# Practical examples for moderators

Discord timestamps are particularly useful in moderation systems.

## Timeout expiration

Instead of:

```text
The timeout ends at 6:30 PM.

you can use:

⏱️ The timeout expires <t:1789495200:R>.

You can also show the exact date:

⏱️ The timeout expires <t:1789495200:F>.

Or combine both:

⏱️ The timeout expires <t:1789495200:R> (<t:1789495200:f>).

This gives the user both:

the remaining time;
the exact date and time.

Appeal deadlines

Timestamps work very well for moderation appeals.

📨 You can submit an appeal until <t:1789495200:F>.

Or:

📨 The appeal deadline is <t:1789495200:R>.

Staff schedules

For example:

🛡️ **Next moderation shift**

Start: <t:1789495200:F>
End: <t:1789506000:F>

Every staff member can interpret the schedule using their own local time.

Community events

🎉 The event starts <t:1789495200:R>!

📅 <t:1789495200:F>

A particularly useful pattern is to display both the relative and absolute times.

Practical examples for administrators

Scheduled maintenance

🔧 Maintenance will begin <t:1789495200:R>.

🕐 Start time: <t:1789495200:F>

Content release

📢 The next update will be released <t:1789495200:R>.

Staff meetings

📋 **Staff meeting**

The meeting begins <t:1789495200:F>.

Please be available a few minutes beforehand.

Combining multiple timestamp formats

You are not limited to using one timestamp in a message.

You can combine several formats to communicate more information.

For example:

🎉 **COMMUNITY EVENT**

📅 <t:1789495200:D>
🕐 <t:1789495200:t>
⏳ <t:1789495200:R>

This could be displayed as:

🎉 COMMUNITY EVENT

📅 September 15, 2026
🕐 4:20 PM
⏳ in 2 hours

This approach can be particularly useful for important announcements.

Which timestamp format should you use?

There is no single format that is correct for every situation.

The best choice depends on the information you are communicating.

Events

Consider:

<t:TIMESTAMP:F>

or:

<t:TIMESTAMP:R>

Deadlines

Use:

<t:TIMESTAMP:R>

You can also include an absolute time underneath.

Moderation actions

A useful combination is:

<t:TIMESTAMP:R>

alongside:

<t:TIMESTAMP:F>

Announcements

Consider:

<t:TIMESTAMP:F>

Quick schedules

Use:

<t:TIMESTAMP:t>

Common mistakes

1. Using a normal date

This:

September 15, 2026 at 4:20 PM

is simply static text.

Discord will not automatically convert it into a dynamic timestamp.

You need:

<t:1789495200:F>

2. Forgetting `<` and `>`

Incorrect:

t:1789495200:F

Correct:

<t:1789495200:F>

3. Using an invalid format flag

For example:

<t:1789495200:X>

does not use one of the standard Discord timestamp formats.

The standard flags are:

t
T
d
D
f
F
R

4. Confusing a local time with an absolute point in time

A timestamp represents an instant, not simply a clock value.

For example:

8:00 PM in Spain

does not necessarily represent the same instant as:

8:00 PM UTC

The time zone must be taken into account when creating the timestamp.

Best practices

Use timestamps for international events

If your community has members from different countries, avoid publishing only static times.

Instead of:

The event starts at 8:00 PM.

use:

The event starts <t:1789495200:F>.

This lets Discord handle the local time conversion.

Use `R` for expiring information

For deadlines and expiration times:

<t:TIMESTAMP:R>

is particularly useful.

For example:

The appeal remains open <t:1789495200:R>.

Use an absolute format when precision matters

For documentation, records, and information that may be referenced later:

<t:TIMESTAMP:F>

is more explicit than a relative timestamp.

For example:

The moderation action was issued on <t:1789495200:F>.

Combine relative and absolute formats when necessary

You do not have to choose between an exact date and a relative countdown.

You can use both:

⏳ Expires <t:1789495200:R>.

📅 Exact time: <t:1789495200:F>

This is especially useful for moderation systems.

Timestamps in bots and embeds

Timestamps are not limited to messages manually written by users.

They can also be used in content generated by bots and applications where Discord processes the timestamp syntax.

For example:

<t:1789495200:R>

can be included in an automated message.

This makes timestamps useful for:

moderation logs;
punishment notifications;
reminders;
automated events;
ticket systems;
deadlines;
audit logs;
administration tools.

<DiscordMessage author=“Carl-bot” bot={true} roleColor=“#5865F2” timestamp=“Today at 16:20” content=“🛡️ Automated Audit Event Record” embed={{ color: “#5865F2”, title: “Member Temporary Restriction”, description: “Automated anti-spam filter triggered in #general.”, fields: [ { name: “Target Member”, value: “@Troublemaker (ID: 4128941029)”, inline: true }, { name: “Action Taken”, value: “Timeout (1 Hour)”, inline: true }, { name: “Trigger Time”, value: “<t:1789495200:f>”, inline: false }, { name: “Expiration”, value: “<t:1789506000:R>”, inline: false } ], footer: “Security System v4.2” }} />

Timestamps in moderation logs

Moderation logs are one of the most useful applications for timestamps.

A moderation log could look like:

👤 User: @Example
🛡️ Moderator: @Moderator
⚠️ Action: Timeout
⏱️ Duration: 1 hour
📅 Started: <t:1789495200:F>
⏳ Expires: <t:1789506000:R>

This allows staff members to understand the event regardless of where they are located.

You can also combine absolute timestamps with relative timestamps:

📅 Started: <t:1789495200:F>
⏳ Remaining: <t:1789506000:R>

Timestamps and localization

Timestamps can significantly reduce problems caused by time zones.

They are particularly valuable for:

international communities;
gaming servers;
esports communities;
distributed moderation teams;
open-source projects;
online events;
educational communities.

A timestamp represents the same moment for everyone.

What changes is how Discord displays that moment to each user.

Do timestamps actually change?

It is important to distinguish between two things.

The point in time represented by the timestamp does not change.

What may change is:

the displayed hour;
the date format;
the language;
the local time zone;
the relative representation.

For example, the same timestamp could appear as:

4:20 PM

for one user and:

10:20 AM

for another.

This does not mean that Discord is using two different times.

Both users are seeing the same instant represented in their respective local time zones.

Daylight saving time

Time zones can change throughout the year because of daylight saving time and other regional rules.

This is another reason why manually maintaining lists of times for different countries can become difficult.

A correctly generated timestamp allows Discord to perform the appropriate local conversion rather than requiring you to manually calculate every time zone.

Quick reference

If you need a quick reference, these are the standard formats:

<t:UNIX_TIMESTAMP:t>
<t:UNIX_TIMESTAMP:T>
<t:UNIX_TIMESTAMP:d>
<t:UNIX_TIMESTAMP:D>
<t:UNIX_TIMESTAMP:f>
<t:UNIX_TIMESTAMP:F>
<t:UNIX_TIMESTAMP:R>

Flag	Description	Typical use
`t`	Short time	Simple schedules
`T`	Long time	Precise times
`d`	Short date	Compact dates
`D`	Long date	Announcements
`f`	Date + time	Events
`F`	Full date + time	Events and meetings
`R`	Relative time	Deadlines and expiration

Copy-and-paste templates

Here are the basic timestamp templates you can reuse:

Short time

<t:UNIX_TIMESTAMP:t>

Long time

<t:UNIX_TIMESTAMP:T>

Short date

<t:UNIX_TIMESTAMP:d>

Long date

<t:UNIX_TIMESTAMP:D>

Short date and time

<t:UNIX_TIMESTAMP:f>

Full date and time

<t:UNIX_TIMESTAMP:F>

Relative time

<t:UNIX_TIMESTAMP:R>

Replace:

UNIX_TIMESTAMP

with the Unix timestamp for the desired point in time.

Complete examples

Event announcement

# 🎉 Community Event

Our next event will take place <t:1789495200:R>.

📅 Date: <t:1789495200:D>
🕐 Time: <t:1789495200:t>

We hope to see you there!

Moderation deadline

⚠️ **Appeal Deadline**

You can submit your appeal until <t:1789495200:R>.

📅 Exact deadline:
<t:1789495200:F>

Timeout

🔇 **Timeout**

Start: <t:1789495200:F>
Expiration: <t:1789506000:R>

Staff meeting

📋 **Staff Meeting**

The meeting begins <t:1789495200:R>.

🗓️ <t:1789495200:F>

Scheduled maintenance

🔧 **Scheduled Maintenance**

Start: <t:1789495200:F>
⏳ <t:1789495200:R>

Recommended templates for moderation teams

If you manage a server with multiple moderators, timestamps can help keep your records consistent.

Instead of having each moderator write dates differently:

09/15 4:20 PM

September 15th, 4:20 PM

15 September — 16:20 UTC

you can establish a consistent format.

For example, use:

<t:TIMESTAMP:F>

for historical records and:

<t:TIMESTAMP:R>

for expiration times.

This makes moderation logs easier to interpret and reduces confusion between staff members in different time zones.

Practical template library

Event

🎉 **Event**

📅 <t:TIMESTAMP:F>
⏳ Starts <t:TIMESTAMP:R>

Deadline

⏰ **Deadline**

The deadline is <t:TIMESTAMP:R>.

Exact date:
<t:TIMESTAMP:F>

Timeout

🔇 **Timeout**

Started: <t:TIMESTAMP:F>
Expires: <t:TIMESTAMP:R>

Meeting

📋 **Staff Meeting**

The meeting starts <t:TIMESTAMP:R>.

🗓️ <t:TIMESTAMP:F>

Maintenance

🔧 **Scheduled Maintenance**

Start: <t:TIMESTAMP:F>
⏳ <t:TIMESTAMP:R>

Checklist

Before publishing a timestamp, check the following:

Frequently Asked Questions

Do Discord timestamps work on every device?

Discord timestamps are a built-in Discord feature and are intended to be rendered dynamically by supported Discord clients.

Do I need a different timestamp for every country?

No.

You should create a timestamp for the specific point in time you want to communicate.

Discord handles the local representation for each user.

Can I use timestamps in bot messages?

Yes.

Bots can send timestamp syntax as part of messages and other supported content.

Can I use timestamps in embeds?

Yes.

Timestamps can be included in bot-generated content where Discord processes the timestamp syntax.

Can I use timestamps in channel names?

You should not assume that every Discord surface processes timestamps in exactly the same way.

Timestamps are primarily intended for message content and other supported contexts.

What is the difference between `f` and `F`?

The main difference is the day of the week.

f displays:

September 15, 2026 4:20 PM

while F displays:

Tuesday, September 15, 2026 4:20 PM

What is the difference between `t` and `T`?

t displays the time without seconds:

4:20 PM

while T includes seconds:

4:20:30 PM

What is the difference between a normal date and a timestamp?

A normal date is static text.

For example:

September 15 at 4:20 PM

A timestamp represents an exact point in time that Discord can dynamically display according to the user’s local settings.

Why should I use `R` instead of manually writing “in 2 hours”?

Because a manually written message does not update.

For example:

The event starts in 2 hours.

will still say “in 2 hours” after 90 minutes.

A relative timestamp:

The event starts <t:1789495200:R>.

updates automatically as time passes.

Advanced moderation examples

Timestamps become particularly powerful when several of them are used together.

Punishment record

🛡️ **Moderation Action**

👤 User: @Example
👮 Moderator: @Moderator

⚠️ Action: Timeout
⏱️ Duration: 24 hours

📅 Issued: <t:1789495200:F>
⏳ Expires: <t:1789581600:R>

Appeal window

📨 **Appeal Information**

Your appeal window is open until <t:1789581600:R>.

📅 Exact deadline:
<t:1789581600:F>

Scheduled staff shift

🛡️ **Moderation Shift**

👤 Staff member: @Moderator

🟢 Start: <t:1789495200:F>
🔴 End: <t:1789506000:F>

⏳ Starts <t:1789495200:R>

Why timestamps are useful for Discord communities

For small communities, timestamps can simply make announcements easier to understand.

For larger communities, they can become part of the server’s infrastructure.

They can help standardize:

event announcements;
moderation logs;
staff schedules;
automated messages;
deadlines;
maintenance windows;
tournament schedules;
community activities;
appeal systems;
ticket systems.

Instead of manually explaining the same date to users in different locations, you can provide one timestamp and let Discord handle the presentation.

Summary

Discord timestamps provide a simple way to communicate an exact point in time while allowing Discord to display it according to each user’s local settings.

The basic syntax is:

<t:UNIX_TIMESTAMP:FORMAT>

The available formats are:

t  → Short time
T  → Long time
d  → Short date
D  → Long date
f  → Date and time
F  → Full date and time
R  → Relative time

The most important concepts to remember are:

The Unix timestamp identifies the exact point in time.
The format flag determines how Discord displays it.
The same timestamp can be shown differently to users in different time zones.
Relative timestamps (R) update automatically as time passes.
Timestamps are especially useful for international communities, events, deadlines, and moderation systems.

If you only remember one thing:

The number represents the moment. The flag determines how Discord displays it.

* `t`: Short time (`4:20 PM`) * `T`: Long time with seconds (`4:20:30 PM`) * **Best for:** Daily schedules, exact coordination. * `d`: Short numeric date (`09/15/2026`) * `D`: Written date (`September 15, 2026`) * **Best for:** Historical logs, official announcements. * `f`: Short date & time (`September 15, 2026 4:20 PM`) * `F`: Full date with weekday (`Tuesday, September 15, 2026 4:20 PM`) * **Best for:** Events, meetings, town halls. * `R`: Dynamic countdown (`in 2 hours` / `5 minutes ago`) * Updates dynamically in the client without refresh. * **Best for:** Timeouts, appeal deadlines, urgency.

Resources

Compare AutoMod, Wick, Carl-bot, and Dyno for automated sanction enforcement and timestamp generation.

[Read Bot Guide →](/tools/moderation-bots/)

Master cryptographic event IDs, message caches, and cross-referencing staff action trails.

[Inspect Audit Logs Guide →](/tools/audit-logs/)

Pre-configured disciplinary templates, ban appeal responses, and staff handover scripts.

[Browse Templates Library →](/tools/templates-and-macros/)

Browser utility for copying member IDs, calculating timestamps, and formatting tickets on the fly.

[Explore Mod Helper →](/tools/mod-helper/)

Discord Timestamps

Discord Timestamps

What is a Discord timestamp?

A practical example

How Discord timestamps work

Understanding the syntax

<t:

UNIX_TIMESTAMP

FORMAT

>

Timestamp formats

t — Short Time

Syntax

Example

Example

T — Long Time

Syntax

Example

d — Short Date

Syntax

Example

Example

D — Long Date

Syntax

Example

f — Short Date and Time

Syntax

Example

F — Long Date and Time

Syntax

Example

R — Relative Time

Syntax

Why relative timestamps are useful for moderation

Using multiple formats for the same timestamp

What is a Unix timestamp?

Why does Discord use Unix timestamps?

Time zones

Creating a Discord timestamp

Method 1 — Use a timestamp generator

Method 2 — Convert a date into Unix time

Method 3 — Generate timestamps with code

Native discord.py helper:

Format styles: ‘R’ (relative), ‘F’ (long date/time), ‘t’ (short time)

Appeal deadlines

Staff schedules

Community events

Practical examples for administrators

Scheduled maintenance

Content release

Staff meetings

Combining multiple timestamp formats

Which timestamp format should you use?

Events

Deadlines

Moderation actions

Announcements

Quick schedules

Common mistakes

1. Using a normal date

2. Forgetting < and >

3. Using an invalid format flag

4. Confusing a local time with an absolute point in time

Best practices

Use timestamps for international events

Use R for expiring information

Use an absolute format when precision matters

Combine relative and absolute formats when necessary

Timestamps in bots and embeds

Timestamps in moderation logs

Timestamps and localization

Do timestamps actually change?

Daylight saving time

Quick reference

Copy-and-paste templates

Short time

Long time

Short date

Long date

Short date and time

`<t:`

`UNIX_TIMESTAMP`

`FORMAT`

`>`

`t` — Short Time

`T` — Long Time

`d` — Short Date

`D` — Long Date

`f` — Short Date and Time

`F` — Long Date and Time

`R` — Relative Time

2. Forgetting `<` and `>`

Use `R` for expiring information

What is the difference between `f` and `F`?

What is the difference between `t` and `T`?

Why should I use `R` instead of manually writing “in 2 hours”?