Setiap pelanggan tidak lahir setara. Sebagian membeli setiap minggu, sebagian baru sekali lalu hilang, dan sebagian lagi sudah lama tidak kembali padahal dulu rajin berbelanja. Jika semua diperlakukan sama, strategi marketing Anda membuang waktu dan budget. Di sinilah RFM analysis hadir — sebuah metode sederhana namun sangat ampuh untuk mengelompokkan pelanggan berdasarkan perilaku transaksinya.

Kabar baiknya, RFM tidak butuh machine learning yang rumit. Cukup memanfaatkan SQL untuk menghitung dan memberi skor, lalu Python untuk validasi dan analisis lanjutan. Artikel ini akan menuntun Anda selangkah demi selangkah, dari data mentah transaksi hingga segmen pelanggan yang siap dieksekusi tim marketing.

🎯 Apa Itu RFM Analysis?

RFM analysis adalah teknik segmentasi pelanggan berdasarkan tiga dimensi perilaku transaksi: Recency, Frequency, dan Monetary. Konsep ini sederhana: pelanggan yang baru belanja, sering belanja, dan menghabiskan banyak uang cenderung menjadi pelanggan terbaik dan paling loyal.

Kekuatan RFM terletak pada kesederhanaannya. Ia tidak memerlukan data demografis, survei kepuasan, atau fitur rumit — cukup data transaksi yang hampir semua bisnis sudah miliki. Anda bisa langsung menerapkan metode ini pada tabel orders/transaksi yang ada di database Anda.

Tiga Komponen Inti RFM

Perhatikan satu hal penting: pada dimensi Recency, nilai yang lebih kecil justru lebih baik karena berarti pelanggan baru saja bertransaksi. Berbeda dengan Frequency dan Monetary yang nilainya lebih besar lebih baik. Perbedaan arah ini harus diperhitungkan saat memberi skor nanti.

⚙️ Alur Kerja RFM dalam 5 Langkah

1. Hitung R, F, M per pelanggan — agregasi dari tabel transaksi menggunakan SQL.
2. Bagi tiap komponen menjadi 5 kelas — gunakan kuartil atau fungsi NTILE agar setiap komponen memiliki skala 1–5.
3. Beri skor 1–5 — pada Recency 5 berarti paling baru, pada Frequency dan Monetary 5 berarti paling tinggi.
4. Gabung ketiga skor — kombinasi R, F, M membentuk “RFM cell” (misal 555, 511, 311).
5. Petakan ke segmen — terjemahkan tiap cell menjadi segmen bernama seperti Champions, Loyal, atau At Risk.

🗄️ Langkah 1: Siapkan Data Transaksi (SQL)

Semua dimulai dari tabel transaksi. Untuk contoh, kita gunakan tabel transactions yang menyimpan setiap order. Berikut struktur DDL-nya:

CREATE TABLE transactions (
    transaction_id INT PRIMARY KEY,
    customer_id    INT,
    order_date     DATE,
    amount         DECIMAL(10,2)
);

Dan beberapa baris data contoh:

INSERT INTO transactions VALUES
(1001, 501, '2026-08-10', 250000),
(1002, 502, '2026-07-20', 120000),
(1003, 501, '2026-07-05', 300000),
(1004, 503, '2026-06-15', 50000),
(1005, 502, '2026-05-30', 180000),
(1006, 501, '2026-05-10', 90000),
(1007, 504, '2026-08-12', 500000),
(1008, 503, '2026-04-20', 75000);

🧮 Langkah 2–3: Hitung R, F, M dan Beri Skor (SQL)

Pertama, kita hitung Recency, Frequency, dan Monetary untuk setiap pelanggan. Recency dihitung sebagai selisih hari antara tanggal terakhir transaksi dan tanggal acuan (misal tanggal hari ini atau tanggal maksimum di data).

WITH rfm_raw AS (
    SELECT
        customer_id,
        DATEDIFF(CURRENT_DATE, MAX(order_date)) AS recency,
        COUNT(*)                                AS frequency,
        SUM(amount)                             AS monetary
    FROM transactions
    GROUP BY customer_id
)
SELECT * FROM rfm_raw
ORDER BY customer_id;

Hasilnya terlihat seperti tabel di bawah ini (untuk memudahkan, kita gunakan tanggal acuan 2026-08-15):

