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.

:::tip[In Short]
Instead of writing static text like `September 15 at 8:00 PM`, use a dynamic timestamp that Discord automatically displays according to each user's local time zone.
:::

<DiscordTimezoneComparison timestamp={1789495200} format="F" />

---

## 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:

```text
<t:1789495200:F>
```

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

> Tuesday, September 15, 2026 4:20 PM

**Live Discord render:** <DiscordTimestampPill timestamp={1789495200} format="F" />

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:

```text
🗓️ The event starts at 20:00 UTC.
```

some users will have to manually convert that time.

Instead, you can use a timestamp:

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

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

<DiscordMessage author="Community Event Coordinator" roleColor="#F6821F" timestamp="Today at 12:00">
  <div class="discord-body">
    🗓️ The event starts <DiscordTimestampPill timestamp={1789495200} format="F" />. Everyone sees this in their own local time automatically!
  </div>
</DiscordMessage>

---

# 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:

```text
September 15, 2026, 4:20 PM
```

the date is represented using a number:

```text
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:

```text
<t:UNIX_TIMESTAMP:FORMAT>
```

For example:

```text
<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:

```text
<t:UNIX_TIMESTAMP:FORMAT>
```

### `<t:`

This indicates the beginning of a Discord timestamp.

```text
<t:
```

### `UNIX_TIMESTAMP`

This is the number representing the exact point in time.

For example:

```text
1789495200
```

### `FORMAT`

This determines how Discord displays the date.

For example:

```text
F
```

requests the full date and time format.

### `>`

This closes the timestamp expression.

Therefore:

```text
<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

```text
<t:1789495200:t>
```

### Example

```text
4:20 PM
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="t" />

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

### Example

```text
📅 September 15
⏰ <t:1789495200:t>
```

<DiscordMessage author="Events Lead" timestamp="Today at 14:00">
  <div class="discord-body">
    📅 September 15<br />
    ⏰ <DiscordTimestampPill timestamp={1789495200} format="t" />
  </div>
</DiscordMessage>

---

## `T` — Long Time

The `T` format includes seconds.

### Syntax

```text
<t:1789495200:T>
```

### Example

```text
4:20:30 PM
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="T" />

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

```text
<t:1789495200:d>
```

### Example

```text
09/15/2026
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="d" />

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

### Example

```text
📅 Next review: <t:1789495200:d>
```

---

## `D` — Long Date

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

### Syntax

```text
<t:1789495200:D>
```

### Example

```text
September 15, 2026
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="D" />

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

```text
<t:1789495200:f>
```

### Example

```text
September 15, 2026 4:20 PM
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="f" />

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

```text
<t:1789495200:F>
```

### Example

```text
Tuesday, September 15, 2026 4:20 PM
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="F" />

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

For example:

```text
🎉 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

```text
<t:1789495200:R>
```

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

```text
in 2 hours
```

or:

```text
5 minutes ago
```

**Live Discord pill:** <DiscordTimestampPill timestamp={1789495200} format="R" />

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:

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

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

<DiscordMessage author="Security Bot" bot={true} roleColor="#5865F2" timestamp="Today at 15:30">
  <div class="discord-body">
    ⏱️ The timeout expires <DiscordTimestampPill timestamp={1789495200} format="R" />.
  </div>
</DiscordMessage>

---

# Using multiple formats for the same timestamp

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

For example:

```text
1789495200
```

can be used as:

```text
<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:

```text
January 1, 1970, 00:00:00 UTC
```

This moment is known as the **Unix epoch**.

For example:

```text
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:

```text
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:

```text
🇪🇸 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:

```text
<t:1789495200:F>
```

Each user will see the corresponding local time.

<DiscordTimezoneComparison timestamp={1789495200} format="F" />

---

# 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:

1. The date.
2. The time.
3. The appropriate time zone.
4. The desired display format.

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

<div style="margin: 1.5rem 0;">
  <DiscordTimestampTester />
</div>

For example:

```text
<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:

```text
September 15, 2026 — 4:20 PM UTC
```

could be converted into:

```text
1789495200
```

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

```text
<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:

<Tabs syncKey="programming-lang">
  <TabItem label="JavaScript" icon="seti:javascript">
