> ## Documentation Index
> Fetch the complete documentation index at: https://docs.dodopayments.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Customer Blocklist

> किसी ग्राहक को ब्लॉक करके भविष्य के checkouts रोकें, उनकी live subscriptions रद्द करें और उनके Customer Portal को केवल-पठन योग्य बनाएं। Settings या API से blocklist प्रबंधित करें।

<Info>
  Customer Blocklist किसी ज्ञात धोखाधड़ी करने वाले व्यक्ति को आपसे दोबारा खरीदारी करने से रोकती है। ब्लॉक किया गया ग्राहक भुगतान नहीं कर सकता, उसकी live subscriptions समाप्त हो जाती हैं और वह [Customer Portal](/features/customer-portal) में चीज़ें देख तो सकता है, लेकिन उनमें बदलाव नहीं कर सकता। इसे **Settings → Blocklist** से या Blocklist API के माध्यम से प्रबंधित करें।
</Info>

<Frame caption="The Blocklist tab under Settings">
  <img src="https://mintcdn.com/dodopayments/c1t35qHSH45TR4GO/images/blocklist/blocklist-settings.png?fit=max&auto=format&n=c1t35qHSH45TR4GO&q=85&s=771eb4a5654fbd22e6a5110cfb1a2e9d" alt="Blocklist settings page showing the total number of blocked customers, a table of blocked entries with identifier, blocked by, and blocked on columns, and an Add to Blocklist button" style={{ maxHeight: '500px', width: 'auto' }} width="2358" height="1554" data-path="images/blocklist/blocklist-settings.png" />
</Frame>

## ग्राहक को ब्लॉक करने पर क्या होता है

| क्षेत्र                  | प्रभाव                                                                                                                                                                                                                                              |
| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Checkout**             | ब्लॉक किए गए email से किया गया हर payment attempt अस्वीकार कर दिया जाता है: payment links, checkout sessions और API के माध्यम से बनाए गए payments या subscriptions।                                                                                 |
| **Live subscriptions**   | `pending`, `active`, `on_hold` या `paused` status वाली subscriptions को `cancelled_by_merchant` कारण के साथ cancel कर दिया जाता है। प्रत्येक के लिए सामान्य `subscription.cancelled` webhook सक्रिय होता है।                                        |
| **Renewals and retries** | Automatic renewals और [payment retries](/features/recovery/payment-retries) ब्लॉक किए गए ग्राहक को छोड़ देते हैं, इसलिए cancellation अभी pending होने पर भी कोई अतिरिक्त charge नहीं लिया जाता।                                                     |
| **Manual retry**         | ब्लॉक किए गए ग्राहक के payment का [manual retry](/features/recovery/manual-retry) अस्वीकार कर दिया जाता है।                                                                                                                                         |
| **Customer Portal**      | ग्राहक अब भी log in करके invoices, subscriptions और license keys देख सकता है, लेकिन subscription cancel, pause या resume नहीं कर सकता, plans बदल नहीं सकता और payment method update नहीं कर सकता। Saved payment method हटाने की अनुमति बनी रहती है। |

<Note>
  ब्लॉक करने से पिछले payments का refund नहीं होता और open disputes पर भी इसका कोई प्रभाव नहीं पड़ता। कोई भी refund [Refunds](/features/transactions/refunds) page से अलग से जारी करें।
</Note>

## Customers का मिलान कैसे किया जाता है

आप **customer ID** या **email** के आधार पर ब्लॉक कर सकते हैं। दोनों ही स्थितियों में block ग्राहक record पर नहीं, बल्कि ग्राहक के email पर आधारित होता है:

* **उस email वाले हर record पर लागू होता है।** लौटने वाले email के लिए Checkout नया customer record बना सकता है, इसलिए केवल एक customer ID पर लगाया गया block bypass किया जा सकता है। Email पर लगाया गया block bypass नहीं किया जा सकता।
* **Aliases भी शामिल होते हैं।** Emails की तुलना lowercase में की जाती है और `+alias` हटाया जाता है, इसलिए `buyer+promo@example.com` और `Buyer@example.com` को एक ही ग्राहक माना जाता है। Address में मौजूद dots वैसे ही रखे जाते हैं।
* **आपके business तक सीमित।** Block केवल आपके business पर लागू होता है। वही email Dodo Payments पर अन्य businesses से अब भी खरीदारी कर सकता है।
* **Email किसी मौजूदा ग्राहक का होना चाहिए।** आप ऐसे email को ब्लॉक नहीं कर सकते जिसने कभी आपके साथ checkout नहीं किया हो, और बिना email वाले customer record को ब्लॉक नहीं किया जा सकता।