Selanjutnya, kita ubah masing-masing komponen menjadi skor 1–5. Cara paling populer adalah fungsi window NTILE(5) yang membagi data menjadi 5 kelompok sama besar berdasarkan urutan nilai.

Ingat arah skornya: untuk Recency, nilai terkecil (paling baru) mendapat skor 5, sehingga kita urutkan ORDER BY recency ASC — artinya kelompok terbaru mendapat skor 5. Untuk Frequency dan Monetary, nilai terbesar mendapat skor 5, sehingga urutannya ORDER BY frequency DESC dan ORDER BY monetary DESC.

WITH rfm_raw AS (
    SELECT
        customer_id,
        DATEDIFF(CURRENT_DATE, MAX(order_date)) AS recency,
        COUNT(*)                                AS frequency,
        SUM(amount)                             AS monetary
    FROM transactions
    GROUP BY customer_id
),
rfm_score AS (
    SELECT
        customer_id,
        recency, frequency, monetary,
        NTILE(5) OVER (ORDER BY recency ASC)   AS r_score,
        NTILE(5) OVER (ORDER BY frequency DESC) AS f_score,
        NTILE(5) OVER (ORDER BY monetary DESC)  AS m_score
    FROM rfm_raw
)
SELECT * FROM rfm_score
ORDER BY r_score DESC, f_score DESC, m_score DESC;

🏷️ Langkah 4–5: Gabung Skor Menjadi Segmen (SQL)

Setelah setiap pelanggan memiliki skor R, F, dan M, kita bisa menggabungkannya menjadi “RFM cell” seperti 555, 533, atau 311. Selanjutnya, kita petakan kombinasi tersebut menjadi segmen yang mudah dimengerti tim marketing menggunakan pernyataan CASE WHEN.

WITH rfm_raw AS (
    SELECT
        customer_id,
        DATEDIFF(CURRENT_DATE, MAX(order_date)) AS recency,
        COUNT(*)                                AS frequency,
        SUM(amount)                             AS monetary
    FROM transactions
    GROUP BY customer_id
),
rfm_score AS (
    SELECT
        customer_id,
        recency, frequency, monetary,
        NTILE(5) OVER (ORDER BY recency ASC)    AS r_score,
        NTILE(5) OVER (ORDER BY frequency DESC) AS f_score,
        NTILE(5) OVER (ORDER BY monetary DESC)  AS m_score
    FROM rfm_raw
)
SELECT
    customer_id,
    CONCAT(r_score, f_score, m_score) AS rfm_cell,
    CASE
        WHEN r_score = 5 AND f_score = 5 THEN 'Champions'
        WHEN r_score = 4 AND f_score = 5 THEN 'Loyal Customers'
        WHEN r_score >= 4 AND f_score >= 4 THEN 'Potential Loyalist'
        WHEN r_score = 5 AND f_score <= 2 THEN 'New Customers'
        WHEN r_score >= 3 AND f_score >= 3 THEN 'Need Attention'
        WHEN r_score <= 2 AND f_score >= 3 THEN 'At Risk'
        WHEN r_score <= 2 AND f_score = 1 THEN 'Hibernating'
        WHEN r_score = 1 THEN 'Lost'
        ELSE 'Promising'
    END AS segment
FROM rfm_score
ORDER BY r_score DESC, f_score DESC;

Perhatikan bahwa logika segmentasi di atas bersifat heuristik — bukan aturan baku. Anda bebas menyesuaikan ambang batas sesuai karakter bisnis. Skor r_score=5 dan f_score=5 jelas termasuk Champions, sedangkan r_score rendah menandakan pelanggan yang berisiko hilang.

🐍 Validasi & Analisis Lanjut dengan Python

SQL sudah menghasilkan segmen. Namun kadang Anda butuh analisis lebih dalam — distribusi skor, breakpoint kuartil yang jelas, hingga visualisasi. Di sinilah Python dengan pandas dan seaborn berperan, melanjutkan seri analisis SQL + Python kami.

Daripada menghitung agregasi di SQL lalu menyalin hasilnya manual, kita bisa menarik data mentah dari database, lalu menghitung RFM sepenuhnya di Python. Ini memberi kita kendali penuh atas cara menentukan breakpoint.

import pandas as pd

df = pd.read_sql_query(
    "SELECT customer_id, order_date, amount FROM transactions",
    conn
)

# Acuan: tanggal maksimum di data
ref_date = df['order_date'].max()