```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>
```
  </TabItem>

  <TabItem label="Discord.js (v14)" icon="discord">
```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}")
```
  </TabItem>

  <TabItem label="discord.py" icon="discord">
```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)
}
```
  </TabItem>

  <TabItem label="Rust" icon="seti:rust">
```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>");
```
  </TabItem>

  <TabItem label="PHP" icon="seti:php">
```php
<?php
$now = time();
echo "Current: <t:{$now}:F>\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:

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

You can also show the exact date:

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

Or combine both:

```text
⏱️ 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.

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

Or:

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

---

## Staff schedules

For example:

```text
🛡️ **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

```text
🎉 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

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

🕐 Start time: <t:1789495200:F>
```

## Content release

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

## Staff meetings

```text
📋 **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:

```text
🎉 **COMMUNITY EVENT**

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

This could be displayed as:

```text
🎉 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:

```text
<t:TIMESTAMP:F>
```

or:

```text
<t:TIMESTAMP:R>
```

## Deadlines

Use:

```text
<t:TIMESTAMP:R>
```

You can also include an absolute time underneath.

## Moderation actions

A useful combination is:

```text
<t:TIMESTAMP:R>
```

alongside:

```text
<t:TIMESTAMP:F>
```

## Announcements

Consider:

```text
<t:TIMESTAMP:F>
```

## Quick schedules

Use:

```text
<t:TIMESTAMP:t>
```

---

# Common mistakes

## 1. Using a normal date

This:

```text
September 15, 2026 at 4:20 PM
```

is simply static text.

Discord will not automatically convert it into a dynamic timestamp.

You need:

```text
<t:1789495200:F>
```

---

## 2. Forgetting `<` and `>`

Incorrect:

```text
t:1789495200:F
```

Correct:

```text
<t:1789495200:F>
```

---

## 3. Using an invalid format flag

For example:

```text
<t:1789495200:X>
```

does not use one of the standard Discord timestamp formats.

The standard flags are:

```text
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:

```text
8:00 PM in Spain
```

does not necessarily represent the same instant as:

```text
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:

```text
The event starts at 8:00 PM.
```

use:

```text
The event starts <t:1789495200:F>.
```

This lets Discord handle the local time conversion.

---

## Use `R` for expiring information

For deadlines and expiration times:

```text
<t:TIMESTAMP:R>
```

is particularly useful.

For example:

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

---

## Use an absolute format when precision matters

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

```text
<t:TIMESTAMP:F>
```

is more explicit than a relative timestamp.

For example:

```text
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:

```text
⏳ 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:

```text
<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:

```text
👤 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:

```text
📅 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:

```text
4:20 PM
```

for one user and:

```text
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:

```text
<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

```text
<t:UNIX_TIMESTAMP:t>
```

### Long time

```text
<t:UNIX_TIMESTAMP:T>
```

### Short date

```text
<t:UNIX_TIMESTAMP:d>
```

### Long date

```text
<t:UNIX_TIMESTAMP:D>
```

### Short date and time

```text
<t:UNIX_TIMESTAMP:f>
```

### Full date and time

```text
<t:UNIX_TIMESTAMP:F>
```

### Relative time

```text
<t:UNIX_TIMESTAMP:R>
```

Replace:

```text
UNIX_TIMESTAMP
```

with the Unix timestamp for the desired point in time.

---

# Complete examples

## Event announcement

```text
# 🎉 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

```text
⚠️ **Appeal Deadline**

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

📅 Exact deadline:
<t:1789495200:F>
```

---

## Timeout

```text
🔇 **Timeout**

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

---

## Staff meeting

```text
📋 **Staff Meeting**

The meeting begins <t:1789495200:R>.

🗓️ <t:1789495200:F>
```

---

## Scheduled maintenance

```text
🔧 **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:

```text
09/15 4:20 PM
```

```text
September 15th, 4:20 PM
```

```text
15 September — 16:20 UTC
```

you can establish a consistent format.

For example, use:

```text
<t:TIMESTAMP:F>
```

for historical records and:

```text
<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

```text
🎉 **Event**

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

## Deadline

```text
⏰ **Deadline**

The deadline is <t:TIMESTAMP:R>.

Exact date:
<t:TIMESTAMP:F>
```