## ग्राहक को ब्लॉक करना

<Tabs>
  <Tab title="From Settings">
    <Steps>
      <Step title="Open the Blocklist">
        अपने dashboard में **Settings → Blocklist** पर जाएं।
      </Step>

      <Step title="Add to Blocklist">
        **Add to Blocklist** पर click करें, फिर ग्राहक का email या customer ID दर्ज करें। एक reason जोड़ें ताकि आपकी team बाद में देख सके कि block क्यों जोड़ा गया था।
      </Step>

      <Step title="Confirm">
        Block की पुष्टि करें। ग्राहक की live subscriptions तुरंत cancel हो जाती हैं और entry **Blocked entries** table में दिखाई देती है।
      </Step>
    </Steps>
  </Tab>

  <Tab title="From the customer's page">
    <Steps>
      <Step title="Open the customer">
        **Sales → Customers** पर जाएं और उस ग्राहक को खोलें जिसे आप ब्लॉक करना चाहते हैं।
      </Step>

      <Step title="Block the customer">
        **Block Customer** पर click करें। Block लागू होने के बाद page ग्राहक के नाम के आगे **Blocked** badge दिखाता है।
      </Step>
    </Steps>
  </Tab>
</Tabs>

## ब्लॉक किए गए ग्राहकों को प्रबंधित करना

**Blocklist** page हर active block की सूची दिखाता है:

* **Total Customers Blocked**: वर्तमान में ब्लॉक किए गए ग्राहकों की संख्या।
* **Blocked entries**: प्रत्येक block के लिए एक row, जिसमें आपके द्वारा दर्ज किया गया **Identifier** (email या customer ID), **Blocked By** (block जोड़ने वाला team member) और **Blocked On** शामिल हैं।
* **Search Identifier** और **Filters**: email या customer ID से entry खोजें, या इसे ब्लॉक करने वाले व्यक्ति और समय के आधार पर filter करें।
* **Action**: entry प्रबंधित करें, जिसमें ग्राहक को unblock करना भी शामिल है।

### ब्लॉक किए गए ग्राहक का page

<Frame caption="A blocked customer's details page">
  <img src="https://mintcdn.com/dodopayments/c1t35qHSH45TR4GO/images/blocklist/blocked-customer-details.png?fit=max&auto=format&n=c1t35qHSH45TR4GO&q=85&s=83e1225a8e71c003d2bf660f0eea9c08" alt="Customer Information page for a blocked customer showing the Blocked badge, an Unblock Customer button, an Activity Log with a note and the Added to blocklist event, and a Reference IDs panel with the customer ID" style={{ maxHeight: '500px', width: 'auto' }} width="2366" height="1554" data-path="images/blocklist/blocked-customer-details.png" />
</Frame>

ब्लॉक किए गए ग्राहक को **Sales → Customers** या Blocklist page से खोलकर यह देखें:

* ग्राहक के नाम के आगे **Blocked** badge और **Unblock Customer** button।
* **Activity Log**: ग्राहक को blocklist में कब जोड़ा गया, reason और उसके बाद आपकी team द्वारा जोड़े गए कोई भी notes। नया context दर्ज करने के लिए **Add Note** पर click करें, जैसे chargeback का परिणाम। Notes को बाद में edit किया जा सकता है।
* **Reference IDs**: इस block से जुड़ी customer ID, जिसे copy करने के लिए तैयार रखा गया है।

## ग्राहक को unblock करना

ग्राहक के page पर **Unblock Customer** पर click करें या Blocklist page पर action menu का उपयोग करें।

* Checkout और Customer Portal में बदलाव तुरंत बहाल हो जाते हैं।
* **Cancelled subscriptions फिर से सक्रिय नहीं होतीं।** ग्राहक को दोबारा purchase करना होगा।
* Entry को उसके notes के साथ audit record के रूप में रखा जाता है, लेकिन यह active list में दिखाई नहीं देती।
* आप बाद में उसी ग्राहक को फिर से ब्लॉक कर सकते हैं। इससे नई entry बनती है।

## ग्राहक को क्या दिखाई देता है

ब्लॉक किए गए ग्राहक को कभी नहीं बताया जाता कि उसे ब्लॉक किया गया है।