rfm = df.groupby('customer_id').agg(
    recency  = ('order_date', lambda d: (ref_date - d.max()).days),
    frequency= ('customer_id', 'count'),
    monetary = ('amount', 'sum')
).reset_index()

# Beri skor 1-5 berbasis kuartil
rfm['R'] = pd.qcut(rfm['recency'], 5, labels=[5,4,3,2,1])
rfm['F'] = pd.qcut(rfm['frequency'].rank(method='first'), 5, labels=[1,2,3,4,5])
rfm['M'] = pd.qcut(rfm['monetary'].rank(method='first'), 5, labels=[1,2,3,4,5])

print(rfm.sort_values('recency'))

Pada Recency, kita balik labelnya ([5,4,3,2,1]) karena nilai terbaru (recency kecil) harus mendapat skor tinggi. Sementara pada Frequency dan Monetary label berjalan normal karena nilai besar mendapat skor tinggi.

Setelah mendapatkan skor, Anda bisa memetakan kombinasi skor ke segmen menggunakan fungsi kecil, lalu memvisualisasikan distribusinya:

import seaborn as sns

def map_segment(r):
    if r['R'] == 5 and r['F'] == 5: return 'Champions'
    if r['R'] == 4 and r['F'] == 5: return 'Loyal Customers'
    if r['R'] >= 3 and r['F'] >= 3: return 'Need Attention'
    if r['R'] <= 2 and r['F'] >= 3: return 'At Risk'
    if r['R'] == 1:                 return 'Lost'
    return 'Others'

rfm['segment'] = rfm.apply(map_segment, axis=1)
sns.countplot(data=rfm, x='segment', order=rfm['segment'].value_counts().index)

📊 Ringkasan Segmen dan Aksi Bisnis

Segmen hanyalah kelompok — yang bermanfaat adalah aksi yang Anda ambil untuk tiap kelompok. Berikut ringkasan umum:

🎯 Kesimpulan

RFM analysis adalah alat segmentasi yang sederhana namun berdampak besar. Dengan tiga angka — Recency, Frequency, dan Monetary — Anda bisa membagi seluruh basis pelanggan menjadi kelompok yang bernilai berbeda, lalu memperlakukan masing-masing sesuai nilainya.

Kombinasi SQL dan Python menjadikan proses ini tangguh: SQL menangani komputasi dan pipelining langsung di database, sementara Python memberi fleksibilitas untuk eksplorasi dan validasi. Mulailah dari data transaksi yang sudah Anda miliki, dan Anda akan segera melihat pelanggan mana yang layak dipertahankan, dimanjakan, atau bahkan dilepas.

❓ FAQ: RFM Analysis

Apa arti singkatan RFM?

RFM adalah singkatan dari Recency (berapa baru pelanggan bertransaksi), Frequency (berapa sering bertransaksi), dan Monetary (berapa besar total nilai transaksinya). Ketiga dimensi ini menjadi dasar untuk mengelompokkan pelanggan.

Kapan sebaiknya RFM analysis digunakan?

RFM cocok untuk bisnis yang memiliki data transaksi berulang, seperti e-commerce, retail, dan layanan berlangganan. Metode ini kurang cocok untuk bisnis one-time purchase seperti menjual rumah atau kendaraan yang jarang dibeli ulang.

Apakah RFM butuh machine learning?

Tidak. RFM adalah metode berbasis aturan yang hanya butuh agregasi dan pengelompokan skor. Namun hasil segmen RFM sering digunakan sebagai fitur atau label untuk model machine learning lanjutan, misalnya prediksi churn.

Berapa banyak segmen yang ideal?

Tergantung kebutuhan. Dengan skor 1–5 ada hingga 125 kombinasi cell, tetapi kebanyakan bisnis memetakannya menjadi 5–11 segmen bernama agar mudah dieksekusi. Terlalu sedikit segmen terlalu kasar, terlalu banyak justru membingungkan tim marketing.

Apa bedanya RFM dengan clustering seperti K-Means?

RFM adalah metode berbasis aturan yang deterministik dan mudah dijelaskan, sedangkan clustering (misal K-Means) berbasis jarak yang otomatis mencari kelompok dalam data. RFM lebih transparan dan mudah diinterpretasikan, sementara clustering bisa menangkap pola yang lebih kompleks.

Dibuat oleh:

Eduardus Defino Ananda Hutama