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

# The preauth signals endpoint

export const preauth_name = "PreauthSignals";

export const get_common_parameters = (resource_name = 'resource') => {
  return {
    id: {
      name: 'id',
      type: "string",
      required: false,
      description: `Unique identifier for the ${resource_name}.`
    },
    entity_id: {
      name: 'entity_id',
      type: 'string',
      required: false,
      description: 'The ID of the associated Entity.'
    },
    account_id: {
      name: 'account_id',
      type: 'string',
      required: false,
      description: 'The ID of the associated Account.'
    },
    error: {
      name: 'error',
      type: 'object | null',
      required: false,
      description: <>
          An object representing an error that occurred while processing
          this {resource_name}. See <a href={`/reference/errors/${resource_name.replace(/^([A-Z])/, function (match) {
        return match.toLowerCase();
      }).replace(/([A-Z])/g, function (match) {
        return "-" + match.toLowerCase();
      })}-errors`}>{resource_name} errors</a>.
        </>
    },
    status_error: {
      name: 'status_error',
      type: 'object | null',
      required: false,
      description: <>
          An object representing an error that occurred while processing
          this {resource_name}. See <a href="/reference/errors/product-errors#status-errors">{resource_name} errors</a>.
        </>
    },
    metadata: {
      name: 'metadata',
      type: 'object | null',
      required: false,
      description: <>
          Additional data provided during creation.
          See <a href="/reference/metadata">metadata</a>
        </>
    },
    created_at: {
      name: 'created_at',
      type: 'string',
      required: false,
      description: `Timestamp of when the ${resource_name} was created.`
    },
    updated_at: {
      name: 'updated_at',
      type: 'string',
      required: false,
      description: `Timestamp of when the ${resource_name} was last updated.`
    },
    status: (enums = []) => ({
      name: 'status',
      type: 'enum',
      required: false,
      description: `Status of the ${resource_name}.`,
      enums
    }),
    type: (enums = []) => ({
      name: 'type',
      type: 'enum',
      required: false,
      description: `The type of ${resource_name}.`,
      enums
    })
  };
};

export const ParamList = ({items = [], is_child = false}) => {
  return items.map(item => {
    const field_props = {
      id: Math.random().toString(),
      body: item.name,
      name: item.name,
      type: item.type,
      required: item.required
    };
    const enums = item.enums || [];
    const items = item.items || [];
    const has_items = items?.length > 0;
    const has_enums = enums?.length > 0;
    const should_default_open = item.defaultOpen || false;
    const render_child_item = () => {
      const child_props = {
        title: has_enums ? "Possible enum values" : "properties"
      };
      if (should_default_open) child_props.defaultOpen = true;
      const has_inline_enums = has_enums && enums.every(enum_item => typeof enum_item === 'string') && enums.map((enum_item, idx) => {
        const is_last = idx === enums.length - 1;
        const is_2nd_to_last = idx === enums.length - 2;
        return <>
            <code>{enum_item}</code>
            {is_last && ''}
            {is_2nd_to_last && ' or '}
            {!is_last && !is_2nd_to_last && ', '}
          </>;
      });
      const enum_list = has_enums && !has_inline_enums && <Accordion {...child_props}>
          {enums.map((enum_item, index) => <div key={`enum-${index}`}>
              <code>{enum_item.name}</code>
              <br />
              <p>{enum_item.description}</p>
            </div>)}
        </Accordion>;
      const item_list = has_items && <Expandable {...child_props}>
          <ParamList items={items || []} is_child />
        </Expandable>;
      return <>
          <p>
            {item.description}
            {has_inline_enums && [has_inline_enums.length > 1 ? ' One of ' : ' Must be ', ...has_inline_enums]}
          </p>

          {enum_list}
          {item_list}
        </>;
    };
    return is_child ? <ResponseField {...field_props}>{render_child_item()}</ResponseField> : <ParamField {...field_props}>{render_child_item()}</ParamField>;
  });
};

The PreauthSignals endpoint returns the predicted likelihood that a transaction
will succeed, alongside verified ownership of the card and recommended retry timing.
It accepts either an authenticated Method Account or raw card data, with optional
purchase context to improve the prediction.

<Note>
  **Public preview.** PreauthSignals is in public preview. Contact your Method CSM to request access.
</Note>

## Data access

The fields returned by PreauthSignals are split across two tiers:

* **Identifier-based fields** — `verified_ownership` and `card_standing` run entirely on the identifiers passed in the request (an `account_id`, or `card.bin6`, `card.last4`, `card.first_name`, `card.last_name`, and `card.phone`) and return a match result and the card's open/closed status. **Available to all customers by default**, with no additional data access required.
* **Predictive components** — `success_likelihood` and `optimal_retry_date` depend on richer underlying data that not every customer is provisioned for. When the required data is not available, the endpoint returns `null` as the value for both `success_likelihood` and `optimal_retry_date`. This is a normal response state, not an error or a fallback.

**The PreauthSignals endpoint is available as a:**

| Type      | Use-Case                                                                   |
| --------- | -------------------------------------------------------------------------- |
| `Product` | On-Demand assessment of a transaction attempt for a given card or account. |

## PreauthSignals Object

<ParamList
  items={[
(get_common_parameters(preauth_name).id),
{
name: 'account_id',
type: 'string | null',
required: false,
description: (
  <>
    The ID of the associated Method Account. Returned whether passed in the request
    or generated from raw card input.
  </>
),
},
(get_common_parameters(preauth_name).status(
[
  { name: 'pending', description: 'The request is queued to be processed.' },
  { name: 'in_progress', description: 'The request is being processed.' },
  { name: 'completed', description: 'The request has successfully processed.' },
  { name: 'failed', description: 'The request failed processing.' }
]
)),
{
name: 'verified_ownership',
type: 'enum | null',
required: false,
description: 'The result of matching the provided card details to a known cardholder identity.',
enums: ['match', 'no_match', 'fuzzy_match', 'identity_not_found', 'unknown']
},
{
name: 'card_standing',
type: 'enum | null',
required: false,
description: 'Current status of the card account at the issuer.',
enums: ['open', 'closed']
},
{
name: 'success_likelihood',
type: 'number | null',
required: false,
description: 'The predicted probability that a charge will succeed under the provided conditions. Decimal 0.00 to 1.00.',
},
{
name: 'optimal_retry_date',
type: 'string | null',
required: false,
description: 'The recommended date to attempt or retry the charge. ISO 8601 date.',
},
{
name: 'error',
type: 'object | null',
required: false,
description: 'An object representing an error that occurred while processing this request.',
},
(get_common_parameters(preauth_name).metadata),
(get_common_parameters(preauth_name).created_at),
(get_common_parameters(preauth_name).updated_at),
]}
/>

<RequestExample>
  ```json The PreauthSignals Object theme={null}
  {
    "id": "preauth_qV7kRaFm4JNxw",
    "account_id": "acc_4m9amk4KFiaQX",
    "status": "completed",
    "verified_ownership": "match",
    "card_standing": "open",
    "success_likelihood": 0.87,
    "optimal_retry_date": "2026-06-02",
    "error": null,
    "metadata": null,
    "created_at": "2026-05-28T14:00:00.000Z",
    "updated_at": "2026-05-28T14:00:00.180Z"
  }
  ```
</RequestExample>