* **Checkout पर**, payment generic decline के साथ fail होता है: "This payment cannot be processed." API HTTP `403` को error code `PAYMENT_NOT_PERMITTED` के साथ लौटाता है, जिसमें कोई कारण नहीं बताया जाता। वास्तविक reason केवल Dodo Payments के logs में लिखा जाता है।
* **Customer Portal में**, सब कुछ दिखाई देता है, लेकिन हर action disabled होता है। ब्लॉक किया गया write `PORTAL_ACTION_NOT_PERMITTED` को message "This action is not available." के साथ लौटाता है। Portal profile में `read_only: true` मौजूद होता है, ताकि custom portal integration अपने controls को disabled कर सके। Portal कभी भी blocklist entry या उसके notes को उजागर नहीं करता।

<Warning>
  यदि आप अपने product में checkout या portal errors render करते हैं, तो यही behavior बनाए रखें। `PAYMENT_NOT_PERMITTED` और `PORTAL_ACTION_NOT_PERMITTED` के लिए generic message दिखाएं। Block उजागर करने से धोखाधड़ी करने वाले व्यक्ति को अलग email आज़माने का संकेत मिल जाएगा।
</Warning>

## API का उपयोग करना

Blocklist API आपको अपने tooling से block करने की सुविधा देती है, उदाहरण के लिए chargeback आने पर। इसके लिए आपकी secret [API key](/api-reference/introduction) आवश्यक है। कोई भी key entries list कर सकती है और notes पढ़ सकती है। **write access** enabled वाली key block, unblock और notes manage कर सकती है। Dashboard team roles पर यही विभाजन लागू करता है: **Viewer** role list पढ़ता है और **Editor** role changes करता है।

| Method   | Endpoint                                          | Purpose                                                        |
| -------- | ------------------------------------------------- | -------------------------------------------------------------- |
| `GET`    | `/blocklist/customers`                            | blocked customers को filters और `total` count के साथ list करना |
| `POST`   | `/blocklist/customers`                            | customer ID या email से ग्राहक को block करना                   |
| `GET`    | `/blocklist/customers/{entry_id}`                 | notes के साथ एक entry प्राप्त करना                             |
| `DELETE` | `/blocklist/customers/{entry_id}`                 | ग्राहक को unblock करना                                         |
| `POST`   | `/blocklist/customers/{entry_id}/notes`           | note जोड़ना                                                    |
| `PATCH`  | `/blocklist/customers/{entry_id}/notes/{note_id}` | note update करना                                               |

### ग्राहक को ब्लॉक करना

Body के top level पर `customer_id` या `email` में से कोई एक भेजें। `reason` optional है और entry के page पर दिखाई देता है।

<CodeGroup>
  ```typescript Node.js theme={null}
  import DodoPayments from 'dodopayments';

  const client = new DodoPayments({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  });

  // Block by customer ID
  const entry = await client.blocklist.customers.create({
    customer_id: 'cus_0NmichXWP8JYBB9Dw1Unj',
    reason: 'Chargeback on pay_0NmichXuYoNoapmr',
  });

  // Or block by email
  const byEmail = await client.blocklist.customers.create({
    email: 'buyer@example.com',
    reason: 'Repeated refund abuse',
  });

  console.log(entry.id, entry.cancelled_subscription_ids);
  ```

  ```python Python theme={null}
  import os
  from dodopayments import DodoPayments

  client = DodoPayments(bearer_token=os.environ["DODO_PAYMENTS_API_KEY"])

  # Block by customer ID
  entry = client.blocklist.customers.create(
      customer_id="cus_0NmichXWP8JYBB9Dw1Unj",
      reason="Chargeback on pay_0NmichXuYoNoapmr",
  )

  # Or block by email
  by_email = client.blocklist.customers.create(
      email="buyer@example.com",
      reason="Repeated refund abuse",
  )

  print(entry.id, entry.cancelled_subscription_ids)
  ```

  ```bash cURL theme={null}
  curl -X POST https://live.dodopayments.com/blocklist/customers \
    -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "customer_id": "cus_0NmichXWP8JYBB9Dw1Unj",
      "reason": "Chargeback on pay_0NmichXuYoNoapmr"
    }'
  ```
</CodeGroup>

```json Response theme={null}
{
  "id": "bcu_7Hq2mV9kRt4LxYw3Pz",
  "customer_id": "cus_0NmichXWP8JYBB9Dw1Unj",
  "customer_name": "wow guy",
  "customer_email": "wowguy@example.com",
  "identifier": "cus_0NmichXWP8JYBB9Dw1Unj",
  "reason": "Chargeback on pay_0NmichXuYoNoapmr",
  "source": "api",
  "blocked_by_email": null,
  "created_at": "2026-09-02T12:09:41Z",
  "unblocked_at": null,
  "cancelled_subscription_ids": ["sub_3Fk8pW2nQs6MzXc1"],
  "subscriptions_swept": true
}
```