## Timeout

```text
🔇 **Timeout**

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

## Meeting

```text
📋 **Staff Meeting**

The meeting starts <t:TIMESTAMP:R>.

🗓️ <t:TIMESTAMP:F>
```

## Maintenance

```text
🔧 **Scheduled Maintenance**

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

---

# Checklist

Before publishing a timestamp, check the following:

* [ ] Is the date correct?
* [ ] Is the time correct?
* [ ] Is the time zone correct?
* [ ] Did you use the correct Unix timestamp?
* [ ] Did you include `<` and `>`?
* [ ] Did you use a valid format flag?
* [ ] Is the selected format appropriate for the context?
* [ ] Would showing the exact date be useful?
* [ ] Is this a deadline or expiration time? If so, consider using `R`.
* [ ] Will users from different time zones need to understand the same moment?

---

# 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:

```text
September 15, 2026 4:20 PM
```

while `F` displays:

```text
Tuesday, September 15, 2026 4:20 PM
```

---

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

`t` displays the time without seconds:

```text
4:20 PM
```

while `T` includes seconds:

```text
4:20:30 PM
```

---

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

A normal date is static text.

For example:

```text
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:

```text
The event starts in 2 hours.
```

will still say "in 2 hours" after 90 minutes.

A relative timestamp:

```text
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

```text
🛡️ **Moderation Action**

👤 User: @Example
👮 Moderator: @Moderator

⚠️ Action: Timeout
⏱️ Duration: 24 hours

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

---

## Appeal window

```text
📨 **Appeal Information**

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

📅 Exact deadline:
<t:1789581600:F>
```

---

## Scheduled staff shift

```text
🛡️ **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:

```text
<t:UNIX_TIMESTAMP:FORMAT>
```

The available formats are:

```text
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:

1. **The Unix timestamp identifies the exact point in time.**
2. **The format flag determines how Discord displays it.**
3. **The same timestamp can be shown differently to users in different time zones.**
4. **Relative timestamps (`R`) update automatically as time passes.**
5. **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.**

<CardGrid>
  <Card title="t & T (Times)" icon="open-book">
    * `t`: Short time (`4:20 PM`)
    * `T`: Long time with seconds (`4:20:30 PM`)
    * **Best for:** Daily schedules, exact coordination.
  </Card>
  <Card title="d & D (Dates)" icon="document">
    * `d`: Short numeric date (`09/15/2026`)
    * `D`: Written date (`September 15, 2026`)
    * **Best for:** Historical logs, official announcements.
  </Card>
  <Card title="f & F (Date + Time)" icon="star">
    * `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.
  </Card>
  <Card title="R (Relative)" icon="rocket">
    * `R`: Dynamic countdown (`in 2 hours` / `5 minutes ago`)
    * Updates dynamically in the client without refresh.
    * **Best for:** Timeouts, appeal deadlines, urgency.
  </Card>
</CardGrid>

---

# Resources

* [Discord Support](https://support.discord.com/)
* [Discord Developer Documentation](https://discord.com/developers/docs/)
* [Unix Time](https://en.wikipedia.org/wiki/Unix_time)

### Related Documentation

<CardGrid>
  <Card title="Essential Moderation Bots" icon="laptop">
    Compare AutoMod, Wick, Carl-bot, and Dyno for automated sanction enforcement and timestamp generation.
    
    [Read Bot Guide →](/tools/moderation-bots/)
  </Card>

  <Card title="Audit Logs & Forensic Investigation" icon="magnifier">
    Master cryptographic event IDs, message caches, and cross-referencing staff action trails.
    
    [Inspect Audit Logs Guide →](/tools/audit-logs/)
  </Card>

  <Card title="Standardized Macros & Modmail" icon="pencil">
    Pre-configured disciplinary templates, ban appeal responses, and staff handover scripts.
    
    [Browse Templates Library →](/tools/templates-and-macros/)
  </Card>

  <Card title="Local Mod Helper Extension" icon="setting">
    Browser utility for copying member IDs, calculating timestamps, and formatting tickets on the fly.
    
    [Explore Mod Helper →](/tools/mod-helper/)
  </Card>
</CardGrid>