| Field                        | Description                                                                                                                     |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `identifier`                 | आपके द्वारा भेजी गई customer ID या email।                                                                                       |
| `source`                     | Block का स्रोत: `blocklist_page`, `customer_page`, `payment_page`, `dispute_page` या `api`। API key हमेशा `api` record करती है। |
| `blocked_by_email`           | Block जोड़ने वाला dashboard user। API key के लिए `null`।                                                                        |
| `cancelled_subscription_ids` | इस call द्वारा cancel की गई subscriptions।                                                                                      |
| `remaining_subscription_ids` | वे subscriptions जो अब भी live हैं, क्योंकि cancellation fail हुई या call अपनी 25 cancellations की limit तक पहुंच गई।           |
| `subscriptions_swept`        | जब live subscriptions बाकी हों तो `false`। Call को तब तक दोहराएं जब तक यह `true` न हो जाए। Block स्वयं पहले से लागू है।         |

<Note>
  पहले से ब्लॉक किए गए ग्राहक को block करने पर HTTP `409` और `CUSTOMER_ALREADY_BLOCKED` लौटता है, जब तक कि subscriptions अभी cancel होने की प्रतीक्षा में न हों। उस स्थिति में call cancellation को आगे जारी रखता है।
</Note>

### जांचें कि ग्राहक ब्लॉक है या नहीं

[Get Customer Detail](/api-reference/customers/get-customers-1) दो अतिरिक्त fields लौटाता है: `blocked_at`, active block जोड़े जाने का समय (जब ग्राहक ब्लॉक नहीं है तो `null`), और `blocklist_entry_id`, उसके पीछे मौजूद entry। [List Customers](/api-reference/customers/get-customers) endpoint दोनों को खाली छोड़ता है।

### ग्राहक को unblock करना

<CodeGroup>
  ```typescript Node.js theme={null}
  await client.blocklist.customers.delete('bcu_7Hq2mV9kRt4LxYw3Pz');
  ```

  ```python Python theme={null}
  client.blocklist.customers.delete("bcu_7Hq2mV9kRt4LxYw3Pz")
  ```

  ```bash cURL theme={null}
  curl -X DELETE https://live.dodopayments.com/blocklist/customers/bcu_7Hq2mV9kRt4LxYw3Pz \
    -H "Authorization: Bearer $DODO_PAYMENTS_API_KEY"
  ```
</CodeGroup>

Endpoint success पर HTTP `204` लौटाता है। Unblocking checkout और portal writes को बहाल करता है, लेकिन किसी subscription को reactivate नहीं करता।

## सर्वोत्तम practices

* **Reason record करें।** Block पर एक छोटा reason और बाद में होने वाली किसी भी घटना के लिए notes आपकी support team को dashboard छोड़े बिना पूरी जानकारी देते हैं।
* **Chargeback के बाद block करें।** Dispute या payment से ग्राहक खोलकर वहीं block करें, या `dispute.opened` webhook को `POST /blocklist/customers` के साथ automate करें। [Disputes](/features/transactions/disputes) देखें।
* **`subscriptions_swept` जांचें।** API के माध्यम से block करते समय call को तब तक दोहराएं जब तक response `true` न दिखाए, ताकि कोई live subscription बाकी न रह जाए।
* **Refund अलग से करें।** Block केवल भविष्य की purchases रोकता है। यदि ग्राहक को पैसे लौटाने हैं, तो payment का सामान्य रूप से refund करें।
* **List की समीक्षा करें।** जिन ग्राहकों की समस्या हल हो गई है उन्हें unblock करें। Unblocking तुरंत होता है और history बनी रहती है।

## संबंधित

<CardGroup cols={2}>
  <Card title="Customer Management" icon="user-group" href="/features/customers">
    किसी ग्राहक को खोजें, उसका details page खोलें और उसकी subscriptions manage करें।
  </Card>

  <Card title="Customer Portal" icon="id-card" href="/features/customer-portal">
    Portal में ब्लॉक किया गया ग्राहक क्या कर सकता है और क्या नहीं।
  </Card>

  <Card title="Disputes" icon="circle-exclamation" href="/features/transactions/disputes">
    Chargebacks का जवाब दें और तय करें कि block कब उचित है।
  </Card>

  <Card title="Error Codes" icon="triangle-exclamation" href="/api-reference/error-codes">
    `PAYMENT_NOT_PERMITTED` और `PORTAL_ACTION_NOT_PERMITTED` का अर्थ क्या है।
  </Card>
</CardGroup>
